@aiwuk/team 0.0.0-stage → 5.0.8

package/team.js

@@ -0,0 +1,101 @@
+import { m as modelText } from './i18n.js';
+// Shared runtime: pins each Team member to one project and resolves its effective role.
+import { confirmedRoute, withConfirmedRoute } from './dispatch-confirm.js';
+import { baseName } from './session-rotation.js';
+import { resolveRole, baseConfig, withAutoRoutes } from './config.js';
+import { projectRoot, loadProject, loadProjectSync, defaultRoot } from './theme.js';
+import { ownsCapabilityTeam } from './preset-guard.js';
+import { autoMatch } from './defaults.js';
+import { applyModelPolicy } from './model-policy.js';
+import { readGlobalPolicy, readGlobalPolicySync, saveGlobalPolicy } from './session-policy.js';
+/**
+ * Detect routes from the live DSH catalog. Re-runs only when the registered provider set changes,
+ * so adding or removing a channel is picked up without a restart and a request costs one sync call.
+ * A degraded result (catalog errors or an unassigned capability) is retried at most once per
+ * `retryMs`, so a channel that was not ready at startup heals without a manual refresh. A retry that
+ * still finds nothing stays unassigned: requests remain blocked (fail-closed, no downgrade).
+ */
+export const DETECT_RETRY_MS = 30_000;
+const degraded = r => r.errors.length > 0 || r.report.some(x => x.status === 'unassigned');
+export function createDetector(llm, preset, { now = Date.now, retryMs = DETECT_RETRY_MS } = {}) {
+  let signature; let pending; let lastAt = 0; let current = { base: preset, report: [], unknown: [], errors: [] };
+  const providers = () => (llm?.listProviders?.() ?? []).map(p => p.id);
+  const detect = async () => {
+    const ids = providers();
+    const entries = []; const errors = [];
+    for (const provider of ids) {
+      try { for (const m of await llm.listModels(provider)) entries.push({ provider, model: m.id }); }
+      catch (error) { errors.push({ provider, error: String(error?.message ?? error).slice(0, 200) }); }
+    }
+    const match = autoMatch(entries, preset.capabilities);
+    let base = preset;
+    try { base = withAutoRoutes(preset, match); }
+    catch (error) { errors.push({ provider: '*', error: modelText('team.494', { 0: error.message }) }); }
+    current = { base, entries, report: match.report, pools: match.pools, unknown: match.unknown, errors, detectedAt: new Date().toISOString() };
+    return current;
+  };
+  return {
+    get: () => current,
+    async ensure(force = false) {
+      // Serialize reads; an explicit refresh always re-reads models even when provider IDs are unchanged.
+      if (pending) await pending;
+      const sig = providers().join('|');
+      if (!force && sig === signature && !(degraded(current) && now() - lastAt >= retryMs)) return current;
+      signature = sig; lastAt = now();
+      pending = detect().finally(() => { pending = undefined; });
+      return pending;
+    },
+  };
+}
+export function createTeam(ctx, config = {}, { root = defaultRoot(), detect } = {}) {
+  const preset = baseConfig(config);
+  const detector = createDetector(ctx.llm, preset, detect);
+  const pins = new WeakMap();
+  const policyBase = policy => policy.disabledRoutes.length
+    ? withAutoRoutes(preset, autoMatch(detector.get().entries ?? [], preset.capabilities, { disabledRoutes: policy.disabledRoutes }))
+    : detector.get().base;
+  // Pinned once per Agent: a later cd into a subdirectory or elsewhere keeps the same project.
+  const pin = async agent => {
+    if (!pins.has(agent)) pins.set(agent, projectRoot(await ctx.workingDirectory.ensure(agent), root));
+    return pins.get(agent);
+  };
+  return {
+    get base() { return detector.get().base; },
+    preset, root,
+    detection: () => detector.get(),
+    refresh: () => detector.ensure(true),
+    owns: agent => ownsCapabilityTeam(ctx, agent) && !!ctx.agentTeams.tryMembership(agent),
+    pin,
+    pinned: agent => pins.get(agent),
+    async load(agent) {
+      await detector.ensure();
+      const policy = await this.policy(agent);
+      return { ...await loadProject(await pin(agent), policyBase(policy), root), policy };
+    },
+    // The model policy is profile-wide: every save applies to all capability-team sessions from their next request.
+    loadSync(project, _agent) {
+      const policy = readGlobalPolicySync(root);
+      return { ...loadProjectSync(project, policyBase(policy), root), policy };
+    },
+    async policy(_agent) {
+      return readGlobalPolicy(root);
+    },
+    async savePolicy(agent, disabledRoutes, expectedRevision) {
+      if (ctx.agentTeams.membership(agent).role !== 'lead') throw new Error(modelText('team.495'));
+      return saveGlobalPolicy(disabledRoutes, expectedRevision, root);
+    },
+    async resolve(agent) {
+      const { effective, policy } = await this.load(agent);
+      const membership = ctx.agentTeams.membership(agent);
+      const role = resolveRole(membership, effective);
+      // Routes are confirmed per role, so a rotation successor (<role>-rN) keeps the route the user chose.
+      const confirmed = membership?.role === 'teammate' && membership.root ? confirmedRoute(membership.root.id, baseName(membership.name)) : undefined;
+      const resolved = applyModelPolicy(withConfirmedRoute(role, confirmed), policy.disabledRoutes);
+      // The Lead follows the user's pick (lead-route.js), which needs its tier's models and the policy to stay same-tier.
+      return membership?.role === 'teammate' ? resolved
+        : { ...resolved, leadContext: { tierModels: [...(effective.tiers?.[role.tier] ?? [])], disabledRoutes: [...policy.disabledRoutes] } };
+    },
+    // After a save, the saving Lead moves to the configured root if it was a different directory.
+    repin(agent, project) { pins.set(agent, project); },
+  };
+}

