@aiwuk/team 0.0.0-stage → 5.0.3

package/defaults.js

@@ -0,0 +1,222 @@
+import { m as modelText } from './i18n.js';
+// Default matching rules: classify whatever chat models the user's DSH channels expose
+// (official APIs, OpenAI-compatible gateways, self-hosted relays) into capability tiers,
+// then fill every capability that has no explicit route with a primary and same-tier backups.
+//
+// Rules key on vendor naming conventions, never on one user's channel names or catalog.
+// Naming snapshot: 2026-10 (checked against the OpenRouter public catalog). Vendors rename their
+// lines between generations, so each rule lists both the current and the previous scheme.
+// "Current" is relative to the user's own catalog: when a newer major version of the same vendor
+// is present, older ones count as legacy (one tier lower, ranked last). Unknown ids are reported.
+import { routeMatcher } from './model-policy.js';
+
+/** Non-chat or non-agent models are never candidates. */
+// Also excluded: voice-only Live models, robotics, managed agents (deep-research, antigravity),
+// restricted specialty models (daybreak, rosalind, gpt-5.6-cyber), roleplay (-her) and models without tool calling
+// (grok multi-agent): a team member must be able to call tools.
+const NON_CHAT = /(image|imagine|video|veo|sora|dall-?e|tts|speech|voice|audio|realtime|transcri|whisper|embed|rerank|moderation|safety|guard|ocr|banana|lyria|auto-review|computer-use|search-preview|-lora\b|(^|-)live($|-)|translate|robotics|deep-research|antigravity|daybreak|rosalind|-her\b|multi-agent|-cyber\b)/;
+/** Free / trial variants are unreliable for routing. */
+const FREE = /(^|[-:_/])free($|[-:_])/;
+
+/** Turn any gateway spelling into one comparable id. */
+export function normalizeModelId(id) {
+  let s = String(id).toLowerCase().trim();
+  s = s.replace(/:(free|beta|extended|thinking|online|nitro|floor|batch)$/, '');
+  s = s.slice(s.lastIndexOf('/') + 1); // anthropic/…, bai/…, pro/deepseek-ai/…, accounts/x/models/…
+  s = s.replace(/^models[-_]/, '');
+  s = s.replace(/-(\d{4}-\d{2}-\d{2}|\d{8}|\d{6})(?=$|-)/g, ''); // dated snapshots
+  s = s.replace(/-(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])(?=$|-)/g, ''); // MMDD snapshots
+  s = s.replace(/-chat-latest$/, '');
+  s = s.replace(/(\d)-(\d)(?=$|-[a-z])/g, '$1.$2'); // claude-opus-4-5 → 4.5
+  return s;
+}
+const strip = s => s.replace(/\b(a)?\d+(\.\d+)?[bkmt]\b/g, ' ').replace(/\d{3,}/g, ' ');
+function versionOf(norm) {
+  const m = strip(norm.replace(/-\d{3}$/, '')).match(/\d+(?:\.\d+)?/); // drop revision suffixes like -001
+  return m ? Number(m[0]) : undefined;
+}
+/** Total parameters in billions, for open-weight sizing (`-32b`, `-2.4t-a95b`). */
+function paramsOf(norm) {
+  const m = norm.match(/(?:^|[-_])(\d+(?:\.\d+)?)([bt])(?:$|[-_])/);
+  return m ? Number(m[1]) * (m[2] === 't' ? 1000 : 1) : undefined;
+}
+const bySize = (norm, fallback) => {
+  const p = paramsOf(norm);
+  return p === undefined ? fallback : p <= 40 ? 'low' : p <= 150 ? 'medium' : 'upper';
+};
+/** Effort / speed / mode variants of one model share an identity, so they never fill two backup slots. */
+const MODES = /-(xhigh|high|medium|low|minimal|max|thinking|reasoning|non-reasoning|nothink|instruct|it|preview|exp|latest|ultraspeed|fast|customtools)$/;
+
+/**
+ * Vendor rules, checked in order; the first matching class wins, so line names precede suffixes.
+ * `floor`: versions below it are too old for agent work and are excluded.
+ * `modes`: vendor-specific suffixes that are a mode of the same model rather than another tier.
+ */
+export const VENDOR_RULES = Object.freeze([
+  // Claude: Opus / Fable flagship, Sonnet main, Haiku light.
+  { vendor: 'claude', match: /^claude-/, floor: 4, base: 'upper',
+    classes: [[/(opus|fable)/, 'high'], [/sonnet/, 'upper'], [/haiku/, 'low']] },
+  // OpenAI GPT-6+: astra flagship, sol main, terra balanced, luna light; "-pro" exists on every
+  // line at the same price, so it is a reasoning mode. GPT-5.x: -pro flagship, -mini, -nano.
+  { vendor: 'gpt', match: /^(gpt|chatgpt)-(?!oss)/, floor: 5, base: 'upper', modes: /-pro$/,
+    classes: [[/-astra/, 'high'], [/-sol/, 'upper'], [/-terra/, 'medium'], [/-luna/, 'low'],
+      [/-pro\b/, 'high'], [/-nano\b/, 'low'], [/-(mini|instant|chat)\b/, 'medium']] },
+  { vendor: 'gpt-oss', match: /^gpt-oss/, base: 'medium', size: true },
+  // Gemini 4 names its flagship by codename (gemini-4-argon); 3.x used -pro. Flash / Flash-Lite below.
+  // gemini-omni-* is video generation, not chat.
+  { vendor: 'gemini', match: /^gemini-/, exclude: /omni/, floor: 3, base: 'upper',
+    classes: [[/(flash-lite|-lite\b|-nano\b)/, 'low'], [/flash/, 'medium'], [/(pro|ultra)/, 'high'], [/^gemini-\d+(\.\d+)?-[a-z]+($|-)/, 'high']] },
+  // Grok's own version is the number after "grok-"; product lines (grok-build-0.1, grok-composer-2.5)
+  // carry their own numbering and are treated as versionless.
+  { vendor: 'grok', match: /^grok-/, version: /^grok-(\d+(?:\.\d+)?)/, floor: 4, base: 'upper',
+    classes: [[/heavy/, 'high'], [/mini/, 'low'], [/(build|composer|code|non-reasoning)/, 'medium']] },
+  // DeepSeek Flash is a full general model sold cheaply, not a trimmed mini: balanced tier.
+  // Official API ids (2026-10): versionless `deepseek-flash` (now V4.1-Flash-1017) and `deepseek-v4-pro`;
+  // the old `deepseek-v4-flash` id is retired and silently served by V4.1 Flash.
+  { vendor: 'deepseek', match: /^deepseek-/, floor: 3, base: 'upper',
+    classes: [[/distill/, 'low'], [/(flash|lite)/, 'medium']] },
+  // Other Chinese vendors' "-flash" lines are their light models (~0.1/0.5 per M), unlike Gemini Flash.
+  { vendor: 'qwen', match: /^(qwen|qwq)/, floor: 3, base: 'upper', size: true,
+    classes: [[/(max|prime|coder)/, 'upper'], [/plus/, 'medium'], [/(turbo|flash)/, 'low']] },
+  { vendor: 'kimi', match: /^(kimi-|moonshot-)/, floor: 2, base: 'upper', classes: [[/(turbo|mini)/, 'medium']] },
+  { vendor: 'glm', match: /^glm-/, floor: 4.5, base: 'upper', classes: [[/flashx/, 'medium'], [/flash/, 'low'], [/air/, 'medium']] },
+  { vendor: 'minimax', match: /^minimax-/, floor: 2, base: 'upper', classes: [[/flash/, 'low']] },
+  { vendor: 'mimo', match: /^mimo-/, floor: 2, base: 'medium', classes: [[/pro/, 'upper'], [/flash/, 'low']] },
+  { vendor: 'doubao', match: /^doubao-/, base: 'upper', classes: [[/lite/, 'low'], [/flash/, 'medium']] },
+  { vendor: 'mistral', match: /^(mistral|magistral|codestral|devstral|ministral)/, base: 'medium', size: true,
+    classes: [[/large/, 'upper'], [/medium/, 'medium'], [/(small|ministral|tiny)/, 'low']] },
+  // NVIDIA Nemotron (often `llama-3.3-nemotron-super-…`): checked before Llama so the line name wins.
+  { vendor: 'nemotron', match: /nemotron/, version: /(?!)/, base: 'medium', size: true,
+    classes: [[/ultra/, 'upper'], [/super/, 'medium'], [/(nano|mini)/, 'low']] },
+  // StepFun Step 3+ (`step3`, `step-3.5-flash`): the Flash line is a large MoE, so it sits in the balanced tier.
+  { vendor: 'stepfun', match: /^step-?\d/, floor: 3, base: 'upper', classes: [[/(mini|lite)/, 'low'], [/flash/, 'medium']] },
+  // Cohere Command: A is the current flagship line; R / R+ and the 7B are older or light. Digits in both\n  // Nemotron and Command ids are base-model versions or dates, so they are treated as versionless.
+  { vendor: 'cohere', match: /^(c4ai-)?command-/, version: /(?!)/, base: 'medium',
+    classes: [[/command-a/, 'upper'], [/(r7b|light)/, 'low'], [/command-r-plus/, 'medium'], [/command-r\b/, 'low']] },
+  { vendor: 'llama', match: /^(llama|meta-llama)/, floor: 4, base: 'medium', size: true },
+  { vendor: 'gemma', match: /^gemma/, floor: 4, base: 'low', size: true },
+]);
+export const TIER_ORDER = Object.freeze(['low', 'medium', 'upper', 'high']);
+const down = tier => TIER_ORDER[Math.max(0, TIER_ORDER.indexOf(tier) - 1)];
+
+/**
+ * Why a model can never serve as a team member's route unless a project lists it in `tiers` itself: non-chat
+ * models cannot call tools and free/trial variants are unreliable. Old versions and unknown vendors are not
+ * refused here: they are merely left ungraded, and a user may pick them explicitly.
+ */
+export function unroutableReason(modelId) {
+  if (FREE.test(String(modelId).toLowerCase())) return modelText('defaults.160');
+  const norm = normalizeModelId(modelId);
+  if (NON_CHAT.test(norm) || VENDOR_RULES.find(r => r.match.test(norm))?.exclude?.test(norm)) return modelText('defaults.161');
+  return undefined;
+}
+/** Classify one id on its own; generation (legacy) is decided against the whole catalog in autoMatch. */
+export function classify(modelId, { rules = VENDOR_RULES, allowFree = false } = {}) {
+  const raw = String(modelId).toLowerCase();
+  if (!allowFree && FREE.test(raw)) return undefined;
+  const norm = normalizeModelId(modelId);
+  if (NON_CHAT.test(norm)) return undefined;
+  const rule = rules.find(r => r.match.test(norm));
+  if (!rule || rule.exclude?.test(norm)) return undefined;
+  const version = rule.version ? (m => (m ? Number(m[1]) : undefined))(norm.match(rule.version)) : versionOf(norm);
+  if (rule.floor !== undefined && version !== undefined && version < rule.floor) return undefined;
+  const hit = (rule.classes ?? []).find(([re]) => re.test(norm));
+  const tier = hit ? hit[1] : rule.size ? bySize(norm, rule.base) : rule.base;
+  let family = norm;
+  for (let prev; prev !== family;) { prev = family; family = family.replace(MODES, ''); if (rule.modes) family = family.replace(rule.modes, ''); }
+  return { norm, family, vendor: rule.vendor, tier, version };
+}
+
+/**
+ * A model is legacy only when the same vendor line (same vendor, same tier) has a newer major in
+ * this catalog: gemini-3.1-pro is legacy next to gemini-4-argon, but gemini-3.8-flash is not, because
+ * no Gemini 4 Flash exists. Legacy models drop one tier and rank last.
+ */
+function markGenerations(candidates) {
+  const newest = {};
+  const line = c => `${c.vendor}\u0000${c.tier}`;
+  for (const c of candidates) if (c.version !== undefined) newest[line(c)] = Math.max(newest[line(c)] ?? 0, Math.floor(c.version));
+  for (const c of candidates) {
+    if (c.version !== undefined && Math.floor(c.version) < newest[line(c)]) { c.legacy = true; c.tier = down(c.tier); }
+  }
+  // Within one major, an older minor of the same line (deepseek-v4-flash next to v4.1-flash) stays in
+  // its tier but is marked superseded: it ranks after every current model, as a last-resort backup.
+  const lineKey = c => `${c.vendor}\u0000${c.tier}\u0000${c.family.replace(/\d+(\.\d+)?/g, '#')}`;
+  const latest = {};
+  for (const c of candidates) if (c.version !== undefined && !c.legacy) latest[lineKey(c)] = Math.max(latest[lineKey(c)] ?? 0, c.version);
+  for (const c of candidates) if (c.version !== undefined && !c.legacy && c.version < latest[lineKey(c)]) c.superseded = true;
+  return candidates;
+}
+
+/** Pick an order inside one tier: current generation, preferred vendor, newer version, provider order. */
+function ranker(prefer, providerOrder) {
+  const pref = v => { const i = prefer.indexOf(v); return i < 0 ? prefer.length : i; };
+  const prov = p => { const i = providerOrder.indexOf(p); return i < 0 ? providerOrder.length : i; };
+  // A bare id beats its mode variants (gpt-6.1-sol before gpt-6.1-sol-pro) as the default primary.
+  const variant = c => Number(c.norm !== c.family);
+  // `-latest` aliases point at a moving target that may include previews: use stable ids first.
+  // A plain versionless id (DeepSeek's official `deepseek-flash`) is the vendor's stable name, not penalized.
+  const alias = c => Number(/latest/.test(c.norm));
+  const old = c => Number(!!c.legacy) * 2 + Number(!!c.superseded);
+  return (a, b) => old(a) - old(b) || alias(a) - alias(b) || pref(a.vendor) - pref(b.vendor) || (b.version ?? 0) - (a.version ?? 0)
+    || variant(a) - variant(b) || prov(a.provider) - prov(b.provider) || a.model.localeCompare(b.model);
+}
+export const MAX_AUTO_FALLBACKS = 3;
+/** Same-tier backups: the primary's own model on another channel first, then other vendors, then the rest. */
+export function pickFallbacks(pool, primary, limit = MAX_AUTO_FALLBACKS) {
+  const rest = pool.filter(c => !(c.provider === primary.provider && c.model === primary.model));
+  // Same model on another channel first: identical behavior, only the route differs.
+  const same = rest.filter(c => c.norm === primary.norm && c.provider !== primary.provider).slice(0, 1);
+  const seen = new Set([primary.family]); const distinct = [];
+  for (const c of rest) if (!seen.has(c.family)) { seen.add(c.family); distinct.push(c); }
+  const current = distinct.filter(c => !c.legacy && !c.superseded && !/latest/.test(c.norm));
+  const others = current.filter(c => c.vendor !== primary.vendor);
+  // One model per other vendor first, so a single vendor outage cannot take out every backup.
+  const vendors = new Set(); const spread = [];
+  for (const c of others) if (!vendors.has(c.vendor)) { vendors.add(c.vendor); spread.push(c); }
+  const order = [...same, ...spread, ...others.filter(c => !spread.includes(c)), ...current.filter(c => c.vendor === primary.vendor),
+    ...distinct.filter(c => !current.includes(c))];
+  return order.slice(0, limit).map(({ provider, model }) => ({ provider, model }));
+}
+
+/**
+ * Match the live catalog to capabilities.
+ * @param entries [{provider, model}] in DSH provider registration order
+ * @param capabilities {id: {tier, prefer?}} the required tier per capability
+ * Never downgrades: an empty tier moves the capability up to the nearest non-empty higher tier.
+ */
+export function autoMatch(entries, capabilities, options = {}) {
+  const candidates = [];
+  const unknown = []; const seen = new Set();
+  for (const e of entries) {
+    const id = `${e.provider}\u0000${e.model}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const c = classify(e.model, options);
+    if (c) candidates.push({ provider: e.provider, model: e.model, ...c });
+    else unknown.push(`${e.provider}/${e.model}`);
+  }
+  markGenerations(candidates);
+  const providerOrder = [...new Set(entries.map(e => e.provider))];
+  const tiers = Object.fromEntries(TIER_ORDER.map(t => [t, [...new Set(candidates.filter(c => c.tier === t).map(c => c.model))]]));
+  const disabled = routeMatcher(options.disabledRoutes ?? []);
+  const eligible = candidates.filter(c => !disabled(`${c.provider}/${c.model}`));
+  const routes = {}; const report = [];
+  for (const [id, cap] of Object.entries(capabilities)) {
+    const start = TIER_ORDER.indexOf(cap.tier);
+    if (start < 0) { report.push({ capability: id, status: 'unassigned', reason: modelText('defaults.162', { 0: cap.tier }) }); continue; }
+    const has = t => eligible.some(c => c.tier === t);
+    // Never fill a required capability with a lower tier just to make the roster look ready.
+    const tier = TIER_ORDER.slice(start).find(has);
+    if (!tier) { report.push({ capability: id, status: 'unassigned', reason: modelText('defaults.163', { 0: cap.tier }) }); continue; }
+    const pool = eligible.filter(c => c.tier === tier).sort(ranker(cap.prefer ?? [], providerOrder));
+    const [primary] = pool;
+    const fallbacks = pickFallbacks(pool, primary);
+    const delta = TIER_ORDER.indexOf(tier) - start;
+    const status = delta === 0 ? 'matched' : delta > 0 ? 'upgraded' : 'below-tier';
+    const reason = { matched: undefined, upgraded: modelText('defaults.164', { 0: cap.tier, 1: tier }), 'below-tier': modelText('defaults.165', { 0: cap.tier, 1: tier }) }[status];
+    routes[id] = { provider: primary.provider, model: primary.model, tier, fallbacks };
+    report.push({ capability: id, status, tier, primary: `${primary.provider}/${primary.model}`, fallbacks: fallbacks.map(f => `${f.provider}/${f.model}`), ...(reason ? { reason } : {}) });
+  }
+  return { tiers, routes, pools: candidates, report, unknown };
+}

package/dispatch-confirm.js

@@ -0,0 +1,293 @@
+import { m as modelText, t } from './i18n.js';
+// Dispatch confirmation: before a delegate plan takes effect, the user sees every assigned role with its
+// primary model and up to three fallbacks, and may change them for this task or save them as the project
+// default. The Web card answers over api/capability-team.dispatch-confirm; hosts without the card fall back
+// to DSH's native question box. Confirmed per-task routes live in memory per Lead and are applied by
+// team.resolve before the global model policy, so disabled models stay disabled.
+import { crossSiteRequest } from './http-guard.js';
+import { createHash } from 'node:crypto';
+import { modelCatalog, verifyRoutes } from './allocation.js';
+import { routeKey, routeMatcher } from './model-policy.js';
+import { saveProject } from './theme.js';
+import { applyPreferences, unhealthyRoutes } from './model-prefs.js';
+export const DISPATCH_CONFIRM_PATH = '/api/capability-team.dispatch-confirm';
+export { CONFIRM_MODES } from './config.js';
+export const MAX_ROUTE_FALLBACKS = 3;
+const CARD_GRACE_MS = 8000; // no card asked for the request in this time → the host has no card; use the question box
+const HEARTBEAT_MS = 15000; // a card that stopped polling this long ago is gone (tab closed, page left); use the question box
+const CONFIRM_TIMEOUT_MS = 10 * 60 * 1000; // nobody answers at all → fail instead of hanging the Lead's turn forever
+const leads = new Map(); // lead id → { pending: Map(callId → request), routes: Map(role → route), confirmed: Map(role → key) }
+let routeStore; // optional persistence for per-task routes (dispatch-routes-store.js), set by the plugin
+/** Persist confirmed per-task routes so they survive a DSH restart; `undefined` keeps them in memory only. */
+export function setRouteStore(store) { routeStore = store; }
+const stateOf = id => {
+  if (!leads.has(id)) {
+    const saved = routeStore?.load(id);
+    leads.set(id, { pending: new Map(), routes: new Map(saved?.routes ?? []), confirmed: new Map(saved?.confirmed ?? []) });
+  }
+  return leads.get(id);
+};
+const sameRoute = (a, b) => a?.provider === b?.provider && a?.model === b?.model;
+const keyOf = r => JSON.stringify([r.primary ? routeKey(r.primary) : null, r.fallbacks.map(routeKey)]);
+export const parseRoute = text => {
+  const s = String(text ?? '').trim(); const i = s.indexOf('/');
+  return i > 0 && i < s.length - 1 && !/\s/.test(s) ? { provider: s.slice(0, i), model: s.slice(i + 1) } : undefined;
+};
+/** Per-task route the user confirmed for a member of this Lead, if any. */
+export function confirmedRoute(leadId, role) { return (leads.has(leadId) || routeStore ? stateOf(leadId) : undefined)?.routes.get(role); }
+/** Apply a confirmed per-task route to a resolved role (before the model policy). */
+export function withConfirmedRoute(role, route) {
+  if (!route?.primary) return role;
+  return { ...role, provider: route.primary.provider, model: route.primary.model, fallbacks: route.fallbacks, confirmedByUser: true };
+}
+export function forgetLead(leadId) { leads.delete(leadId); }
+/** The roles of a delegate plan with their effective routes and same-tier candidates. */
+export function planRoutes(plan, effective, disabledRoutes, catalog) {
+  const disabled = routeMatcher(disabledRoutes);
+  return plan.assignments.map(a => {
+    const c = effective.capabilities[a.capability];
+    const tierModels = effective.tiers[c.tier] ?? [];
+    const candidates = catalog.entries.filter(e => !disabled(routeKey(e)))
+      .map(e => ({ provider: e.provider, model: e.model, sameTier: tierModels.includes(e.model) }))
+      .sort((a, b) => Number(b.sameTier) - Number(a.sameTier));
+    const allowed = [...(c.provider ? [{ provider: c.provider, model: c.model }] : []), ...(c.fallbacks ?? [])].filter(r => !disabled(routeKey(r)));
+    return { role: a.role, displayName: a.displayName, capability: a.capability, tier: c.tier, task: a.task,
+      primary: allowed[0] ?? null, fallbacks: allowed.slice(1, 1 + MAX_ROUTE_FALLBACKS), candidates };
+  });
+}
+/** Validate the user's answer against the offered candidates; returns normalized routes or throws. */
+export function validateAnswer(offered, answer) {
+  if (!answer || typeof answer !== 'object') throw new Error(modelText('dispatch-confirm.166'));
+  if (answer.decision === 'cancel') return { decision: 'cancel' };
+  if (answer.decision !== 'confirm') throw new Error(modelText('dispatch-confirm.167'));
+  const scope = answer.scope ?? 'task';
+  if (!['task', 'project'].includes(scope)) throw new Error(modelText('dispatch-confirm.168'));
+  const given = new Map((Array.isArray(answer.routes) ? answer.routes : []).map(r => [r?.role, r]));
+  const routes = offered.map(o => {
+    const r = given.get(o.role);
+    const chosen = r ?? { primary: o.primary, fallbacks: o.fallbacks };
+    const allowed = route => o.candidates.some(c => sameRoute(c, route));
+    const primary = typeof chosen.primary === 'string' ? parseRoute(chosen.primary) : chosen.primary;
+    if (!primary?.provider || !primary?.model || !allowed(primary)) throw new Error(modelText('dispatch-confirm.169', { 0: o.displayName ?? o.role, 1: primary ? routeKey(primary) : String(chosen.primary) }));
+    const list = (Array.isArray(chosen.fallbacks) ? chosen.fallbacks : []).map(f => (typeof f === 'string' ? parseRoute(f) : f));
+    if (list.length > MAX_ROUTE_FALLBACKS) throw new Error(modelText('dispatch-confirm.170', { 0: o.displayName ?? o.role, 1: MAX_ROUTE_FALLBACKS }));
+    const seen = new Set([routeKey(primary)]);
+    for (const f of list) {
+      if (!f?.provider || !f?.model || !allowed(f)) throw new Error(modelText('dispatch-confirm.171', { 0: o.displayName ?? o.role, 1: f ? routeKey(f) : '?' }));
+      if (seen.has(routeKey(f))) throw new Error(modelText('dispatch-confirm.172', { 0: o.displayName ?? o.role, 1: routeKey(f) }));
+      seen.add(routeKey(f));
+    }
+    if (scope === 'project' && [primary, ...list].some(route => o.candidates.find(c => sameRoute(c, route))?.sameTier === false))
+      throw new Error(modelText('dispatch-confirm.173'));
+    // Compared with the configured route, so a preselected habit still counts as a change when saved as default.
+    const ref = o.base ?? o;
+    const changed = !sameRoute(primary, ref.primary) || keyOf({ primary, fallbacks: list }) !== keyOf(ref);
+    return { role: o.role, capability: o.capability, primary, fallbacks: list, changed };
+  });
+  if (scope === 'project') {
+    const byCap = new Map();
+    for (const r of routes.filter(x => x.changed)) {
+      const prior = byCap.get(r.capability);
+      if (prior && keyOf(prior) !== keyOf(r)) throw new Error(modelText('dispatch-confirm.174', { 0: r.capability }));
+      byCap.set(r.capability, r);
+    }
+  }
+  return { decision: 'confirm', scope, routes };
+}
+/** Public view of a pending request for the card; without a callId, the Lead's latest one (for the composer dock). */
+export function pendingView(leadId, callId) {
+  const pending = leads.get(leadId)?.pending;
+  if (!callId && pending?.size) callId = [...pending.keys()].at(-1);
+  const request = pending?.get(callId);
+  if (!request) return { schemaVersion: 1, status: 'none' };
+  request.lastSeenAt = Date.now(); // heartbeat: the card keeps polling while it is on screen
+  // The native question box is already open for this request: the card only points there, so one question has one place to answer.
+  const native = request.nativeAsked === true && request.nativeFailed !== true;
+  if (request.kind === 'direct') return { schemaVersion: 1, status: 'pending', kind: 'direct', callId, native, analysis: request.plan.analysis, reason: request.plan.reason };
+  return { schemaVersion: 1, status: 'pending', callId, native, catalogVersion: request.catalogVersion, maxFallbacks: MAX_ROUTE_FALLBACKS, routes: request.offered };
+}
+/** Resolve a pending request with the card's answer; throws (with status) when it cannot. */
+export function answerPending(leadId, callId, answer) {
+  const request = leads.get(leadId)?.pending.get(callId);
+  if (!request) throw Object.assign(new Error(modelText('dispatch-confirm.175')), { status: 404, code: 'NOT_FOUND' });
+  if (answer?.catalogVersion !== undefined && answer.catalogVersion !== request.catalogVersion) throw Object.assign(new Error(modelText('dispatch-confirm.176')), { status: 409, code: 'CONFLICT' });
+  let result;
+  try { result = request.validate(answer); } catch (error) { throw Object.assign(error, { status: 422, code: 'INVALID' }); }
+  request.resolve(result);
+  return { schemaVersion: 1, status: 'resolved', decision: result.decision };
+}
+const fallbackText = r => r.fallbacks.length ? r.fallbacks.map(routeKey).join('、') : t('dispatch-confirm.177');
+const routeLine = r => t('dispatch-confirm.178', { 0: r.displayName ?? r.role, 1: r.capability, 2: r.primary ? routeKey(r.primary) : t('dispatch-confirm.179'), 3: fallbackText(r) });
+/** Native question box: confirm as offered, or type changes as "role: primary, fallback1, fallback2". */
+async function askNative(userQuestions, exec, offered, signal) {
+  const answer = await userQuestions.ask({ agent: exec.agent, signal, questions: [{
+    id: 'dispatch', header: t('dispatch-confirm.180'),
+    question: t('dispatch-confirm.181'),
+    detail: offered.map(routeLine).join('\n'),
+    options: [{ label: t('dispatch-confirm.182') }, { label: t('dispatch-confirm.183') }, { label: t('dispatch-confirm.184') }, { label: t('dispatch-confirm.185') }],
+  }] });
+  const item = answer.answers.find(a => a.id === 'dispatch');
+  const choice = item?.selected?.[0];
+  if (!choice || choice === t('dispatch-confirm.186')) return { decision: 'cancel', note: item?.custom };
+  if (choice === t('dispatch-confirm.187')) return { decision: 'confirm', scope: 'task', routes: [] };
+  const routes = String(item.custom ?? '').split(/\n|；|;/).map(line => line.trim()).filter(Boolean).map(line => {
+    const [role, rest = ''] = line.split(/[:：]/);
+    const [primary, ...fallbacks] = rest.split(/[,，、]/).map(s => s.trim()).filter(Boolean);
+    return { role: role.trim(), primary, fallbacks };
+  });
+  return { decision: 'confirm', scope: choice === t('dispatch-confirm.188') ? 'project' : 'task', routes };
+}
+/** The Lead's request to work without its step limit has one question: allow or refuse. */
+export function validateDirectAnswer(answer) {
+  if (answer?.decision !== 'confirm' && answer?.decision !== 'cancel') throw new Error(modelText('dispatch-confirm.189'));
+  return { decision: answer.decision };
+}
+async function askDirectNative(userQuestions, exec, plan, signal) {
+  const answer = await userQuestions.ask({ agent: exec.agent, signal, questions: [{
+    id: 'direct', header: t('dispatch-confirm.190'),
+    question: t('dispatch-confirm.191'),
+    detail: t('dispatch-confirm.192', { 0: plan.analysis, 1: plan.reason }),
+    options: [{ label: t('dispatch-confirm.193') }, { label: t('dispatch-confirm.194') }],
+  }] });
+  return { decision: answer.answers.find(a => a.id === 'direct')?.selected?.[0] === t('dispatch-confirm.195') ? 'confirm' : 'cancel' };
+}
+const minutesOf = ms => Number((ms / 60000).toFixed(1));
+/**
+ * Register a pending request and wait for its answer from the card or the native question box. Every exit
+ * (answer, cancel, timeout, abort) clears the abort listener, both timers and the pending entry, and aborts an
+ * open native question box so no stale dialog is left behind.
+ */
+function waitForAnswer(ctx, state, exec, callId, spec, { graceMs, heartbeatMs, timeoutMs }) {
+  const startedAt = Date.now();
+  const native = new AbortController(); // ends the native question box when the request ends any other way
+  let settled = false, deadline, check, onAbort, nativeError;
+  const request = { ...spec, lastSeenAt: undefined, nativeAsked: false };
+  const cleanup = () => {
+    clearTimeout(deadline); clearInterval(check);
+    if (onAbort) exec.signal?.removeEventListener?.('abort', onAbort);
+    if (state.pending.get(callId) === request) state.pending.delete(callId);
+    native.abort();
+  };
+  return new Promise((resolve, reject) => {
+    const finish = (fn, value) => { if (settled) return; settled = true; cleanup(); fn(value); };
+    request.resolve = value => finish(resolve, value);
+    const fail = error => finish(reject, error);
+    if (exec.signal?.aborted) { fail(new Error(modelText('dispatch-confirm.196', { 0: spec.subject }))); return; }
+    state.pending.set(callId, request);
+    onAbort = () => fail(new Error(modelText('dispatch-confirm.197', { 0: spec.subject })));
+    exec.signal?.addEventListener?.('abort', onAbort, { once: true });
+    deadline = setTimeout(() => fail(new Error(modelText('dispatch-confirm.198', { 0: spec.subject, 1: minutesOf(timeoutMs), 2: spec.consequence })
+      + `${nativeError ? modelText('dispatch-confirm.199', { 0: nativeError.code ?? nativeError.message }) : ''}${spec.retry}`)), timeoutMs);
+    deadline.unref?.();
+    // Only a card that never showed up within graceMs means the host has no card: then ask once in the native
+    // question box. A card that was seen keeps the request even when its heartbeat stalls (background tabs throttle
+    // timers), so the user never gets the same question twice; the overall timeout still ends an abandoned wait.
+    // heartbeatMs stays accepted for callers but no longer triggers the fallback.
+    void heartbeatMs;
+    const cardGone = () => request.lastSeenAt === undefined && Date.now() - startedAt >= graceMs;
+    check = setInterval(() => {
+      if (settled || request.nativeAsked || !ctx.userQuestions?.ask || !cardGone()) return;
+      request.nativeAsked = true; // asked at most once: a second dialog for the same plan would only confuse
+      clearInterval(check);
+      spec.ask(native.signal).then(answer => {
+        if (settled) return;
+        try { request.resolve(spec.validate(answer)); } catch (error) { fail(error); }
+      }, error => {
+        // The question box failed (e.g. NO_PROVIDER when no client is attached, or it was dismissed by the host).
+        // That is not the user's answer: the card can still answer while the request is pending (the user may
+        // reopen the conversation), so keep waiting; the overall timeout still ends the wait with a clear error.
+        if (!settled) { nativeError = error; request.nativeFailed = true; }
+      });
+    }, Math.max(5, Math.min(1000, graceMs, heartbeatMs)));
+    check.unref?.();
+  });
+}
+export function createDispatchConfirm(ctx, team, { graceMs = CARD_GRACE_MS, heartbeatMs = HEARTBEAT_MS, timeoutMs = CONFIRM_TIMEOUT_MS, prefs, health = () => ({}) } = {}) {
+  async function saveDefaults(exec, routes) {
+    const changed = routes.filter(r => r.changed);
+    if (!changed.length) return null;
+    const project = await team.pin(exec.agent);
+    const { revision } = await team.load(exec.agent);
+    const capabilities = Object.fromEntries(changed.map(r => [r.capability, { provider: r.primary.provider, model: r.primary.model, fallbacks: r.fallbacks }]));
+    const result = await saveProject(project, { capabilities }, revision, { base: team.base, root: team.root,
+      async check(_before, after) { verifyRoutes(changed.flatMap(r => [r.primary, ...r.fallbacks].map(x => ({ ...x, capability: r.capability }))), await modelCatalog(ctx.llm, after.tiers)); } });
+    return result.revision;
+  }
+  return {
+    /** Ask the user whether the Lead may finish this turn without its step limit; throws unless they allow it. */
+    async confirmDirect(exec, plan) {
+      const callId = exec.callId ?? `direct-${Date.now()}`;
+      const result = await waitForAnswer(ctx, stateOf(exec.agent.id), exec, callId, { kind: 'direct', plan, subject: modelText('dispatch-confirm.200'), consequence: modelText('dispatch-confirm.201'), retry: modelText('dispatch-confirm.202'),
+        validate: validateDirectAnswer, ask: signal => askDirectNative(ctx.userQuestions, exec, plan, signal) }, { graceMs, heartbeatMs, timeoutMs });
+      if (result.decision === 'cancel') throw new Error(modelText('dispatch-confirm.203'));
+      return true;
+    },
+    /**
+     * Ask the user to confirm a delegate plan. Resolves with the confirmed routes (applied to this Lead),
+     * or throws when the user cancels. `mode` is workflow.confirmDispatch.
+     */
+    async confirm(exec, plan, effective, policy, mode = 'on-change') {
+      const leadId = exec.agent.id;
+      const state = stateOf(leadId);
+      const catalog = await modelCatalog(ctx.llm, effective.tiers);
+      // Learned habits and recent failures shape what the card preselects; a route the user already confirmed in
+      // this session wins over both. `base` keeps the configured route, which "save as default" compares against.
+      const project = prefs ? await team.pin(exec.agent) : undefined;
+      const habits = project ? await prefs.habits(project).catch(() => ({})) : {};
+      const unhealthy = unhealthyRoutes(health());
+      const offered = planRoutes(plan, effective, policy.disabledRoutes, catalog).map(r => {
+        const base = { primary: r.primary, fallbacks: r.fallbacks };
+        const prior = state.routes.get(r.role);
+        const shaped = prior ? { ...r, primary: prior.primary, fallbacks: prior.fallbacks, learned: { unhealthy: {} } } : applyPreferences(r, habits[r.capability], unhealthy);
+        return { ...shaped, base };
+      });
+      const unchanged = offered.every(r => state.confirmed.get(r.role) === keyOf(r));
+      if (mode === 'never' || (mode === 'on-change' && unchanged)) return { asked: false, routes: offered };
+      const catalogVersion = createHash('sha256').update(JSON.stringify(offered.map(r => r.candidates))).digest('hex').slice(0, 16);
+      const callId = exec.callId ?? `dispatch-${Date.now()}`;
+      const result = await waitForAnswer(ctx, state, exec, callId, { offered, catalogVersion, subject: modelText('dispatch-confirm.204'), consequence: modelText('dispatch-confirm.205'), retry: modelText('dispatch-confirm.206'),
+        validate: answer => validateAnswer(offered, answer), ask: signal => askNative(ctx.userQuestions, exec, offered, signal) }, { graceMs, heartbeatMs, timeoutMs });
+      if (result.decision === 'cancel') throw new Error(modelText('dispatch-confirm.207'));
+      if (result.scope === 'project') await saveDefaults(exec, result.routes);
+      if (project) void prefs.record(project, result.routes).catch(() => {});
+      for (const r of result.routes) {
+        if (result.scope === 'task' && r.changed) state.routes.set(r.role, { primary: r.primary, fallbacks: r.fallbacks });
+        if (result.scope === 'project') state.routes.delete(r.role);
+        state.confirmed.set(r.role, keyOf(r));
+      }
+      routeStore?.save(leadId, state.routes, state.confirmed);
+      return { asked: true, scope: result.scope, routes: result.routes.map(r => ({ ...offered.find(o => o.role === r.role), primary: r.primary, fallbacks: r.fallbacks, changed: r.changed })) };
+    },
+  };
+}
+/** GET ?sessionId=[&callId=] → pending view (latest one without callId); POST {sessionId, callId, decision, scope, routes, catalogVersion}. */
+import { ownsCapabilityTeam } from './preset-guard.js';
+export async function handleDispatchConfirm(ctx, request) {
+  const fail = (status, code, message) => Response.json({ code, message }, { status });
+  try {
+    const url = new URL(request.url);
+    const lead = id => {
+      const agent = typeof id === 'string' && /^[\w.:-]{1,256}$/.test(id) ? ctx.get('agents')?.get(id) : undefined;
+      return ownsCapabilityTeam(ctx, agent) && ctx.get('agentTeams')?.tryMembership(agent)?.role === 'lead' ? agent : undefined;
+    };
+    if (request.method === 'GET') {
+      const agent = lead(url.searchParams.get('sessionId'));
+      if (!agent) return fail(404, 'NOT_FOUND', 'Lead unavailable');
+      return Response.json(pendingView(agent.id, url.searchParams.get('callId') ?? ''), { headers: { 'cache-control': 'no-store' } });
+    }
+    if (request.method !== 'POST') return fail(400, 'BAD_REQUEST', 'Method not allowed');
+    if (crossSiteRequest(request)) return fail(403, 'FORBIDDEN', 'Same-origin required');
+    if (!/^application\/json(?:\s*;|$)/i.test(request.headers.get('content-type') ?? '')) return fail(400, 'BAD_REQUEST', 'JSON required');
+    const text = await request.text();
+    if (text.length > 16384) return fail(400, 'BAD_REQUEST', 'Body too large');
+    let body; try { body = JSON.parse(text); } catch { return fail(400, 'BAD_REQUEST', 'Invalid JSON'); }
+    const agent = lead(body?.sessionId);
+    if (!agent) return fail(404, 'NOT_FOUND', 'Lead unavailable');
+    const { sessionId: _s, callId, ...answer } = body;
+    return Response.json(answerPending(agent.id, callId, answer), { headers: { 'cache-control': 'no-store' } });
+  } catch (error) { return fail(error.status ?? 503, error.code ?? 'UNAVAILABLE', error.status ? error.message : 'Dispatch confirm unavailable'); }
+}
+export function applyDispatchConfirmApi(ctx) {
+  ctx.inject?.(['connection', 'agents', 'agentTeams'], scoped => scoped.connection.fetch.register({
+    path: DISPATCH_CONFIRM_PATH, methods: ['GET', 'POST'], requestBody: 'buffered', fetch: req => handleDispatchConfirm(scoped, req) }));
+}

package/dispatch-routes-store.js

@@ -0,0 +1,31 @@
+// Persistence for per-task routes confirmed in the dispatch card ("this task only"). Lead sessions survive a
+// DSH restart, so their confirmed routes do too: one small JSON file per Lead under the plugin root, written
+// atomically (temp file + rename) and read lazily the first time a Lead is seen after start.
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const MAX_AGE_MS = 30 * 86400000; // a Lead untouched for 30 days has finished that task
+export function createRouteStore(root, { now = Date.now } = {}) {
+  const dir = join(root, 'dispatch-routes');
+  const fileOf = leadId => join(dir, `${createHash('sha256').update(String(leadId)).digest('hex').slice(0, 32)}.json`);
+  return {
+    /** { routes: [[role, route]], confirmed: [[role, key]] } for a Lead, or undefined. */
+    load(leadId) {
+      try {
+        const data = JSON.parse(readFileSync(fileOf(leadId), 'utf8'));
+        if (data?.leadId !== leadId || !Array.isArray(data.routes) || !Array.isArray(data.confirmed)) return undefined;
+        if (now() - (data.savedAt ?? 0) > MAX_AGE_MS) { this.remove(leadId); return undefined; }
+        return data;
+      } catch { return undefined; }
+    },
+    save(leadId, routes, confirmed) {
+      const file = fileOf(leadId), temp = `${file}.${randomUUID()}.tmp`;
+      try {
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(temp, JSON.stringify({ schemaVersion: 1, leadId, savedAt: now(), routes: [...routes], confirmed: [...confirmed] }) + '\n');
+        renameSync(temp, file);
+      } catch { /* routing still works from memory for this run */ } finally { try { unlinkSync(temp); } catch { /* renamed */ } }
+    },
+    remove(leadId) { try { unlinkSync(fileOf(leadId)); } catch { /* absent */ } },
+  };
+}

package/failover.js

@@ -0,0 +1,85 @@
+import { m as modelText } from './i18n.js';
+// Same-route retries, then ordered same-tier failover, with a per-route cooldown that doubles while a route keeps
+// failing (a dead provider is not retried every minute) and resets once it has stayed quiet for a while.
+// DSH's own provider retry policy (dsh-llm-retry) runs first; this layer only acts once it declines.
+import { isCredential } from './route-health.js';
+const key = r => `${r.provider}/${r.model}`;
+export const MAX_COOLDOWN_MS = 30 * 60_000;
+/** Cooldown for the n-th consecutive failure: base, 2×, 4×… capped at 30 minutes. */
+export const escalatedCooldown = (baseMs, strikes) => Math.min(baseMs * 2 ** Math.max(0, strikes - 1), Math.max(baseMs, MAX_COOLDOWN_MS));
+function wait(ms, signal) {
+  if (signal?.aborted) return Promise.resolve(false);
+  return new Promise(resolve => {
+    const timer = setTimeout(() => { signal?.removeEventListener('abort', stop); resolve(true); }, ms);
+    function stop() { clearTimeout(timer); resolve(false); }
+    signal?.addEventListener('abort', stop, { once: true });
+  });
+}
+export function createFailover({ now = Date.now, sleep = wait, registered = () => true, log = () => {}, telemetry = () => {} } = {}) {
+  const observe = event => { try { telemetry(event); } catch { /* observability never changes recovery */ } };
+  const cooling = new Map(); // route key → { until, failure, strikes, lastFailureAt }
+  const steps = new WeakMap(); // agent → per-step state
+  const healthy = route => (cooling.get(key(route))?.until ?? 0) <= now();
+  const candidates = role => [{ provider: role.provider, model: role.model }, ...(role.fallbacks ?? [])];
+  return {
+    /** Route for this attempt: the step's current candidate, else the first healthy registered one. */
+    route(agent, turn, step, role) {
+      const list = candidates(role);
+      const signature = `${list.map(key).join('|')}|${role.taskLeaseSignature ?? ''}`;
+      let state = steps.get(agent);
+      if (!state || state.turn !== turn || state.step !== step || state.signature !== signature) {
+        const usable = list.map((r, i) => i).filter(i => registered(list[i].provider));
+        const start = usable.find(i => healthy(list[i])) ?? usable[0] ?? 0;
+        state = { turn, step, signature, index: start, retries: 0, tried: [], role };
+        steps.set(agent, state);
+      }
+      state.role = role;
+      return { ...list[state.index], primary: state.index === 0, index: state.index };
+    },
+    /** Decide recovery after DSH's own retries declined. Returns true to retry the step. */
+    async recover(agent, failure, signal) {
+      const state = steps.get(agent);
+      if (!state || signal?.aborted) return false;
+      const { failover: policy } = state.role;
+      const list = candidates(state.role);
+      const current = list[state.index];
+      if (policy.retryCodes.includes(failure.code) && state.retries < policy.retries) {
+        state.retries += 1;
+        const backoff = Math.min(policy.initialDelayMs * 2 ** (state.retries - 1), policy.maxDelayMs);
+        const hinted = failure.providerRetryAfterMs > 0 && failure.providerRetryAfterMs <= policy.maxDelayMs ? failure.providerRetryAfterMs : backoff;
+        log(modelText('failover.208', { 0: key(current), 1: state.retries, 2: policy.retries, 3: failure.code, 4: hinted }));
+        const retry = await sleep(hinted, signal);
+        if (retry) observe({ kind: 'retry', agent });
+        return retry;
+      }
+      // Some adapters report the HTTP status only inside the message ("401 {...}"); read it from there too.
+      const status = failure.status ?? Number(/^(\d{3})\b/.exec(String(failure.message ?? ''))?.[1] ?? NaN);
+      const eligible = policy.failoverCodes.includes(failure.code) || policy.failoverStatuses.includes(status);
+      state.tried.push({ route: key(current), code: failure.code, status: failure.status, message: String(failure.message).slice(0, 300) });
+      if (!eligible) return false;
+      // A failure soon after the last cooldown ended counts as the same outage; a long quiet spell starts over.
+      const prior = cooling.get(key(current));
+      const strikes = prior && now() - prior.until < 10 * policy.cooldownMs ? prior.strikes + 1 : 1;
+      const until = now() + escalatedCooldown(policy.cooldownMs, strikes);
+      cooling.set(key(current), { until, failure: failure.code, strikes, lastFailureAt: now(), credential: isCredential(failure.code, status) });
+      observe({ kind: 'cooldown', agent, route: current, until, code: failure.code, status, strikes });
+      const tried = new Set(state.tried.map(item => item.route));
+      const next = list.findIndex(r => !tried.has(key(r)) && registered(r.provider) && healthy(r));
+      if (next < 0) { log(modelText('failover.209', { 0: JSON.stringify(state.tried) })); return false; }
+      log(modelText('failover.210', { 0: key(current), 1: failure.code, 2: failure.status ? '/' + failure.status : '', 3: key(list[next]) }));
+      observe({ kind: 'switch', agent, from: current, to: list[next], code: failure.code, status: failure.status });
+      state.index = next; state.retries = 0;
+      return true;
+    },
+    /** Model-facing status for the team context. */
+    status(agent) {
+      const state = steps.get(agent);
+      if (!state) return undefined;
+      const list = candidates(state.role);
+      return { active: key(list[state.index]), primary: state.index === 0, failed: state.tried };
+    },
+    cooling: () => [...cooling].filter(([, v]) => v.until > now()).map(([route, v]) => ({ route, failure: v.failure, until: new Date(v.until).toISOString(), strikes: v.strikes })),
+    /** Recent failure record per route (for ranking choices), including routes whose cooldown has ended. */
+    health: () => Object.fromEntries([...cooling].map(([route, v]) => [route, { strikes: v.strikes, lastFailureAt: v.lastFailureAt, cooling: v.until > now(), credential: v.credential }])),
+  };
+}