@aiwuk/team 0.0.0-stage → 5.0.8

package/memory-sync-queue.js

@@ -0,0 +1,28 @@
+import { mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { randomUUID } from 'node:crypto';
+// Atomic disk snapshots; overflow is explicit and never silently drops older messages.
+export function createSyncQueue(path, { max = 200, warn = () => {} } = {}) {
+  let rows = [], revoked = [];
+  if (path) {
+    try { const saved = JSON.parse(readFileSync(path, 'utf8')); rows = saved.rows ?? []; revoked = saved.revoked ?? []; }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+  }
+  const persist = () => {
+    if (!path) return;
+    mkdirSync(dirname(path), { recursive: true });
+    const temp = `${path}.${randomUUID()}.tmp`;
+    writeFileSync(temp, JSON.stringify({ rows, revoked }), { mode: 0o600 }); renameSync(temp, path);
+  };
+  return {
+    push(row) {
+      if (rows.length >= max) { warn('OpenViking sync queue full; memory retained locally'); throw new Error('OpenViking sync queue full'); }
+      rows.push({ ...row, queueId: randomUUID() }); persist();
+    },
+    peek: (n = 40) => rows.slice(0, n),
+    ack(batch) { const ids = new Set(batch.map(r => r.queueId)); rows = rows.filter(r => !ids.has(r.queueId)); persist(); },
+    revoke(texts) { revoked = [...new Set([...revoked, ...texts])]; persist(); },
+    revoked: () => [...revoked],
+    size: () => rows.length,
+  };
+}

package/model-policy.js

@@ -0,0 +1,85 @@
+import { m as modelText } from './i18n.js';
+// The (profile-wide) model policy is applied to a resolved role before the failover state chooses a route.
+// Entries are exact provider/model routes, or prefix rules ending in "*" that match either the full
+// route or the bare model id (so "@cf/*" covers every provider). No lower-tier substitution.
+export const routeKey = route => `${route.provider}/${route.model}`;
+export const isPrefixRule = entry => entry.endsWith('*');
+export function validateDisabledRoutes(value) {
+  if (!Array.isArray(value) || value.length > 2000) throw new Error(modelText('model-policy.311'));
+  for (const v of value) {
+    if (typeof v !== 'string' || !v.trim() || v.length > 512 || /[\r\n\0\s]/.test(v)) throw new Error(modelText('model-policy.312'));
+    if (isPrefixRule(v)) {
+      if (v.length < 3 || v.slice(0, -1).includes('*')) throw new Error(modelText('model-policy.313', { 0: v }));
+    } else if (!v.includes('/') || v.includes('*')) throw new Error(modelText('model-policy.314'));
+  }
+  return [...new Set(value)].sort();
+}
+/** Predicate over provider/model keys for a validated disabled list. */
+export function routeMatcher(disabledRoutes = []) {
+  const exact = new Set(), prefixes = [];
+  for (const entry of validateDisabledRoutes(disabledRoutes)) (isPrefixRule(entry) ? prefixes.push(entry.slice(0, -1)) : exact.add(entry));
+  return key => {
+    if (exact.has(key)) return true;
+    const model = key.slice(key.indexOf('/') + 1);
+    return prefixes.some(p => key.startsWith(p) || model.startsWith(p));
+  };
+}
+export function applyModelPolicy(role, disabledRoutes = []) {
+  const disabled = routeMatcher(disabledRoutes);
+  if (role.unassigned || !role.provider || !role.model) return role;
+  const candidates = [{ provider: role.provider, model: role.model }, ...(role.fallbacks ?? [])];
+  const allowed = candidates.filter(r => !disabled(routeKey(r)));
+  if (!allowed.length) throw new Error(modelText('model-policy.315', { 0: role.displayName ?? role.id }));
+  const [primary, ...fallbacks] = allowed;
+  // A disabled long-context route is dropped; requests then stay on the allowed primary and backups.
+  const { longContext, ...rest } = role;
+  const keep = longContext && !disabled(routeKey(longContext)) ? { longContext } : {};
+  return { ...rest, ...primary, fallbacks, ...keep, policyExcluded: candidates.filter(r => disabled(routeKey(r))).map(routeKey) };
+}
+/** Roles as requests see them under the policy: excluded routes dropped, roles with no allowed route marked blocked. */
+export function policyRoleView(roles, disabledRoutes = []) {
+  return roles.map(role => {
+    try { return applyModelPolicy(role, disabledRoutes); }
+    catch (error) { return { ...role, provider: undefined, model: undefined, fallbacks: [], blocked: error.message }; }
+  });
+}
+export function allocationPreview(roles, disabledRoutes) {
+  return roles.map(role => {
+    try {
+      const resolved = applyModelPolicy(role, disabledRoutes);
+      return { id: role.id, displayName: role.displayName ?? role.id,
+        status: resolved.provider && resolved.model ? 'eligible' : 'unassigned',
+        primary: resolved.provider && resolved.model ? routeKey(resolved) : null,
+        fallbacks: (resolved.fallbacks ?? []).map(routeKey) };
+    } catch (error) {
+      return { id: role.id, displayName: role.displayName ?? role.id, status: 'blocked', primary: null, fallbacks: [], reason: error.message };
+    }
+  });
+}
+export function modelPolicyRows(tiers, roles, disabledRoutes = [], catalog = []) {
+  const disabledList = validateDisabledRoutes(disabledRoutes);
+  const isDisabled = routeMatcher(disabledList);
+  const rows = new Map();
+  for (const entry of catalog) {
+    const slash = typeof entry === 'string' ? entry.indexOf('/') : -1;
+    const candidate = typeof entry === 'string'
+      ? { provider: entry.slice(0, slash), model: entry.slice(slash + 1) } : entry;
+    if (!candidate?.provider || !candidate.model || (typeof entry === 'string' && slash < 1)) continue;
+    const key = routeKey(candidate);
+    rows.set(key, { key, provider: candidate.provider, model: candidate.model,
+      tiers: candidate.tier ? [candidate.tier] : [], primaryFor: [], fallbackFor: [],
+      disabled: isDisabled(key), verified: false });
+  }
+  for (const role of roles) {
+    if (!role.provider || !role.model) continue;
+    for (const [index, route] of [{ provider: role.provider, model: role.model }, ...(role.fallbacks ?? [])].entries()) {
+      const key = routeKey(route);
+      const row = rows.get(key) ?? { key, provider: route.provider, model: route.model, tiers: [], primaryFor: [], fallbackFor: [], disabled: isDisabled(key), verified: false };
+      if (!row.tiers.includes(role.tier)) row.tiers.push(role.tier);
+      row[index === 0 ? 'primaryFor' : 'fallbackFor'].push(role.id);
+      rows.set(key, row);
+    }
+  }
+  // Catalog tier membership may contain unallocated IDs; don't invent a provider for them.
+  return { rows: [...rows.values()], tierCatalog: tiers, disabledRoutes: disabledList, allocations: allocationPreview(roles, disabledRoutes) };
+}

package/model-prefs.js

@@ -0,0 +1,104 @@
+import { m as modelText } from './i18n.js';
+// Learned model preferences: every confirmed dispatch records, per capability, which primary and fallbacks the
+// user chose. Later confirmation cards preselect a habit (a primary chosen at least twice and in most recent
+// choices) unless that route keeps failing, and suggest saving it as the project default once it is settled.
+// Nothing is applied silently: the card still asks, and the learned data can be cleared.
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export const PREF_LIMITS = { keep: 20, window: 10, minCount: 2, settled: 3, unhealthyStrikes: 2 };
+const routeKey = r => (r ? `${r.provider}/${r.model}` : null);
+const parse = key => { const i = key.indexOf('/'); return { provider: key.slice(0, i), model: key.slice(i + 1) }; };
+/** Habit for one capability from its recent choices, or undefined. Pure. */
+export function habitOf(choices, limits = PREF_LIMITS) {
+  const recent = (choices ?? []).slice(-limits.window);
+  if (!recent.length) return undefined;
+  const counts = new Map();
+  for (const c of recent) counts.set(c.primary, (counts.get(c.primary) ?? 0) + 1);
+  const [primary, count] = [...counts].sort((a, b) => b[1] - a[1] || recent.findLastIndex(c => c.primary === b[0]) - recent.findLastIndex(c => c.primary === a[0]))[0];
+  if (count < limits.minCount || count * 2 < recent.length) return undefined;
+  const last = recent.findLast(c => c.primary === primary);
+  const tail = recent.slice(-limits.settled);
+  const settled = tail.length === limits.settled && tail.every(c => c.primary === primary && c.fallbacks.join() === last.fallbacks.join());
+  return { primary, fallbacks: last.fallbacks, count, of: recent.length, settled };
+}
+/** Health notes for routes: strikes from the failover layer; a route is unhealthy at PREF_LIMITS.unhealthyStrikes. */
+export function unhealthyRoutes(health = {}, limits = PREF_LIMITS) {
+  // A credential failure (wrong or missing key) stays bad until fixed, so one is enough.
+  return Object.fromEntries(Object.entries(health).filter(([, h]) => h.cooling || h.credential || (h.strikes ?? 0) >= limits.unhealthyStrikes).map(([k, h]) => [k, h.strikes ?? 1]));
+}
+/**
+ * Apply learning to one offered row: preselect the habit when every route in it is offered and healthy, and
+ * move unhealthy fallbacks to the end. Returns a new row with `learned` notes for the card.
+ */
+export function applyPreferences(row, habit, unhealthy) {
+  const offeredKeys = new Set([routeKey(row.primary), ...row.fallbacks.map(routeKey), ...row.candidates.map(routeKey)].filter(Boolean));
+  const learned = { unhealthy: Object.fromEntries(Object.entries(unhealthy).filter(([k]) => offeredKeys.has(k))) };
+  let primary = row.primary, fallbacks = row.fallbacks;
+  if (habit && offeredKeys.has(habit.primary) && !unhealthy[habit.primary] && habit.fallbacks.every(k => offeredKeys.has(k))) {
+    learned.habit = { count: habit.count, of: habit.of, settled: habit.settled };
+    if (habit.primary !== routeKey(primary) || habit.fallbacks.join() !== fallbacks.map(routeKey).join()) {
+      primary = parse(habit.primary); fallbacks = habit.fallbacks.filter(k => k !== habit.primary).map(parse); learned.preselected = true;
+    }
+  }
+  fallbacks = [...fallbacks.filter(f => !unhealthy[routeKey(f)]), ...fallbacks.filter(f => unhealthy[routeKey(f)])];
+  return { ...row, primary, fallbacks, learned };
+}
+export function createModelPrefs(root) {
+  const pathOf = project => join(root, 'model-prefs', `${createHash('sha256').update(project).digest('hex').slice(0, 32)}.json`);
+  async function read(project) {
+    try { const d = JSON.parse(await readFile(pathOf(project), 'utf8')); return d && typeof d.byCapability === 'object' ? d : { byCapability: {} }; }
+    catch (error) { if (error.code === 'ENOENT' || error instanceof SyntaxError) return { byCapability: {} }; throw error; }
+  }
+  async function write(project, data) {
+    const path = pathOf(project);
+    await mkdir(join(root, 'model-prefs'), { recursive: true });
+    const temp = `${path}.${randomUUID()}.tmp`;
+    try { await writeFile(temp, JSON.stringify(data, null, 2) + '\n'); await rename(temp, path); }
+    finally { await unlink(temp).catch(() => {}); }
+  }
+  let queue = Promise.resolve();
+  const serial = fn => (queue = queue.catch(() => {}).then(fn));
+  return {
+    read,
+    /** Habit per capability for a project. */
+    async habits(project) {
+      // Wait for queued records so a habit read right after a confirmation sees it (rename timing differs by OS).
+      await queue.catch(() => {});
+      const data = await read(project);
+      return Object.fromEntries(Object.entries(data.byCapability).map(([cap, v]) => [cap, habitOf(v.choices)]).filter(([, h]) => h));
+    },
+    /** Record the confirmed routes of one dispatch (each capability once). */
+    record(project, routes, at = Date.now()) {
+      return serial(async () => {
+        const data = await read(project);
+        const seen = new Set();
+        for (const r of routes) {
+          if (!r.primary || seen.has(r.capability)) continue;
+          seen.add(r.capability);
+          const entry = (data.byCapability[r.capability] ??= { choices: [] });
+          entry.choices = [...entry.choices, { primary: routeKey(r.primary), fallbacks: r.fallbacks.map(routeKey), changed: !!r.changed, at }].slice(-PREF_LIMITS.keep);
+        }
+        await write(project, data);
+      });
+    },
+    clear(project) { return serial(() => unlink(pathOf(project)).catch(error => { if (error.code !== 'ENOENT') throw error; })); },
+  };
+}
+const output = { schema: { type: 'string' }, render: (_a, v) => [{ type: 'text', text: v }] };
+/** Lead tool to show or clear what was learned for the current project. */
+export function applyModelPrefsTool(ctx, team, prefs) {
+  ctx.effect(() => ctx.tools.register({ name: 'capability_model_prefs', output,
+    description: modelText('model-prefs.316'),
+    parameters: { type: 'object', properties: { action: { type: 'string', enum: ['read', 'clear'] } }, required: ['action'], additionalProperties: false },
+    async execute(args, exec) {
+      const project = await team.pin(exec.agent);
+      if (args.action === 'clear') {
+        if (ctx.agentTeams.tryMembership(exec.agent)?.role !== 'lead') throw new Error(modelText('model-prefs.317'));
+        await prefs.clear(project);
+        return JSON.stringify({ cleared: true, project });
+      }
+      return JSON.stringify({ project, habits: await prefs.habits(project) });
+    },
+  }));
+}

package/observability-api.js

@@ -0,0 +1,76 @@
+import { runtimeBinding } from './runtime-observability.js';
+import { safeId } from './activity-summary.js';
+export const RUNTIME_PATH = '/api/capability-team.runtime';
+export const RUNTIME_STREAM_PATH = `${RUNTIME_PATH}/stream`;
+/** Epoch of the placeholder snapshot of a team lead whose runtime is not bound yet (a draft session before its first message). */
+export const UNBOUND_EPOCH = 'unbound';
+const UNBOUND_POLL_MS = 1000;
+/** Empty but well-formed snapshot: the Team overview renders "no activity yet" instead of an error. */
+export function emptySnapshot(leadSessionId) {
+  return { schemaVersion: 1, leadSessionId, epoch: UNBOUND_EPOCH, revision: 0, generatedAt: 0, coverage: { mode: 'unbound', since: 0 }, members: [], taskControl: null };
+}
+function resolve(ctx, request) {
+  const url = new URL(request.url), ids = url.searchParams.getAll('sessionId');
+  if (ids.length !== 1 || !safeId(ids[0]) || [...url.searchParams.keys()].some(k => k !== 'sessionId')) return { error: 400 };
+  // Never resolve/activate a session from user-controlled input.
+  const agent = ctx.get?.('agents')?.get(ids[0]);
+  if (!agent) return { error: 404 };
+  const teams = ctx.get?.('agentTeams');
+  if (!teams || !ctx.agentPresets) return { error: 503 };
+  const membership = teams.tryMembership(agent);
+  if (!membership || membership.role !== 'lead' || ctx.agentPresets?.composedPreset(agent.ctx) !== 'capability-team') return { error: 404 };
+  // A draft lead has no runtime until its first message: answer with an empty snapshot, not an error.
+  const current = () => runtimeBinding(agent);
+  const snapshot = () => { const binding = current(); return binding ? binding.runtime.snapshot(agent.id, teams.listMembers(agent)) : emptySnapshot(agent.id); };
+  return { current, agent, snapshot };
+}
+export function handleRuntime(ctx, request, stream = false) {
+  if (request.method !== 'GET') return new Response('method not allowed', { status: 405 });
+  // In production Connection refuses non-owner peers before invoking any registered fetch route.
+  let resolved;
+  try { resolved = resolve(ctx, request); } catch { return Response.json({ error: 503 }, { status: 503 }); }
+  if (resolved.error) return Response.json({ error: resolved.error }, { status: resolved.error, headers: { 'cache-control': 'no-store' } });
+  if (!stream) {
+    try { return Response.json(resolved.snapshot(), { headers: { 'cache-control': 'no-store' } }); }
+    catch { return Response.json({ error: 503 }, { status: 503 }); }
+  }
+  let dispose = () => {}, timer = null, poll = null, closed = false, abortCleanup = () => {};
+  const body = new ReadableStream({
+    start(controller) {
+      const encoder = new TextEncoder();
+      const close = () => { if (closed) return; closed = true; if (timer) clearTimeout(timer); if (poll) clearInterval(poll); dispose(); request.signal.removeEventListener('abort', close); controller.close(); };
+      const emit = () => {
+        timer = null; if (closed) return;
+        try { controller.enqueue(encoder.encode(`data: ${JSON.stringify(resolved.snapshot())}\n\n`)); }
+        catch { close(); }
+      };
+      emit();
+      const attach = binding => { dispose = binding.runtime.onChanged(() => { if (!closed && timer === null) timer = setTimeout(emit, 350); }); };
+      const bound = resolved.current();
+      if (bound) attach(bound);
+      else {
+        // Idle until the lead's runtime appears (first message), then push the real snapshot and follow its changes.
+        poll = setInterval(() => {
+          if (closed) return;
+          const binding = resolved.current();
+          if (!binding) return;
+          clearInterval(poll); poll = null; attach(binding); emit();
+        }, UNBOUND_POLL_MS);
+        poll.unref?.();
+      }
+      abortCleanup = () => request.signal.removeEventListener('abort', close);
+      request.signal.addEventListener('abort', close, { once: true });
+      if (request.signal.aborted) close();
+    },
+    cancel() { closed = true; if (timer) clearTimeout(timer); if (poll) clearInterval(poll); dispose(); abortCleanup(); },
+  });
+  return new Response(body, { headers: { 'content-type': 'text/event-stream', 'cache-control': 'no-store', 'x-accel-buffering': 'no' } });
+}
+export function applyObservabilityApi(ctx) {
+  ctx.inject?.(['connection', 'agents', 'agentTeams', 'agentPresets'], scoped => {
+    for (const [path, stream] of [[RUNTIME_PATH, false], [RUNTIME_STREAM_PATH, true]]) {
+      // Host createSharedFetchHandler enforces peer.principal.kind === 'owner'.
+      scoped.connection.fetch.register({ path, methods: ['GET'], requestBody: 'buffered', fetch: request => Promise.resolve(handleRuntime(scoped, request, stream)) });
+    }
+  });
+}

package/observability-projection.js

@@ -0,0 +1,116 @@
+import { t } from './i18n.js';
+import { safeId, safeTarget, safeTime, summarizeActivity } from './activity-summary.js';
+import { isolatedProjection } from './preset-guard.js';
+import { OWN_USAGE_KEY, initOwnUsage, applyOwnUsage, ownUsageView } from './usage.js';
+const schema = { parse(v) { if (!v || typeof v !== 'object' || Array.isArray(v)) throw new Error('Invalid observability state'); return v; } };
+const n = x => typeof x === 'number' && x >= 0 ? Math.min(x, Number.MAX_SAFE_INTEGER) : 0;
+const base = (header = {}, inherited = 0) => ({ sessionId: safeId(header.id) ?? 'unknown', cwd: header.cwd ?? null, root: header.cwd ?? null, inherited, cursor: -1 });
+const ignored = (s, e) => !Number.isSafeInteger(e.seq) || e.seq < s.inherited || e.seq <= s.cursor;
+const coord = x => Number.isSafeInteger(x) && x >= 0 ? x : null;
+const callId = e => safeId(e.data?.message?.source?.callId ?? e.data?.message?.toolCallId);
+const definition = (key, init, apply) => ({ key, stateVersion: 1,
+  stateSchema: { parse(value) {
+    schema.parse(value);
+    if (!Number.isSafeInteger(value.inherited) || value.inherited < 0 || !Number.isSafeInteger(value.cursor) || value.cursor < -1 || !value.view || value.view.schemaVersion !== 1) throw new Error('Invalid observability checkpoint');
+    if (key === 'capabilityTeamActivity' && (!Array.isArray(value.pending) || value.pending.length > 64 || !Array.isArray(value.view.recent) || value.view.recent.length > 8)) throw new Error('Invalid activity checkpoint');
+    if (key === 'capabilityTeamArtifacts' && (!Array.isArray(value.view.items) || value.view.items.length > 20 || !Array.isArray(value.view.changes) || value.view.changes.length > 10)) throw new Error('Invalid artifacts checkpoint');
+    if (key === 'capabilityTeamReport' && (!Array.isArray(value.pending) || value.pending.length > 64 || !value.view.usage || !value.view.counters)) throw new Error('Invalid report checkpoint');
+    if (Buffer.byteLength(JSON.stringify(value.view)) > 32768) throw new Error('Oversized observability checkpoint');
+    return value;
+  } }, init, apply, wire: { viewSchema: schema, view: s => s.view } });
+const cwdChange = (s, e) => e.type === 'working-directory/change' ? { ...s, cwd: e.data?.cwd ?? e.data?.path ?? null, cursor: e.seq } : null;
+export const activityDefinition = definition('capabilityTeamActivity', (h, i) => ({ ...base(h, i), pending: [], view: { schemaVersion: 1, phase: 'idle', current: null, recent: [], activeCount: 0, truncated: false } }), (s, e) => {
+  if (ignored(s, e)) return s;
+  const cwd = cwdChange(s, e); if (cwd) return cwd;
+  const d = e.data ?? {}; let pending = s.pending, recent = s.view.recent, phase = s.view.phase, truncated = s.view.truncated;
+  if (e.type === 'tool/call') {
+    const id = safeId(d.callId); if (!id) return s;
+    const item = { id: `${s.sessionId}:${e.seq}`, callId: id, callSeq: e.seq, ...summarizeActivity(d.name, d.arguments, s.cwd, s.root), startedAt: safeTime(e.time), endedAt: null, status: 'running', turn: coord(d.turn), step: coord(d.step) };
+    pending = [...pending.filter(p => p.callId !== id), item];
+    if (pending.length > 64) { pending = pending.slice(-64); truncated = true; }
+    const history = [item, ...recent.filter(p => p.callId !== id)];
+    if (history.length > 8) truncated = true;
+    recent = history.slice(0, 8); phase = 'tool';
+  } else if (e.type === 'tool/result') {
+    const id = callId(e), item = pending.find(p => p.callId === id); if (!item) return s;
+    pending = pending.filter(p => p.callId !== id);
+    const done = { ...item, endedAt: safeTime(e.time), status: d.message?.isError ? 'failed' : 'succeeded' };
+    const history = [done, ...recent.filter(p => p.id !== item.id)];
+    if (history.length > 8) truncated = true;
+    recent = history.slice(0, 8); phase = pending.length ? 'tool' : 'model';
+  } else if (e.type === 'step/start') phase = pending.length ? 'tool' : 'model';
+  else if (e.type === 'step/end') phase = pending.length ? 'tool' : 'settled';
+  else if (e.type === 'turn/end') {
+    const ids = new Set(pending.map(p => p.id));
+    recent = recent.map(p => ids.has(p.id) ? { ...p, endedAt: safeTime(e.time), status: d.reason?.kind === 'cancelled' || d.reason?.kind === 'interrupted' ? 'interrupted' : 'unknown' } : p);
+    pending = []; phase = 'settled';
+  } else return s;
+  return { ...s, cursor: e.seq, pending, view: { schemaVersion: 1, phase, current: recent[0] ?? null, recent, activeCount: pending.length, truncated } };
+});
+export const artifactsDefinition = definition('capabilityTeamArtifacts', (h, i) => ({ ...base(h, i), view: { schemaVersion: 1, items: [], changes: [], truncated: false } }), (s, e) => {
+  if (ignored(s, e)) return s;
+  const cwd = cwdChange(s, e); if (cwd) return cwd;
+  const d = e.data ?? {}; let { items, changes, truncated } = s.view;
+  if (e.type === 'workspace/changes') {
+    changes = [{ seq: e.seq, turn: coord(d.turn), at: safeTime(e.time) }, ...changes];
+    if (changes.length > 10) { changes = changes.slice(0, 10); truncated = true; }
+  } else if (e.type === 'deliverables/presented' && Array.isArray(d.files)) {
+    const additions = [];
+    for (let index = 0; index < Math.min(d.files.length, 256); index++) {
+      const file = d.files[index]; const relative = safeTarget(file?.path, s.cwd, 4096, s.root);
+      if (!relative || relative === t('observability-projection.318')) continue;
+      additions.push({ id: `${s.sessionId}:${e.seq}:${index}`, sessionId: s.sessionId, presentSeq: e.seq, fileIndex: index, turn: coord(d.turn), at: safeTime(e.time), path: file.path, displayPath: relative.slice(0, 240), changeRef: null });
+    }
+    items = [...additions, ...items];
+    if (items.length > 20 || d.files.length > 256) { items = items.slice(0, 20); truncated = true; }
+    // A UTF-8 byte ceiling, not merely a character limit.
+    while (Buffer.byteLength(JSON.stringify({ items, changes })) > 31000) { items.pop(); truncated = true; }
+  } else return s;
+  return { ...s, cursor: e.seq, view: { schemaVersion: 1, items, changes, truncated } };
+});
+const zeroUsage = () => ({ uncachedInputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, outputTokens: 0 });
+export const reportDefinition = definition('capabilityTeamReport', (h, i) => ({ ...base(h, i), ownUsage: initOwnUsage(i), pending: [], lastTurn: null, view: { schemaVersion: 1, scope: 'own-session-events', firstTurnAt: null, lastTurnEndAt: null, openTurnAt: null, completedTurnMs: 0, turns: 0, steps: 0, stepsStarted: 0, usage: zeroUsage(), usageCoverage: { reportedSamples: 0, attemptsWithoutUsage: 0, coverage: 'unknown' }, counters: { hostRetriesStarted: 0, failedTurns: 0, sendMessageAccepted: 0, boardMutations: h?.origin === 'subagent' ? null : 0 }, truncated: false } }), (s, e) => {
+  if (ignored(s, e)) return s;
+  const relevant = ['request/header', 'turn/start', 'turn/end', 'step/start', 'step/end', 'assistant/attempt', 'assistant/message', 'llm/retry-started', 'tool/call', 'tool/result', 'team/task'];
+  if (!relevant.includes(e.type)) return s;
+  const d = e.data ?? {}, v = { ...s.view, usage: { ...s.view.usage }, counters: { ...s.view.counters } };
+  const next = { ...s, cursor: e.seq, view: v }; const time = safeTime(e.time);
+  const add = (obj, key, value) => { if (typeof value === 'number' && value > Number.MAX_SAFE_INTEGER) v.truncated = true; const sum = obj[key] + n(value); if (!Number.isFinite(sum) || sum > Number.MAX_SAFE_INTEGER) v.truncated = true; obj[key] = n(sum); };
+  if (e.type === 'turn/start') { v.firstTurnAt ??= time; v.openTurnAt = time; }
+  if (e.type === 'turn/end') {
+    if (v.openTurnAt !== null && time !== null) add(v, 'completedTurnMs', Math.max(0, time - v.openTurnAt));
+    v.openTurnAt = null; v.lastTurnEndAt = time; next.pending = [];
+    if (d.reason?.kind === 'error') add(v.counters, 'failedTurns', 1);
+  }
+  if (e.type === 'step/start') { add(v, 'stepsStarted', 1); }
+  if (e.type === 'step/end') { add(v, 'steps', 1); if (s.lastTurn !== d.turn) add(v, 'turns', 1); next.lastTurn = d.turn; }
+  if (e.type === 'llm/retry-started') { add(v.counters, 'hostRetriesStarted', 1);  }
+  if (e.type === 'tool/call' && safeId(d.callId)) {
+    next.pending = [...s.pending, { id: d.callId, send: d.name === 'send_message' }].slice(-64);
+    if (s.pending.length >= 64) v.truncated = true;
+  }
+  if (e.type === 'tool/result') {
+    const id = callId(e), p = s.pending.find(p => p.id === id);
+    if (p) { next.pending = s.pending.filter(p => p.id !== id); if (p.send && !d.message?.isError) add(v.counters, 'sendMessageAccepted', 1); }
+  }
+  if (e.type === 'team/task' && v.counters.boardMutations !== null) add(v.counters, 'boardMutations', 1);
+  next.ownUsage = applyOwnUsage(s.ownUsage, e);
+  v.usage = next.ownUsage.totals;
+  v.truncated ||= next.ownUsage.truncated;
+  v.usageCoverage = { reportedSamples: next.ownUsage.reportedSamples, attemptsWithoutUsage: next.ownUsage.attemptsWithoutUsage, coverage: next.ownUsage.coverage };
+  return next;
+});
+// Own-session attempt-aware fold. v4 dropped the `timing` view: turn/step wall times come from DSH's native `sessionStats` projection.
+reportDefinition.stateVersion = 4;
+export const ownUsageDefinition = {
+  key: OWN_USAGE_KEY, stateVersion: 1, stateSchema: { parse(v) { schema.parse(v); if (!Number.isSafeInteger(v.inherited) || !v.totals || !Array.isArray(v.routes)) throw new Error('Invalid own usage checkpoint'); return v; } },
+  init: (_header, inherited) => { const s = initOwnUsage(inherited); return { ...s, view: ownUsageView(s) }; },
+  apply: (s, e) => { const next = applyOwnUsage(s, e); return next === s ? s : { ...next, view: ownUsageView(next) }; },
+  wire: { viewSchema: schema, view: s => s.view },
+};
+export const observabilityDefinitions = [activityDefinition, artifactsDefinition, reportDefinition, ownUsageDefinition];
+export function applyObservabilityProjections(ctx) {
+  ctx.inject?.(['sessionProjections'], scoped => {
+    for (const def of observabilityDefinitions) scoped.effect(() => scoped.sessionProjections.register(isolatedProjection(ctx, def)), `capability-team: ${def.key}`);
+  });
+}

package/onboarding.js

@@ -0,0 +1,47 @@
+// Profile-wide first-run status for the Web onboarding card: whether DSH's official Agent Teams service is
+// running, the official bundle's selection state, and how far the live model catalog covers the default tiers.
+// Read-only: enabling the bundle is a user click in the browser through DSH's own pluginManager Remote.
+import { seed } from './config.js';
+import { autoMatch } from './defaults.js';
+export const ONBOARDING_PATH = '/api/capability-team.onboarding';
+export const AGENT_TEAM_BUNDLE = '@deepseek-ai/dsh-experimental-agent-team-profile';
+/** The official bundle row from pluginManager.listBundles(), reduced to what the card needs. */
+export async function teamBundleStatus(pluginManager) {
+  if (typeof pluginManager?.listBundles !== 'function') return { known: false };
+  try {
+    const listed = await pluginManager.listBundles();
+    const rows = Array.isArray(listed) ? listed : listed?.ok ? listed.value : [];
+    const row = rows.find(b => b?.name === AGENT_TEAM_BUNDLE);
+    if (!row) return { known: true, listed: false };
+    return { known: true, listed: true, enabled: !!row.enabled, installed: !!row.installed, availability: row.availability ?? null, ...(row.error?.code ? { error: row.error.code } : {}) };
+  } catch (error) { return { known: false, error: String(error?.message ?? error).slice(0, 200) }; }
+}
+/** Tier coverage of the seed capabilities against the live catalog; no model is called. */
+export async function tierCoverage(llm, capabilities = seed.capabilities) {
+  if (typeof llm?.listProviders !== 'function') return { known: false };
+  const entries = []; const errors = [];
+  for (const provider of llm.listProviders()) {
+    try { for (const m of await llm.listModels(provider.id)) entries.push({ provider: provider.id, model: m.id }); }
+    catch { errors.push(provider.id); }
+  }
+  const { report } = autoMatch(entries, capabilities);
+  const unassigned = report.filter(r => r.status === 'unassigned').map(r => r.capability);
+  return { known: true, models: entries.length, capabilities: report.length, covered: report.length - unassigned.length, unassigned, ...(errors.length ? { catalogErrors: errors } : {}) };
+}
+/** Everything the onboarding card shows; each part degrades to `known: false` instead of failing. */
+export async function onboardingStatus(ctx) {
+  const selection = (() => { try { return ctx.get?.('agentDefaultModel')?.currentSelection?.(); } catch { return undefined; } })();
+  return {
+    teamServicePresent: !!ctx.get?.('agentTeams'),
+    bundle: await teamBundleStatus(ctx.get?.('pluginManager')),
+    coverage: await tierCoverage(ctx.get?.('llm')).catch(() => ({ known: false })),
+    ...(selection?.provider && selection?.model ? { defaultModel: `${selection.provider}/${selection.model}` } : {}),
+  };
+}
+export function applyOnboardingApi(ctx) {
+  ctx.inject?.(['connection'], scoped => scoped.connection.fetch.register({ path: ONBOARDING_PATH, methods: ['GET'], requestBody: 'buffered',
+    fetch: async () => {
+      try { return Response.json(await onboardingStatus(ctx), { headers: { 'cache-control': 'no-store' } }); }
+      catch { return Response.json({ code: 'UNAVAILABLE' }, { status: 503 }); }
+    } }));
+}

package/opencode.js

@@ -0,0 +1,74 @@
+import { m as modelText } from './i18n.js';
+// Locating OpenCode and its free models on any platform. Nothing here names a user, a machine or a
+// fixed model list: the executable comes from an env override or PATH, the models from OpenCode's own
+// catalog cache, filtered to zero-cost, non-deprecated entries.
+import { access, readFile, constants } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { posix, win32 } from 'node:path';
+
+const ENV_EXE = 'CAPABILITY_TEAM_OPENCODE_EXECUTABLE';
+const ENV_CATALOG = 'CAPABILITY_TEAM_OPENCODE_MODELS';
+const pathApi = platform => (platform === 'win32' ? win32 : posix);
+
+/** Candidate native executables, most specific first. Shell shims (.cmd/.ps1) are never returned. */
+export function openCodeCandidates({ env = process.env, platform = process.platform, home = homedir() } = {}) {
+  const p = pathApi(platform);
+  const dirs = (env.PATH ?? env.Path ?? '').split(p.delimiter).filter(Boolean);
+  const list = [];
+  for (const dir of dirs) {
+    if (platform === 'win32') {
+      list.push(p.join(dir, 'opencode.exe'));
+      // npm on Windows puts a .cmd shim on PATH; the native binary sits in the package next to it.
+      list.push(p.join(dir, 'node_modules', 'opencode-ai', 'bin', 'opencode.exe'));
+    } else list.push(p.join(dir, 'opencode'));
+  }
+  // Location used by the official install script on every platform.
+  list.push(p.join(home, '.opencode', 'bin', platform === 'win32' ? 'opencode.exe' : 'opencode'));
+  return [...new Set(list)];
+}
+
+export async function findOpenCode({ env = process.env, platform = process.platform, home = homedir(), exists = defaultExists(platform) } = {}) {
+  if (env[ENV_EXE]) return env[ENV_EXE];
+  for (const file of openCodeCandidates({ env, platform, home })) if (await exists(file)) return file;
+  throw new Error(modelText('opencode.319', { 0: ENV_EXE }));
+}
+function defaultExists(platform) {
+  return file => access(file, platform === 'win32' ? constants.F_OK : constants.X_OK).then(() => true, () => false);
+}
+
+/** OpenCode keeps its model catalog under the XDG cache directory on all platforms. */
+export function catalogFile({ env = process.env, platform = process.platform, home = homedir() } = {}) {
+  if (env[ENV_CATALOG]) return env[ENV_CATALOG];
+  const p = pathApi(platform);
+  return p.join(env.XDG_CACHE_HOME || p.join(home, '.cache'), 'opencode', 'models.json');
+}
+
+const isZero = v => v === undefined || v === 0;
+/** Zero-cost, non-deprecated, tool-capable models of OpenCode's own provider, newest first. */
+export function freeModelsFromCatalog(catalog) {
+  const models = catalog?.opencode?.models ?? {};
+  return Object.entries(models)
+    .filter(([, m]) => m && m.cost && m.cost.input === 0 && m.cost.output === 0 && isZero(m.cost.cache_read) && isZero(m.cost.cache_write)
+      && m.status !== 'deprecated' && m.tool_call !== false)
+    .sort(([a, x], [b, y]) => String(y.release_date ?? '').localeCompare(String(x.release_date ?? '')) || a.localeCompare(b))
+    .map(([id]) => `opencode/${id}`);
+}
+
+/**
+ * Models the free channel may use. A configured list only orders and narrows; every entry must still be
+ * free in the catalog, so a paid model can never be configured in by mistake.
+ */
+export async function resolveFreeModels(configured = [], { file = catalogFile(), read = readFile } = {}) {
+  let catalog;
+  try { catalog = JSON.parse(await read(file, 'utf8')); } catch (error) {
+    throw new Error(modelText('opencode.320', { 0: file, 1: error.code ?? error.message, 2: ENV_CATALOG }));
+  }
+  const free = freeModelsFromCatalog(catalog);
+  if (!configured.length) {
+    if (!free.length) throw new Error(modelText('opencode.321'));
+    return free;
+  }
+  const rejected = configured.filter(m => !free.includes(m));
+  if (rejected.length) throw new Error(modelText('opencode.322', { 0: rejected.join('、'), 1: free.join('、') || modelText('opencode.323') }));
+  return configured;
+}