package/teammate-context.js

@@ -0,0 +1,120 @@
+import { m as modelText } from './i18n.js';
+// Keep a teammate's fixed prompt small. Measured: before any work a teammate carried ~110k characters
+// (a 326-entry skill catalog of 56k, 57 tool schemas of 40k, system and runtime context), about 55k tokens.
+// 1. Lead-only plugin tools are registered on the lead's agent only, teammate-only tools on teammates only.
+// 2. The skill catalog DSH injects is shortened for teammates (name + one short line), or limited / dropped
+//    per capability (`capabilities.<id>.skills`: 'compact' | 'full' | 'none' | [names or prefixes ending in *]).
+import { ownsCapabilityTeam } from './preset-guard.js';
+export const LEAD_ONLY_TOOLS = new Set(['capability_dispatch_plan', 'capability_free_task', 'capability_team_save', 'capability_team_import',
+  'capability_rotate_member', 'capability_review_plan', 'capability_model_prefs', 'capability_task_budget', 'capability_member_override']);
+export const TEAMMATE_ONLY_TOOLS = new Set(['capability_handoff', 'capability_submit_plan']);
+export const CATALOG_DESCRIPTION_CHARS = 72;
+export const CATALOG_MAX_CHARS = 26000;
+const isTeammateAgent = agent => agent?.session?.header?.parentSession !== undefined;
+/**
+ * A ctx whose tools.register keeps lead-only and teammate-only tools back and installs them per agent when that
+ * agent is created. Everything else passes through to the host unchanged.
+ * Agents that already existed when the plugin loaded (or reloaded) never fire agent/created, so the scoped tools
+ * are also installed for every agent in ctx.agents.list() once registration finished, and lazily on the first
+ * agent/pre-step of an agent. Installation is idempotent per agent and tool name.
+ */
+export function scopeTools(ctx) {
+  const lead = [], teammate = [];
+  const installed = new WeakMap();
+  // Registrations live on the agent's own ctx, which outlives a preset switch (a blank session reused for another
+  // preset is recomposed without agent/created or agent/disposed), so each one keeps its disposer and every call
+  // re-checks the preset: these tools must never act outside the capability-team preset.
+  const gated = (def, agent) => ({ ...def, async execute(args, exec) {
+    if (!ownsCapabilityTeam(ctx, exec?.agent ?? agent)) throw new Error(modelText('teammate-context.496'));
+    return def.execute(args, exec);
+  } });
+  const uninstall = agent => {
+    const done = installed.get(agent);
+    if (!done) return;
+    installed.delete(agent);
+    for (const dispose of done.values()) { try { dispose?.(); } catch { /* already removed */ } }
+  };
+  const install = agent => {
+    if (!agent?.ctx?.tools || !ownsCapabilityTeam(ctx, agent)) return;
+    const done = installed.get(agent) ?? new Map();
+    installed.set(agent, done);
+    for (const def of isTeammateAgent(agent) ? teammate : lead) {
+      if (done.has(def.name)) continue;
+      try { done.set(def.name, agent.ctx.tools.register(gated(def, agent))); } catch { done.set(def.name, undefined); /* already present for this agent */ }
+    }
+  };
+  const tools = new Proxy(ctx.tools, {
+    get(target, prop) {
+      if (prop === 'register') return def => {
+        if (LEAD_ONLY_TOOLS.has(def.name)) { lead.push(def); return () => {}; }
+        if (TEAMMATE_ONLY_TOOLS.has(def.name)) { teammate.push(def); return () => {}; }
+        return target.register(def);
+      };
+      const value = target[prop];
+      return typeof value === 'function' ? value.bind(target) : value;
+    },
+  });
+  const scoped = new Proxy(ctx, { get: (target, prop) => (prop === 'tools' ? tools : target[prop]) });
+  ctx.on('agent/created', ({ agent }) => { install(agent); });
+  ctx.on('agent/pre-step', (payload, next) => { install(payload?.agent); return next(); });
+  ctx.on('agent/disposed', ({ agent }) => uninstall(agent));
+  ctx.on('agent-preset/selected', sessionId => {
+    let agent; try { agent = ctx.agents?.get?.(sessionId); } catch { return; }
+    if (!agent) return;
+    if (ownsCapabilityTeam(ctx, agent)) install(agent); else uninstall(agent);
+  });
+  // Plugin tools register synchronously during apply; existing agents are backfilled right after it returns.
+  const installExisting = () => { let agents = []; try { agents = ctx.agents?.list?.() ?? []; } catch { /* host without agents service */ } for (const agent of agents) install(agent); };
+  queueMicrotask(installExisting);
+  return { ctx: scoped, deferred: () => ({ lead: [...lead], teammate: [...teammate] }), installExisting };
+}
+/** First clause of a description, at most `max` characters. */
+export function shortDescription(text, max = CATALOG_DESCRIPTION_CHARS) {
+  const s = String(text ?? '').replace(/\s+/g, ' ').trim();
+  const cut = s.split(/(?<=[。.!?！？；;])\s*/)[0] ?? s;
+  return cut.length <= max ? cut : `${cut.slice(0, max - 1)}…`;
+}
+const matches = (name, rules) => rules.some(r => (r.endsWith('*') ? name.startsWith(r.slice(0, -1)) : name === r));
+/** Rewrite one skill-catalog message for a policy; undefined means drop it. Entries (used for digests) are kept. */
+export function rewriteCatalog(message, policy, maxChars = CATALOG_MAX_CHARS) {
+  if (policy === 'full' && message.content?.reduce((n, c) => n + (c.text?.length ?? 0), 0) <= maxChars) return message;
+  const entries = message.source?.entries ?? [];
+  const kept = Array.isArray(policy) ? entries.filter(e => matches(e.name, policy)) : entries;
+  if (policy === 'none' || (Array.isArray(policy) && !kept.length)) return undefined;
+  const lines = []; let used = 500;
+  for (const e of kept) {
+    const line = `- \`${e.name}\`${e.description ? `: ${shortDescription(e.description)}` : ''}`;
+    if (used + line.length + 1 > maxChars) continue;
+    lines.push(line); used += line.length + 1;
+  }
+  const text = ['<system-reminder>', 'Skills you can load with the `skill` tool (short list; load one before using it):', '', '<available_skills>', ...lines, '</available_skills>',
+    'If the task clearly matches a skill, call the `skill` tool with its exact name before acting, then follow its full instructions.', '</system-reminder>'].join('\n');
+  return { ...message, content: [{ type: 'text', text }] };
+}
+/** Validate `capabilities.<id>.skills`. */
+export function validateSkillsPolicy(value, label) {
+  if (value === undefined) return undefined;
+  if (['compact', 'full', 'none'].includes(value)) return value;
+  if (Array.isArray(value) && value.length <= 200 && value.every(v => typeof v === 'string' && /^[\w.:@/-]+\*?$/.test(v))) return [...new Set(value)];
+  throw new Error(modelText('teammate-context.497', { 0: label }));
+}
+/**
+ * Shorten the skill catalog for teammates. Registered with `prepend` so it is the outermost agent/pre-step
+ * listener and sees the catalog message the skill tool adds downstream.
+ */
+export function applySkillCatalog(ctx, policyOf) {
+  ctx.on('agent/pre-step', async (payload, next) => {
+    const decision = await next();
+    if (decision?.kind === 'reject' || !ownsCapabilityTeam(ctx, payload.agent) || !isTeammateAgent(payload.agent) || !Array.isArray(decision?.messages)) return decision;
+    let policy;
+    try { policy = policyOf(payload.agent) ?? 'compact'; } catch { policy = 'compact'; }
+    const messages = []; let remaining = CATALOG_MAX_CHARS;
+    for (const m of decision.messages) {
+      if (m?.source?.kind !== 'skill-catalog') { messages.push(m); continue; }
+      if (remaining < 500) continue;
+      const next = rewriteCatalog(m, policy, remaining);
+      if (next) { messages.push(next); remaining -= next.content.reduce((n, c) => n + (c.text?.length ?? 0), 0); }
+    }
+    return { ...decision, messages };
+  }, { prepend: true });
+}

