@aiwuk/team 0.0.0-stage → 5.0.3

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,141 @@
+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.timing || !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 });
+function firstToken(stream) {
+  for (const part of stream ?? []) {
+    if (part.type === 'chunk') {
+      const c = part.chunk;
+      if ((['text-delta', 'reasoning-delta'].includes(c?.type) && c.text !== '') || (c?.type === 'tool-call-delta' && (c.argumentsDelta !== '' || c.name !== undefined))) return safeTime(part.time);
+    } else {
+      if (part.type === 'tool-call-chunks' && part.name !== undefined) return safeTime(part.time0);
+      const fragments = part.type === 'tool-call-chunks' ? part.args : part.texts;
+      let time = part.time0;
+      for (let i = 0; i < (fragments?.length ?? 0); i++) { if (i) time += part.dt?.[i - 1] ?? 0; if (fragments[i] !== '') return safeTime(time); }
+    }
+  }
+  return null;
+}
+export const reportDefinition = definition('capabilityTeamReport', (h, i) => ({ ...base(h, i), ownUsage: initOwnUsage(i), openStep: null, 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' }, timing: { llmMs: 0, toolMs: 0, ttftMs: 0, ttftSteps: 0, decodeMs: 0, decodeTokens: 0 }, 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 }, timing: { ...s.view.timing }, 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 = []; next.openStep = null;
+    if (d.reason?.kind === 'error') add(v.counters, 'failedTurns', 1);
+  }
+  if (e.type === 'step/start') { add(v, 'stepsStarted', 1); next.openStep = { turn: d.turn, step: d.step, at: time, first: null }; }
+  if (e.type === 'step/end') { add(v, 'steps', 1); if (s.lastTurn !== d.turn) add(v, 'turns', 1); next.lastTurn = d.turn; next.openStep = null; }
+  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, at: time, 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 (time !== null && p.at !== null) add(v.timing, 'toolMs', time - p.at); 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);
+  if (['assistant/message', 'assistant/attempt'].includes(e.type)) {
+    const open = s.openStep;
+    if (open && open.turn === d.turn && open.step === d.step) {
+      const first = open.first ?? firstToken(d.stream);
+      next.openStep = { ...open, first };
+      if (e.type === 'assistant/message') {
+        if (time !== null && open.at !== null) add(v.timing, 'llmMs', time - open.at);
+        if (first !== null && open.at !== null) { add(v.timing, 'ttftMs', first - open.at); add(v.timing, 'ttftSteps', 1); if (d.usage?.outputTokens != null) { add(v.timing, 'decodeMs', time - first); add(v.timing, 'decodeTokens', d.usage.outputTokens); } }
+        next.openStep = null;
+      }
+    }
+  }
+  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;
+});
+reportDefinition.stateVersion = 3; // Own-session attempt-aware fold; discard v1 checkpoints.
+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;
+}

package/package.json