package/teammate-wait.js

@@ -0,0 +1,18 @@
+import { m as modelText } from './i18n.js';
+// Teammates never block in wait_agent. DSH's wait_agent only observes changes after the call starts, so a Lead
+// message that lands while the teammate's model request is in flight is missed and the teammate idles until the
+// timeout. Ending the turn instead is lossless: send_message starts or resumes an inactive teammate.
+import { ownsCapabilityTeam } from './preset-guard.js';
+import { restrictiveToolName } from './tool-names.js';
+export const TEAMMATE_WAIT_DENIAL = modelText('teammate-wait.498');
+/** Pure decision: a denial for a teammate's wait_agent call, otherwise undefined. */
+export function teammateWaitDenial(exec, membership) {
+  if (membership?.role !== 'teammate') return undefined;
+  return restrictiveToolName(exec?.name, new Set(['wait_agent'])) === 'wait_agent' ? TEAMMATE_WAIT_DENIAL : undefined;
+}
+export function applyTeammateWait(ctx) {
+  ctx.effect(() => ctx.tools.guard(exec => {
+    if (!ownsCapabilityTeam(ctx, exec.agent)) return undefined;
+    return teammateWaitDenial(exec, ctx.agentTeams.tryMembership(exec.agent));
+  }));
+}

package/template.js

@@ -0,0 +1,46 @@
+import { m as modelText } from './i18n.js';
+// Portable team templates: roles, capability duties and policies, workflow and failover. Channels, models, backups
+// and long-context routes belong to one user's DSH catalog, so they are never exported; after an import, automatic
+// matching (or a later save) assigns them.
+export const TEMPLATE_FORMAT = 'capability-team-template';
+export const TEMPLATE_VERSION = 1;
+const PORTABLE = ['job', 'whenToUse', 'tier', 'search', 'prefer', 'access', 'maxTokens', 'planFirst'];
+const isMap = v => !!v && typeof v === 'object' && !Array.isArray(v);
+const pick = (value, keys) => Object.fromEntries(keys.filter(k => value[k] !== undefined).map(k => [k, value[k]]));
+/** Template of one effective configuration. */
+export function toTemplate(effective) {
+  return {
+    format: TEMPLATE_FORMAT, version: TEMPLATE_VERSION, name: effective.name,
+    workflow: effective.workflow, failover: effective.failover,
+    capabilities: Object.fromEntries(Object.entries(effective.capabilities).map(([id, c]) => [id, pick(c, PORTABLE)])),
+    roles: effective.roles,
+  };
+}
+/**
+ * Save patch that makes a project's team match a template: capability fields merge (keeping routes), roles are
+ * replaced, and a template capability field that is absent clears the project's value back to the default.
+ */
+export function templatePatch(template, current) {
+  if (!isMap(template) || template.format !== TEMPLATE_FORMAT) throw new Error(modelText('template.499', { 0: TEMPLATE_FORMAT }));
+  if (template.version !== TEMPLATE_VERSION) throw new Error(modelText('template.500', { 0: template.version, 1: TEMPLATE_VERSION }));
+  const extra = Object.keys(template).filter(k => !['format', 'version', 'name', 'workflow', 'failover', 'capabilities', 'roles'].includes(k));
+  if (extra.length) throw new Error(modelText('template.501', { 0: extra.join(', ') }));
+  if (!isMap(template.capabilities) || !isMap(template.roles)) throw new Error(modelText('template.502'));
+  if (!isMap(template.roles.lead)) throw new Error(modelText('template.503'));
+  const capabilities = {};
+  for (const [id, c] of Object.entries(template.capabilities)) {
+    if (!isMap(c)) throw new Error(modelText('template.504', { 0: id }));
+    const unknown = Object.keys(c).filter(k => !PORTABLE.includes(k));
+    if (unknown.length) throw new Error(modelText('template.505', { 0: id, 1: unknown.join(', ') }));
+    // Fields the template leaves out are cleared so the project ends up matching the template.
+    const cleared = { search: false, prefer: [] };
+    capabilities[id] = Object.fromEntries(PORTABLE.map(k => [k, c[k] ?? (k in cleared ? cleared[k] : null)]));
+  }
+  const roles = { ...template.roles };
+  for (const id of Object.keys(current.roles)) if (!(id in roles)) roles[id] = false;
+  return {
+    ...(template.name === undefined ? {} : { name: template.name }),
+    workflow: template.workflow ?? null, failover: template.failover ?? null,
+    capabilities, roles,
+  };
+}

package/theme-plugin.js