@@ -1,6 +1,155 @@
 {
   "name": "@aiwuk/team",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "5.0.3",
+  "description": "AIWUK Team, a capability-routed multi-agent team preset for DeepSeek Harness (DSH) with per-role model routing, same-tier failover and conversational team configuration",
+  "license": "MIT",
+  "author": "walke2019",
+  "homepage": "https://github.com/walke2019/dsh-capability-team#readme",
+  "repository": { "type": "git", "url": "git+https://github.com/walke2019/dsh-capability-team.git" },
+  "bugs": { "url": "https://github.com/walke2019/dsh-capability-team/issues" },
+  "keywords": ["aiwuk", "dsh", "dsh-plugin", "deepseek-harness", "cordis", "agent-team", "multi-agent", "model-routing", "failover", "ai-agent", "llm"],
+  "engines": { "node": ">=22", "dsh": ">=0.2.2-rc.1 <0.3.0" },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": ">=4.0.1",
+    "@deepseek-ai/dsh-agent-preset": ">=0.2.2-rc.1",
+    "@deepseek-ai/dsh-persona": ">=0.2.2-rc.1",
+    "@deepseek-ai/dsh-experimental-agent-team": ">=0.2.2-rc.1",
+    "@deepseek-ai/dsh-client-locale": ">=0.2.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-conversation": ">=0.2.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-tool": ">=0.2.2-rc.1",
+    "@deepseek-ai/dsh-api-remotes": ">=0.2.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-sidebar-right": ">=0.2.2-rc.1",
+    "@deepseek-ai/schemastery": ">=3.18.4"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": { "optional": true },
+    "@deepseek-ai/dsh-agent-preset": { "optional": true },
+    "@deepseek-ai/dsh-persona": { "optional": true },
+    "@deepseek-ai/dsh-experimental-agent-team": { "optional": true },
+    "@deepseek-ai/dsh-client-locale": { "optional": true },
+    "@deepseek-ai/dsh-client-ui-conversation": { "optional": true },
+    "@deepseek-ai/dsh-client-ui-tool": { "optional": true },
+    "@deepseek-ai/dsh-api-remotes": { "optional": true },
+    "@deepseek-ai/dsh-client-ui-sidebar-right": { "optional": true },
+    "@deepseek-ai/schemastery": { "optional": true }
+  },
+  "type": "module",
+  "scripts": {
+    "build:client": "node shared-ui/build.mjs && node scripts/build-client.mjs",
+    "pretest": "node shared-ui/build.mjs && node scripts/build-client.mjs",
+    "test": "node --import ./tests/isolated-home.mjs --test tests/*.test.mjs && node --import ./tests/isolated-home.mjs --test tests/global-memory/*.test.mjs && node --import ./tests/isolated-home.mjs --test tests/omni-search/*.test.mjs && node --import ./tests/isolated-home.mjs --test tests/autocomplete/*.test.mjs",
+    "build:global-memory": "node packages/global-memory/scripts/build-shared.mjs",
+    "build:omni-search": "node packages/omni-search/scripts/build-shared.mjs",
+    "build:autocomplete": "node packages/autocomplete/scripts/build-client.mjs",
+    "lint": "node scripts/check.mjs syntax",
+    "build": "node scripts/check.mjs package"
+  },
+  "exports": {
+    ".": "./ui.js",
+    "./client": "./client.js",
+    "./roles": "./index.js",
+    "./locale/*.json": "./locale/*.json",
+    "./i18n/*.json": "./i18n/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "brand.js",
+    "i18n.js",
+    "roles.js",
+    "lead-route.js",
+    "config.js",
+    "roster-defaults.js",
+    "single-model.js",
+    "onboarding.js",
+    "settings-schema.js",
+    "team.js",
+    "failover.js",
+    "defaults.js",
+    "index.js",
+    "free-worker.mjs",
+    "integrations.js",
+    "search.js",
+    "search-engines.js",
+    "transcribe.js",
+    "task-bridge.js",
+    "theme.js",
+    "allocation.js",
+    "theme-plugin.js",
+    "tool-schema.js",
+    "tool-names.js",
+    "workflow.js",
+    "opencode.js",
+    "ui.js",
+    "runtime-view.js",
+    "model-policy.js",
+    "access.js",
+    "teammate-wait.js",
+    "usage.js",
+    "long-context.js",
+    "plan-gate.js",
+    "template.js",
+    "config-projection.js",
+    "session-policy.js",
+    "request-evidence.js",
+    "activity-summary.js",
+    "observability-projection.js",
+    "runtime-observability.js",
+    "observability-api.js",
+    "member-task-control.js",
+    "task-control-audit.js",
+    "task-control-api.js",
+    "client.js",
+    "client/*.js",
+    "file-limits.js",
+    "dispatch-confirm.js",
+    "dispatch-routes-store.js",
+    "session-rotation.js",
+    "memory-embed.js",
+    "memory-store.js",
+    "memory-hub.js",
+    "memory-openviking.js",
+    "memory-backends.js",
+    "preset-guard.js",
+    "token-metrics.js",
+    "memory-sync-queue.js",
+    "memory-redact.js",
+    "integrations-config.js",
+    "integrations-messages.js",
+    "managed-resolve.js",
+    "managed-ref.js",
+    "managed-config-route.js",
+    "shared/managed-config.js",
+    "http-guard.js",
+    "model-prefs.js",
+    "board-dispatch.js",
+    "teammate-context.js",
+    "token-discipline.js",
+    "route-health.js",
+    "skills/project-role-theme/SKILL.md",
+    "README.md",
+    "README.zh-CN.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "scripts/memory-cli.mjs",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "i18n/*.json",
+    "icon.svg"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-tool",
+        "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-client-ui-sidebar-right"
+      ]
+    }
+  }
+}