@@ -0,0 +1,172 @@
+import { m as modelText, t } from './i18n.js';
+import { readFileSync } from 'node:fs';
+import { roleView, describeChanges, resolveRole, seed } from './config.js';
+import { modelCatalog, changedRoutes, verifyRoutes } from './allocation.js';
+import { saveProject } from './theme.js';
+import { params } from './tool-schema.js';
+import { registerTeamReader, registerPolicyWriter } from './runtime-view.js';
+import { modelPolicyRows, applyModelPolicy, policyRoleView } from './model-policy.js';
+import { accessSummary } from './access.js';
+import { toTemplate, templatePatch, TEMPLATE_FORMAT } from './template.js';
+import { ROLE_THEMES, themePatch } from './roster-defaults.js';
+import { singleModelFrom } from './single-model.js';
+const output = { schema: { type: 'string' }, render: (_args, value) => [{ type: 'text', text: value }] };
+const ENTRY_RULE = modelText('theme-plugin.506');
+/** Model-facing team context for one Agent, rebuilt from the pinned project on every step. */
+export function teamContext(team, agent, membership, failover, workflow, planGate) {
+  const project = team.pinned(agent);
+  if (!project) return modelText('theme-plugin.507');
+  let loaded;
+  try { loaded = team.loadSync(project, agent); }
+  catch (error) { return modelText('theme-plugin.508', { 0: error.message }); }
+  let self;
+  try {
+    const { failover: _policy, access, ...role } = applyModelPolicy(resolveRole(membership, loaded.effective), loaded.policy?.disabledRoutes);
+    self = role;
+    const limits = accessSummary(access);
+    if (limits) self.access = modelText('theme-plugin.509', { 0: limits });
+    const planState = planGate?.status(agent, membership, role);
+    if (planState) self.plan = planState;
+    const live = failover?.status(agent);
+    const allowed = [role, ...(role.fallbacks ?? [])].map(r => `${r.provider}/${r.model}`);
+    const wide = role.longContext ? `${role.longContext.provider}/${role.longContext.model}` : undefined;
+    if (live?.active && live.active === wide) self.currentRoute = modelText('theme-plugin.510', { 0: wide });
+    else if (live && !live.primary && allowed.includes(live.active)) self.currentRoute = modelText('theme-plugin.511', { 0: live.active });
+  } catch (error) { self = { error: error.message }; }
+  const roster = roleView(loaded.effective).map(entry => {
+    try {
+      const { id, displayName, capability, whenToUse, provider, model, access, singleModel } = applyModelPolicy(entry, loaded.policy?.disabledRoutes);
+      const limits = accessSummary(access);
+      return { id, displayName, capability, ...(whenToUse ? { whenToUse } : {}), model: provider ? `${provider}/${model}${singleModel ? modelText('theme-plugin.512') : ''}` : modelText('theme-plugin.513'), ...(limits ? { access: limits } : {}) };
+    } catch (error) { return { id: entry.id, displayName: entry.displayName, model: modelText('theme-plugin.514'), error: error.message }; }
+  });
+  const status = membership?.role === 'lead' ? workflow?.status(agent, loaded.effective.workflow) : undefined;
+  return modelText('theme-plugin.515', { 0: loaded.effective.name, 1: loaded.revision, 2: project, 3: JSON.stringify(self), 4: JSON.stringify(roster), 5: status ? `\n${status}` : '' });
+}
+async function confirm(ctx, exec, lines, revision) {
+  const answer = await ctx.userQuestions.ask({ agent: exec.agent, signal: exec.signal, questions: [{
+    id: 'confirm', header: t('theme-plugin.516'),
+    question: t('theme-plugin.517', { 0: lines.length }),
+    detail: t('theme-plugin.518', { 0: lines.join('\n'), 1: revision }),
+    options: [{ label: t('theme-plugin.519'), description: t('theme-plugin.520') }, { label: t('theme-plugin.521'), description: t('theme-plugin.522') }],
+  }] });
+  const item = answer.answers.find(a => a.id === 'confirm');
+  if (!item?.selected.includes(t('theme-plugin.523'))) throw new Error(modelText('theme-plugin.524', { 0: item?.custom ? modelText('theme-plugin.525', { 0: item.custom }) : '' }));
+}
+export function apply(ctx, team, failover, workflow, planGate, taskControl) {
+  const content = readFileSync(new URL('./skills/project-role-theme/SKILL.md', import.meta.url), 'utf8');
+  ctx.effect(() => ctx.skills.register({ name: 'project-role-theme', source: 'runtime', content,
+    description: modelText('theme-plugin.526') }));
+  ctx.effect(() => ctx.tools.register({ name: 'capability_team_read', parameters: params(), output,
+    description: modelText('theme-plugin.527'),
+    async execute(_args, exec) {
+      await team.refresh();
+      const { project, revision, overrides, effective, policy } = await team.load(exec.agent);
+      const { report, unknown, errors, detectedAt } = team.detection();
+      return JSON.stringify({ project, revision, defaults: team.base, overrides, effective, roles: policyRoleView(roleView(effective), policy.disabledRoutes), coolingRoutes: failover?.cooling() ?? [],
+        autoMatch: { detectedAt, report, unrecognized: unknown.slice(0, 50), unrecognizedCount: unknown.length, errors } });
+    },
+  }));
+  ctx.effect(() => ctx.tools.register({ name: 'capability_model_catalog', parameters: params(), output,
+    description: modelText('theme-plugin.528'),
+    async execute(_args, exec) {
+      const { effective } = await team.load(exec.agent);
+      return JSON.stringify(await modelCatalog(ctx.llm, effective.tiers));
+    },
+  }));
+  ctx.effect(() => ctx.tools.register({ name: 'capability_team_save', output,
+    description: modelText('theme-plugin.529'),
+    parameters: params({
+      expected_revision: { type: 'integer', description: modelText('theme-plugin.530') },
+      name: { type: 'string', description: modelText('theme-plugin.531') },
+      tiers: { type: 'object', additionalProperties: true, description: modelText('theme-plugin.532', { 0: ENTRY_RULE }) },
+      capabilities: { type: 'object', additionalProperties: true, description: modelText('theme-plugin.533', { 0: ENTRY_RULE }) },
+      failover: { oneOf: [{ type: 'object', additionalProperties: true }, { type: 'null' }], description: modelText('theme-plugin.534') },
+      workflow: { oneOf: [{ type: 'object', additionalProperties: true }, { type: 'null' }], description: modelText('theme-plugin.535') },
+      roles: { type: 'object', additionalProperties: true, description: modelText('theme-plugin.536', { 0: ENTRY_RULE }) },
+      single_model: { type: 'string', enum: ['use-default', 'off'], description: modelText('theme-plugin.537') },
+    }, ['expected_revision']),
+    async execute(args, exec) {
+      const singleModel = args.single_model === 'off' ? null : args.single_model === 'use-default' ? singleModelFrom(ctx.get?.('agentDefaultModel')?.currentSelection?.()) : undefined;
+      const patch = { name: args.name, failover: args.failover, workflow: args.workflow, tiers: args.tiers, capabilities: args.capabilities, roles: args.roles, singleModel };
+      return JSON.stringify(await saveConfirmed(exec, patch, args.expected_revision));
+    },
+  }));
+  /** Validate, check new routes against the catalog, and save only after the user approves the full diff. */
+  async function saveConfirmed(exec, patch, expectedRevision) {
+    if (ctx.agentTeams.membership(exec.agent).role !== 'lead') throw new Error(modelText('theme-plugin.538'));
+    const project = await team.pin(exec.agent);
+    const result = await saveProject(project, patch, expectedRevision, { base: team.base, root: team.root,
+      async check(before, after) {
+        const lines = describeChanges(before, after);
+        if (!lines.length) throw new Error(modelText('theme-plugin.539'));
+        const routes = changedRoutes(before, after);
+        const single = after.singleModel && `${after.singleModel.provider}/${after.singleModel.model}` !== `${before.singleModel?.provider}/${before.singleModel?.model}`
+          ? [{ capability: modelText('theme-plugin.540'), ...after.singleModel }] : [];
+        if (routes.length || single.length) verifyRoutes([...routes, ...single], await modelCatalog(ctx.llm, after.tiers));
+        await confirm(ctx, exec, lines, expectedRevision);
+      } });
+    return { saved: true, project: result.project, revision: result.revision, roles: roleView(result.effective) };
+  }
+  ctx.effect(() => ctx.tools.register({ name: 'capability_team_export', parameters: params(), output,
+    description: modelText('theme-plugin.541', { 0: TEMPLATE_FORMAT }),
+    async execute(_args, exec) {
+      const { effective } = await team.load(exec.agent);
+      return JSON.stringify(toTemplate(effective), null, 2);
+    },
+  }));
+  ctx.effect(() => ctx.tools.register({ name: 'capability_team_import', output,
+    description: modelText('theme-plugin.542', { 0: Object.keys(ROLE_THEMES).join(' / ') }),
+    parameters: params({
+      expected_revision: { type: 'integer', description: modelText('theme-plugin.543') },
+      template: { type: 'object', additionalProperties: true, description: modelText('theme-plugin.544', { 0: TEMPLATE_FORMAT }) },
+      theme: { type: 'string', enum: Object.keys(ROLE_THEMES), description: modelText('theme-plugin.545') },
+    }, ['expected_revision']),
+    async execute(args, exec) {
+      const { effective } = await team.load(exec.agent);
+      if ((args.template === undefined) === (args.theme === undefined)) throw new Error(modelText('theme-plugin.546'));
+      const patch = args.theme === undefined ? templatePatch(args.template, effective) : themePatch(args.theme, effective);
+      const result = await saveConfirmed(exec, patch, args.expected_revision);
+      const unassigned = result.roles.filter(r => r.provider === undefined).map(r => r.id);
+      return JSON.stringify({ ...result, ...(unassigned.length ? { unassigned, next: modelText('theme-plugin.547') } : {}) });
+    },
+  }));
+  // Install the team context in each Team member's own scope, like the native Team identity.
+  const installed = new Map();
+  const install = async agent => {
+    if (installed.has(agent) || !ownsCapabilityTeam(ctx, agent) || ctx.agentTeams.tryMembership(agent) === undefined) return;
+    installed.set(agent, undefined);
+    // Pin before the first step; a failure must not block creation and resurfaces on the next request.
+    await team.pin(agent).catch(() => {});
+    if (!installed.has(agent)) return; // disposed meanwhile
+    const removeReader = registerTeamReader(agent, async () => {
+      await team.refresh();
+      const { project, revision, effective, policy } = await team.load(agent);
+      return { project, revision, name: effective.name, ...(effective.singleModel ? { singleModel: effective.singleModel } : {}), roles: policyRoleView(roleView(effective), policy.disabledRoutes), workflow: effective.workflow,
+        modelPolicy: { ...modelPolicyRows(effective.tiers, roleView(effective), policy.disabledRoutes, [...(team.detection().pools ?? []), ...(team.detection().unknown ?? [])]), revision: policy.revision },
+        autoMatch: team.detection().report, catalogErrors: team.detection().errors ?? [], actualRequest: null,
+        ...(effective.tierDrift ? { tierDrift: effective.tierDrift } : {}),
+        modelNotice: t('theme-plugin.548') };
+    });
+    const removeContext = agent.ctx.systemPrompt.context({ name: 'capability-team:roster', order: 98, required: true,
+      text: () => (ownsCapabilityTeam(ctx, agent) ? teamContext(team, agent, ctx.agentTeams.tryMembership(agent), failover, workflow, planGate) : '') });
+    const removeBudgetContext = taskControl && ctx.agentTeams.tryMembership(agent)?.role === 'lead'
+      ? agent.ctx.systemPrompt.context({ name: 'capability-team:task-budget', order: 99, required: true,
+        text: () => (ownsCapabilityTeam(ctx, agent) ? taskControl.summary(agent) : '') }) : () => {};
+    const removeWriter = registerPolicyWriter(agent, (routes, revision) => team.savePolicy(agent, routes, revision));
+    installed.set(agent, () => { removeReader(); removeWriter(); removeContext(); removeBudgetContext(); });
+  };
+  for (const agent of ctx.agents.list()) void install(agent);
+  ctx.on('agent/created', async ({ agent }) => { await install(agent); });
+  ctx.on('agent/disposed', ({ agent }) => { installed.get(agent)?.(); installed.delete(agent); });
+  // A blank session reused for another preset is recomposed without agent/created or agent/disposed.
+  ctx.on('agent-preset/selected', sessionId => {
+    let agent; try { agent = ctx.agents?.get?.(sessionId); } catch { return; }
+    if (!agent) return;
+    if (ownsCapabilityTeam(ctx, agent)) { void install(agent); return; }
+    installed.get(agent)?.(); installed.delete(agent);
+  });
+  ctx.effect(() => () => { for (const dispose of installed.values()) dispose?.(); installed.clear(); });
+}
+export { seed };
+import { ownsCapabilityTeam } from './preset-guard.js';

package/theme.js

@@ -0,0 +1,115 @@
+import { m as modelText } from './i18n.js';
+// Per-project team configuration store: overrides on top of the preset base.
+import { mkdir, readFile, writeFile, rename, unlink, open, stat } from 'node:fs/promises';
+import { readFileSync, statSync, existsSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { resolve, join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { effectiveConfig, migrateProject, applyPatch, seed } from './config.js';
+import { pinRoster } from './roster-defaults.js';
+export const STALE_LOCK_MS = 30000;
+export function defaultRoot() {
+  return process.env.CAPABILITY_TEAM_HOME || join(homedir(), '.dsh', 'capability-team-themes');
+}
+function identity(dir) {
+  const project = resolve(dir);
+  return process.platform === 'win32' ? project.toLowerCase() : project;
+}
+export function themePath(cwd, root = defaultRoot()) {
+  return join(root, createHash('sha256').update(identity(cwd)).digest('hex') + '.json');
+}
+/** Nearest ancestor (inclusive) that already owns a configuration, else the directory itself. */
+export function projectRoot(cwd, root = defaultRoot()) {
+  let dir = resolve(cwd);
+  for (;;) {
+    if (existsSync(themePath(dir, root))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return resolve(cwd);
+    dir = parent;
+  }
+}
+const cache = new Map();
+function parse(raw, path) {
+  try { return migrateProject(JSON.parse(raw)); }
+  catch (error) { throw new Error(modelText('theme.549', { 0: path, 1: error.message })); }
+}
+const EMPTY = Object.freeze({ revision: 0, tiers: {}, capabilities: {}, roles: {} });
+function remember(path, info, raw) {
+  const value = parse(raw, path);
+  cache.set(path, { mtimeMs: info.mtimeMs, size: info.size, value });
+  return value;
+}
+function cached(path, info) {
+  const hit = cache.get(path);
+  return hit && hit.mtimeMs === info.mtimeMs && hit.size === info.size ? hit.value : undefined;
+}
+/** Read stored overrides; cached by mtime and size so a request costs one stat. */
+export async function readOverrides(project, root = defaultRoot()) {
+  const path = themePath(project, root);
+  let info;
+  try { info = await stat(path); } catch (error) { if (error.code === 'ENOENT') { cache.delete(path); return EMPTY; } throw error; }
+  return cached(path, info) ?? remember(path, info, await readFile(path, 'utf8'));
+}
+/** Synchronous variant for prompt assembly, which cannot await. */
+export function readOverridesSync(project, root = defaultRoot()) {
+  const path = themePath(project, root);
+  let info;
+  try { info = statSync(path); } catch (error) { if (error.code === 'ENOENT') { cache.delete(path); return EMPTY; } throw error; }
+  return cached(path, info) ?? remember(path, info, readFileSync(path, 'utf8'));
+}
+export async function loadProject(project, base = seed, root) {
+  const overrides = await readOverrides(project, root);
+  return { project, revision: overrides.revision, overrides, effective: effectiveConfig(overrides, base, { trustedFrom: overrides }) };
+}
+export function loadProjectSync(project, base = seed, root) {
+  const overrides = readOverridesSync(project, root);
+  return { project, revision: overrides.revision, overrides, effective: effectiveConfig(overrides, base, { trustedFrom: overrides }) };
+}
+function alive(pid) {
+  try { process.kill(pid, 0); return true; } catch (error) { return error.code === 'EPERM'; }
+}
+export async function acquireLock(lockPath) {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const handle = await open(lockPath, 'wx');
+      try { await handle.writeFile(JSON.stringify({ pid: process.pid, at: Date.now() })); }
+      catch (error) { await handle.close(); await unlink(lockPath); throw error; }
+      return handle;
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      let owner = {};
+      try { owner = JSON.parse(await readFile(lockPath, 'utf8')); } catch { /* empty or partial lock: judged by file age */ }
+      const since = Number(owner.at) || (await stat(lockPath).catch(() => ({ mtimeMs: Date.now() }))).mtimeMs;
+      const knownOwner = Number.isSafeInteger(owner.pid) && owner.pid > 0;
+      // A confirmation dialog can stay open for minutes. Age never invalidates a live owner's lock.
+      const stale = knownOwner ? !alive(owner.pid) : Date.now() - since > STALE_LOCK_MS;
+      if (attempt || !stale) throw new Error(modelText('theme.550'));
+      await unlink(lockPath).catch(e => { if (e.code !== 'ENOENT') throw e; });
+    }
+  }
+}
+/**
+ * Apply one patch under a lock with revision CAS; the merged result must validate.
+ * `check(before, after)` may reject, for example on a catalog or confirmation failure.
+ */
+export async function saveProject(project, patch, expectedRevision, { base = seed, root = defaultRoot(), check } = {}) {
+  const path = themePath(project, root);
+  await mkdir(dirname(path), { recursive: true });
+  const lock = await acquireLock(path + '.lock');
+  const tmp = path + '.' + randomUUID() + '.tmp';
+  try {
+    const previous = await loadProject(project, base, root);
+    if (!Number.isSafeInteger(expectedRevision) || previous.revision !== expectedRevision) throw new Error(modelText('theme.551', { 0: previous.revision }));
+    const nextOverrides = pinRoster(applyPatch(previous.overrides, patch), previous.overrides, base.roles);
+    const effective = effectiveConfig(nextOverrides, base, { trustedFrom: previous.overrides });
+    if (check) await check(previous.effective, effective);
+    const stored = { ...nextOverrides, revision: previous.revision + 1, project: resolve(project) };
+    await writeFile(tmp, JSON.stringify(stored, null, 2), { encoding: 'utf8', flag: 'wx' });
+    await rename(tmp, path);
+    cache.delete(path);
+    return { project: resolve(project), revision: stored.revision, effective };
+  } finally {
+    try { await unlink(tmp).catch(e => { if (e.code !== 'ENOENT') throw e; }); }
+    finally { try { await lock.close(); } finally { await unlink(path + '.lock').catch(e => { if (e.code !== 'ENOENT') throw e; }); } }
+  }
+}