@aiwuk/team 0.0.0-stage → 5.0.3

package/i18n.js

@@ -0,0 +1,34 @@
+// Server text uses the host's explicit locale preference, with an environment override.
+import en from './i18n/server.en.json' with { type: 'json' };
+import zh from './i18n/server.zh.json' with { type: 'json' };
+import rolesEn from './i18n/roles.en.json' with { type: 'json' };
+import rolesZh from './i18n/roles.zh.json' with { type: 'json' };
+const dictionaries = { en, zh };
+const roles = { en: rolesEn, zh: rolesZh };
+let hostSettings;
+export const normalizeLocale = value => /^zh(?:[-_]|$)/i.test(String(value ?? '')) ? 'zh' : 'en';
+/** Bind only the public, optional DSH settings service; read preferences live. */
+export function configureI18n(ctx) {
+  ctx.inject?.(['settings'], scoped => {
+    hostSettings = scoped.settings;
+    scoped.effect?.(() => () => { if (hostSettings === scoped.settings) hostSettings = undefined; });
+  });
+}
+export function locale({ env = process.env, settings = hostSettings } = {}) {
+  if (env.AIWUK_LOCALE) return normalizeLocale(env.AIWUK_LOCALE);
+  try {
+    const rows = settings?.describe?.({ redactSecrets: true }) ?? [];
+    return normalizeLocale(rows.find(row => row.ns === 'locale')?.value?.preference);
+  } catch { return 'en'; }
+}
+const interpolate = (text, vars) => text.replace(/\{(\w+)\}/g, (match, key) => Object.hasOwn(vars, key) ? String(vars[key]) : match);
+/** Translate user-visible text. Unknown keys remain visible for diagnostics. */
+export function t(key, vars = {}, language = locale()) {
+  return interpolate(dictionaries[normalizeLocale(language)][key] ?? dictionaries.en[key] ?? key, vars);
+}
+/** Tool descriptions, errors and model instructions are always English. */
+export const m = (key, vars = {}) => t(key, vars, 'en');
+/** Role/persona data is distinct from user-interface text. */
+export function roleText(key, vars = {}, language = locale()) {
+  return interpolate(roles[normalizeLocale(language)][key] ?? roles.en[key] ?? key, vars);
+}

package/icon.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" fill="none">
+  <rect x="4" y="4" width="56" height="56" rx="14" fill="#1e1b4b" stroke="#6366f1" stroke-width="2"/>
+  <path d="M16 48 L32 16 L48 48 Z" fill="rgba(99, 102, 241, 0.3)" stroke="#f59e0b" stroke-width="2"/>
+  <circle cx="32" cy="22" r="4" fill="#38bdf8"/>
+  <circle cx="24" cy="40" r="3.5" fill="#10b981"/>
+  <circle cx="40" cy="40" r="3.5" fill="#ef4444"/>
+</svg>

package/index.js

@@ -0,0 +1,111 @@
+import { apply as applyRoles } from './roles.js';
+import { ownsCapabilityTeam } from './preset-guard.js';
+import { apply as applyIntegrations } from './integrations.js';
+import { apply as applyTheme } from './theme-plugin.js';
+import { createTeam } from './team.js';
+import { createFailover } from './failover.js';
+import { createWorkflow } from './workflow.js';
+import { applyAccess } from './access.js';
+import { applyTeammateWait } from './teammate-wait.js';
+import { createPlanGate } from './plan-gate.js';
+import { createRuntimeObservability } from './runtime-observability.js';
+import { createTaskControl } from './member-task-control.js';
+import { createTaskAudit } from './task-control-audit.js';
+import { createDispatchConfirm, setRouteStore } from './dispatch-confirm.js';
+import { createRouteStore } from './dispatch-routes-store.js';
+import { applyModelPrefsTool, createModelPrefs } from './model-prefs.js';
+import { createBoardDispatch } from './board-dispatch.js';
+import { baseName } from './session-rotation.js';
+import { legacyRoleId } from './roster-defaults.js';
+import { applySkillCatalog, scopeTools } from './teammate-context.js';
+import { createTokenDiscipline } from './token-discipline.js';
+import { createRouteHealth, mergeHealth } from './route-health.js';
+import { createRotation } from './session-rotation.js';
+import { createMemoryHub } from './memory-hub.js';
+import { knownSecretValues, refreshCredentials, releaseCredentials, useCredentials } from './integrations-config.js';
+export const inject = ['agents', 'agentTeams', 'systemPrompt', 'tools', 'workingDirectory', 'skills', 'llm', 'userQuestions'];
+import { configureI18n } from './i18n.js';
+export function apply(host, config = {}) {
+  configureI18n(host);
+  // Lead-only and teammate-only plugin tools are installed per agent, so teammates do not carry the lead's tool schemas.
+  const { ctx } = scopeTools(host);
+  const team = createTeam(ctx, config); // Validates preset bindings up front.
+  // Memory endpoints/models are read-only user file/environment configuration.
+  // Keys come from DSH's own credential store first (Settings → credentials), the environment second.
+  // The same binding also feeds the managed manifest reader, so locked fields win over local settings.
+  ctx.inject?.(['credentials'], scoped => {
+    const service = scoped.credentials;
+    if (!service) return;
+    useCredentials(service);
+    scoped.effect?.(() => () => releaseCredentials(service));
+    void refreshCredentials().catch(() => {});
+  });
+  // Settings may also arrive as same-named credentials (e.g. MEMORY_BACKEND pushed by a fleet manager).
+  void refreshCredentials().catch(() => {});
+  void team.refresh(); // First catalog match in the background; requests await it if still pending.
+  const observability = createRuntimeObservability();
+  const routeHealth = createRouteHealth(team.root);
+  const failover = createFailover({
+    telemetry: event => { observability.telemetry(event); routeHealth.record(event); },
+    // A provider missing from DSH throws before the stream starts, which no hook can recover.
+    registered: provider => ctx.llm.listProviders().some(p => p.id === provider),
+    log: message => ctx.logger?.info?.(`capability-team: ${message}`),
+  });
+  const taskControl = createTaskControl(ctx, team, { audit: createTaskAudit(team.root), onChanged: () => observability.notifyTaskControl(),
+    predecessorOf: (leadId, name) => rotation.predecessorOf(leadId, name) });
+  const planGate = createPlanGate(ctx, team);
+  // Re-read the credential store before redacting, so a key added in Settings since the last refresh is redacted too.
+  const memory = createMemoryHub(ctx, team, { secrets: async () => { await refreshCredentials().catch(() => {}); return knownSecretValues(); } });
+  const rotation = createRotation(ctx, team, { onHandoff: handoff => memory.ingestHandoff(handoff) });
+  const board = createBoardDispatch(ctx, team);
+  const prefs = createModelPrefs(team.root);
+  setRouteStore(createRouteStore(team.root)); // per-task confirmed routes survive a DSH restart
+  const workflow = createWorkflow(ctx, team, { onDelegate: (lead, roles) => planGate.reset(lead, roles), onAssignments: (lead, assignments) => taskControl.dispatch(lead, assignments), dispatchConfirm: createDispatchConfirm(ctx, team, { prefs, health: () => mergeHealth(routeHealth.recent(), failover.health()) }), rotation, board });
+  taskControl.setWorkflow(workflow);
+  taskControl.register();
+  workflow.register();
+  planGate.register();
+  rotation.register();
+  memory.register();
+  applyBoard(ctx, team, board, rotation);
+  applyModelPrefsTool(ctx, team, prefs);
+  createTokenDiscipline(host, team).register();
+  applySkillCatalog(host, agent => {
+    const project = team.pinned(agent);
+    const m = host.agentTeams.tryMembership(agent);
+    if (!project || !m?.name) return undefined;
+    const { effective } = team.loadSync(project, agent);
+    const id = baseName(m.name);
+    return effective.capabilities[effective.roles[legacyRoleId(id, effective.roles) ?? id]?.capability]?.skills;
+  });
+  applyAccess(ctx, team);
+  applyTeammateWait(ctx);
+  applyRoles(ctx, team, failover, observability, taskControl);
+  applyIntegrations(ctx, team);
+  applyTheme(ctx, team, failover, workflow, planGate, taskControl);
+}
+/**
+ * Board integration hooks. A teammate becomes an active member once it claims its first message; then its ready
+ * tasks are handed to it (and a rotation successor takes over its predecessor's open tasks). Its runtime context
+ * lists its board tasks, and edits outside the scopes of the tasks it holds are refused when configured.
+ */
+function applyBoard(ctx, team, board, rotation) {
+  ctx.on('agent/inbox/claimed', ({ agent }) => {
+    const m = ctx.agentTeams.tryMembership(agent);
+    if (!ownsCapabilityTeam(ctx, agent) || m?.role !== 'teammate' || !m.root) return;
+    const from = rotation.predecessorOf(m.root.id, m.name);
+    void (async () => { if (from) await board.transfer(m.root, from, m.name); await board.handOut(m.root, baseName(m.name), m.name); })().catch(() => {});
+  });
+  ctx.on('agent/created', ({ agent }) => {
+    if (!ownsCapabilityTeam(ctx, agent) || ctx.agentTeams.tryMembership(agent)?.role !== 'teammate') return;
+    agent.ctx.systemPrompt.context({ name: 'capability-team:board', order: 96, text: () => board.context(agent) });
+  });
+  ctx.effect(() => ctx.tools.guard(exec => {
+    if (!ownsCapabilityTeam(ctx, exec.agent)) return undefined;
+    const project = team.pinned(exec.agent);
+    if (!project) return undefined;
+    let enforce;
+    try { enforce = team.loadSync(project, exec.agent).effective.workflow.enforceWriteScopes !== false; } catch { return undefined; }
+    return board.guard(exec, { enforce });
+  }));
+}

package/integrations-config.js

@@ -0,0 +1,301 @@
+// External integrations (search engines, embeddings, speech, memory) are per-user data, never code: base URLs,
+// paths, headers, models and engine order all come from configuration, and nothing assumes a particular vendor.
+// Keys are never stored: the config names the environment variable (or DSH credential) that holds each key.
+// Layers (contract F.3): a LOCKED managed ref (published by the Mothership connector) wins over everything local;
+// otherwise bundle settings form › credentials › environment › user integrations.json › unlocked managed value ›
+// defaults. Every resolved field reports its source: managed-locked | settings | credential | env | file |
+// managed-default | default. Managed values are ordinary credentials; only the lock manifest is extra.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { defaultRoot } from './theme.js';
+import { message } from './integrations-messages.js';
+import { pickLayer, sourceLabel } from './managed-resolve.js';
+import { readManagedManifest } from './shared/managed-config.js';
+/** Search engines in their default (auto) order, and the page-fetch engines. */
+export const SEARCH_ENGINES = Object.freeze(['tavily', 'brave', 'searxng', 'custom']);
+export const FETCH_ENGINES = Object.freeze(['jina', 'tavily', 'custom']);
+export const MEMORY_BACKENDS = Object.freeze(['local', 'openviking']);
+export const SHARED_RECALL_SCOPES = Object.freeze(['current', 'none']);
+export const INTEGRATION_DEFAULTS = Object.freeze({
+  // engines: null = auto (every configured engine, in SEARCH_ENGINES order). baseUrl/apiKeyEnv/paths/providers
+  // belong to the `custom` engine (any gateway speaking the generic search/fetch protocol). Custom gateways may
+  // fall back across upstream providers, so a full answer can take up to two minutes.
+  search: Object.freeze({ engines: null, fetchEngines: Object.freeze(['jina']), tavilyKeyEnv: 'TAVILY_API_KEY', braveKeyEnv: 'BRAVE_API_KEY', searxngUrl: null, searxngKeyEnv: 'SEARXNG_API_KEY', jinaKeyEnv: 'JINA_API_KEY',
+    baseUrl: null, apiKeyEnv: 'OMNI_SEARCH_API_KEY', searchPath: '/v1/search', fetchPath: '/v1/web/fetch', providersPath: null, headers: {}, providers: [], fetchProviders: [], timeoutMs: 120000, fetchTimeoutMs: 120000,
+    // Direct engines (tavily, brave, searxng, jina) answer fast; a short timeout keeps failover snappy.
+    engineTimeoutMs: 30000 }),
+  // Any OpenAI-compatible /v1/embeddings endpoint (OpenAI, Ollama, vLLM, Jina, a gateway...).
+  embeddings: Object.freeze({ baseUrl: null, apiKeyEnv: 'EMBEDDING_API_KEY', path: '/v1/embeddings', headers: {}, model: null, provider: null, dimensions: null, queryTask: null, passageTask: null, timeoutMs: 15000, batch: 32 }),
+  // Speech to text: multipart upload of a user-approved local file. maxBytes mirrors a typical gateway cap;
+  // the gateway's own limit wins when it is lower (a 413 is reported, never retried).
+  audio: Object.freeze({ baseUrl: null, apiKeyEnv: 'OMNI_AUDIO_API_KEY', path: '/v1/audio/transcriptions', statusPath: null, headers: {}, model: null, timeoutMs: 125000, maxBytes: 8388608 }),
+  // Memory hub backend (one of MEMORY_BACKENDS): 'local' (team store only) or 'openviking' (also shared
+  // long-term memory on that server). The OpenViking key is optional: a local dev-mode server needs none.
+  // sharedRecall (one of SHARED_RECALL_SCOPES) is a deployment choice: 'current' keeps recall local because
+  // shared backends carry no trusted project metadata; 'none' searches the whole shared account.
+  memory: Object.freeze({ backend: 'local', url: null, apiKeyEnv: 'OPENVIKING_API_KEY', account: null, user: null, timeoutMs: 8000, recallLimit: 4, sharedRecall: 'current' }),
+});
+/**
+ * Names that override single fields. A list means primary first, then legacy fallbacks: a later name is
+ * consulted only when every earlier one is unset. Each name is read from the DSH credential store first (a
+ * fleet manager can push settings there) and from the environment second.
+ */
+export const ENV_OVERRIDES = Object.freeze({
+  search: { baseUrl: 'OMNI_SEARCH_BASE_URL', searxngUrl: 'SEARXNG_URL', engines: 'OMNI_SEARCH_ENGINES', fetchEngines: 'OMNI_FETCH_ENGINES', providersPath: 'OMNI_SEARCH_PROVIDERS_PATH' },
+  embeddings: { baseUrl: ['EMBEDDING_BASE_URL', 'CPA_EMBED_BASE_URL'], model: ['EMBEDDING_MODEL', 'CPA_EMBED_MODEL'], dimensions: ['EMBEDDING_DIMENSIONS', 'CPA_EMBED_DIMENSIONS'] },
+  audio: { baseUrl: 'OMNI_AUDIO_BASE_URL' },
+  memory: { url: 'OPENVIKING_URL', backend: 'MEMORY_BACKEND', sharedRecall: 'MEMORY_SHARED_RECALL' },
+});
+/** Every override name (primary and legacy), e.g. for refreshing them from the credential store. */
+export const overrideNames = () => [...new Set(Object.values(ENV_OVERRIDES).flatMap(fields => Object.values(fields).flat()))];
+// List fields arrive as one comma-separated string from the environment or a credential.
+const LIST_FIELDS = ['engines', 'fetchEngines'];
+const overrideValue = (key, raw) => (LIST_FIELDS.includes(key) ? String(raw).split(',').map(v => v.trim()).filter(Boolean) : raw);
+/** Legacy key names consulted when a section still uses its default key name and that one is unset. */
+export const LEGACY_KEY_ENV = Object.freeze({ embeddings: Object.freeze({ EMBEDDING_API_KEY: 'CPA_EMBED_API_KEY' }) });
+/** Per-engine key fields of integrations.search (the `custom` engine uses apiKeyEnv). */
+export const SEARCH_KEY_FIELDS = Object.freeze({ tavily: 'tavilyKeyEnv', brave: 'braveKeyEnv', searxng: 'searxngKeyEnv', jina: 'jinaKeyEnv', custom: 'apiKeyEnv' });
+const SECTIONS = Object.keys(INTEGRATION_DEFAULTS);
+const KEY_FIELDS = ['apiKeyEnv', 'tavilyKeyEnv', 'braveKeyEnv', 'searxngKeyEnv', 'jinaKeyEnv'];
+const HEADER_NAME = /^[A-Za-z0-9-]{1,64}$/;
+const FORBIDDEN_HEADERS = ['authorization', 'cookie', 'host', 'content-length', 'content-type', 'proxy-authorization'];
+const fail = (label, rule) => { throw new Error(`${label} ${rule}`); };
+const integerIn = (value, min, max, label, rule) => { const n = Number(value); return Number.isSafeInteger(n) && n >= min && n <= max ? n : fail(label, rule); };
+/** An https URL, or plain http only for a server on this machine; never with credentials, query or hash. */
+export function localOrHttpsUrl(value, label) {
+  let url; try { url = new URL(String(value)); } catch { fail(label, message('notUrl')); }
+  const loopback = ['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname);
+  if (!(url.protocol === 'https:' || (url.protocol === 'http:' && loopback)) || url.username || url.password || url.search || url.hash) fail(label, message('localOrHttps'));
+  return url.href.replace(/\/+$/, '');
+}
+const engineList = (value, allowed, label) => {
+  if (!Array.isArray(value) || !value.length || value.some(v => !allowed.includes(v))) fail(label, message('engineList', { allowed: allowed.join(' / ') }));
+  return [...new Set(value)];
+};
+function validateField(section, key, value) {
+  const label = `${section}.${key}`;
+  if (value === null) return null;
+  switch (key) {
+    case 'engines': return engineList(value, SEARCH_ENGINES, label);
+    case 'fetchEngines': return engineList(value, FETCH_ENGINES, label);
+    case 'searxngUrl': return localOrHttpsUrl(value, label);
+    case 'baseUrl': {
+      let url; try { url = new URL(String(value)); } catch { fail(label, message('notUrl')); }
+      if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash) fail(label, message('httpsOnly'));
+      return url.href.replace(/\/+$/, '');
+    }
+    case 'tavilyKeyEnv': case 'braveKeyEnv': case 'searxngKeyEnv': case 'jinaKeyEnv':
+    case 'apiKeyEnv': return /^[A-Z_][A-Z0-9_]{0,63}$/.test(value) ? value : fail(label, message('envName'));
+    case 'searchPath': case 'fetchPath': case 'providersPath': case 'statusPath': case 'path':
+      return typeof value === 'string' && /^\/[A-Za-z0-9._~\/-]{0,200}$/.test(value) && !value.includes('..') ? value : fail(label, message('path'));
+    case 'headers': {
+      if (typeof value !== 'object' || Array.isArray(value)) fail(label, message('headersObject'));
+      const out = {};
+      for (const [name, v] of Object.entries(value)) {
+        if (!HEADER_NAME.test(name) || FORBIDDEN_HEADERS.includes(name.toLowerCase())) fail(label, message('headerForbidden', { name }));
+        if (typeof v !== 'string' || v.length > 512 || /[\r\n]/.test(v)) fail(label, message('headerValue', { name }));
+        out[name] = v;
+      }
+      return out;
+    }
+    case 'providers': case 'fetchProviders':
+      if (!Array.isArray(value) || value.length > 50 || value.some(v => typeof v !== 'string' || !/^[\w.:-]{1,64}$/.test(v))) fail(label, message('providerList'));
+      return [...new Set(value)];
+    case 'model': case 'provider': case 'queryTask': case 'passageTask':
+      return typeof value === 'string' && value.trim() && value.length <= 200 && !/\s/.test(value.trim()) ? value.trim() : fail(label, message('noWhitespace'));
+    case 'dimensions': return integerIn(value, 1, 8192, label, message('intRange', { min: 1, max: 8192 }));
+    case 'timeoutMs': case 'fetchTimeoutMs': case 'engineTimeoutMs': return integerIn(value, 1000, 300000, label, message('msRange', { min: 1000, max: 300000 }));
+    case 'batch': return integerIn(value, 1, 256, label, message('intRange', { min: 1, max: 256 }));
+    case 'maxBytes': return integerIn(value, 1024, 104857600, label, message('byteRange', { min: 1024, max: 104857600 }));
+    case 'backend': return MEMORY_BACKENDS.includes(value) ? value : fail(label, message('oneOf', { values: MEMORY_BACKENDS.join(message('or')) }));
+    // Plain http is accepted only for a server on this machine; anything remote must use https.
+    case 'url': return localOrHttpsUrl(value, label);
+    case 'account': case 'user':
+      return typeof value === 'string' && /^[\w.@-]{1,64}$/.test(value) ? value : fail(label, message('accountName'));
+    case 'recallLimit': return integerIn(value, 0, 20, label, message('intRange', { min: 0, max: 20 }));
+    case 'sharedRecall': return SHARED_RECALL_SCOPES.includes(value) ? value : fail(label, message('oneOf', { values: SHARED_RECALL_SCOPES.join(message('or')) }));
+    default: return fail(label, message('unsupportedField'));
+  }
+}
+// Settings layer: the owning bundle's volatile DSH Config (settings-schema.js), read on every resolve.
+let settingsReader = () => ({});
+export function setSettingsReader(fn) { settingsReader = typeof fn === 'function' ? fn : () => ({}); }
+function readSettings() { try { return settingsReader() ?? {}; } catch { return {}; } }
+/** Validate a partial config ({search?, embeddings?}); unknown sections or fields are rejected. */
+export function validateIntegrations(value) {
+  if (value === undefined || value === null) return {};
+  if (typeof value !== 'object' || Array.isArray(value)) throw new Error(message('integrationsObject'));
+  const out = {};
+  for (const [section, fields] of Object.entries(value)) {
+    if (!SECTIONS.includes(section)) throw new Error(message('integrationsSection', { section }));
+    if (fields === null) continue;
+    if (typeof fields !== 'object' || Array.isArray(fields)) throw new Error(message('integrationsSectionObject', { section }));
+    out[section] = {};
+    for (const [key, v] of Object.entries(fields)) {
+      if (!Object.hasOwn(INTEGRATION_DEFAULTS[section], key)) throw new Error(`integrations.${section}.${key} ${message('unsupportedField')}`);
+      out[section][key] = validateField(section, key, v);
+    }
+  }
+  return out;
+}
+export const integrationsPath = (root = defaultRoot()) => join(root, 'integrations.json');
+function readFileLayer(root) {
+  try { const raw = JSON.parse(readFileSync(integrationsPath(root), 'utf8')); return { revision: raw.revision ?? 0, value: validateIntegrations(raw.integrations) }; }
+  catch (error) { if (error.code === 'ENOENT') return { revision: 0, value: {} }; throw new Error(message('fileCorrupt', { reason: error.message })); }
+}
+/**
+ * Effective config with the source of every field, plus whether each section's key is present.
+ * Key values never leave this function except through `keyOf`.
+ */
+export function resolveIntegrations({ root = defaultRoot(), env = process.env, managed, credentials, settings: injectedSettings } = {}) {
+  const file = readFileLayer(root);
+  const effective = {}, sources = {}, keys = {}, locked = {};
+  // The credential store only backs the real process environment (tests pass their own env, or their own store).
+  const store = credentials ?? (env === process.env ? credentialCache : undefined);
+  const manifest = managed === undefined ? (store ? managedManifest : null) : managed;
+  const settings = injectedSettings ?? (store ? readSettings() : {});
+  const entryOf = name => manifest?.entries?.get(name);
+  for (const section of SECTIONS) {
+    effective[section] = {}; sources[section] = {}; locked[section] = {};
+    for (const key of Object.keys(INTEGRATION_DEFAULTS[section])) {
+      const names = [ENV_OVERRIDES[section][key] ?? []].flat();
+      const layer = pickLayer({
+        names, entryOf,
+        settings: () => settings[section]?.[key],
+        credential: name => store?.get(name),
+        env: name => env[name],
+        file: file.value[section]?.[key],
+        // A file value was validated when it was read; every other layer is validated here, and an invalid one is skipped.
+        validate: (raw, kind) => (kind === 'file' ? raw : validateField(section, key, kind === 'settings' ? raw : overrideValue(key, raw))),
+        fallback: INTEGRATION_DEFAULTS[section][key],
+      });
+      effective[section][key] = layer.value; sources[section][key] = sourceLabel(layer); locked[section][key] = layer.locked;
+    }
+    const names = sectionKeyNames(section, effective[section], manifest);
+    keys[section] = keyState(names, env, store, manifest, names[0]);
+  }
+  keys.search.engines = Object.fromEntries(Object.entries(SEARCH_KEY_FIELDS).map(([engine, field]) => {
+    const names = sectionKeyNames('search', effective.search, manifest, field);
+    return [engine, keyState(names, env, store, manifest, names[0])];
+  }));
+  const resolved = { revision: file.revision, effective, sources, locked, keys, fileLayer: file.value };
+  // The environment, store and manifest stay attached but non-enumerable, so a serialized view never carries them.
+  for (const [name, value] of Object.entries({ env, store, managed: manifest })) Object.defineProperty(resolved, name, { value });
+  return resolved;
+}
+/** Presence and source of a key (never its value): `{env: <name>, present, source, locked}`. */
+function keyState(names, env, store, manifest, label) {
+  const hit = findKey(names, env, store, manifest);
+  return { env: label, present: !!hit, source: hit?.source ?? 'default', locked: names.some(name => manifest?.entries?.get(name)?.locked === true) };
+}
+/** A locked canonical credential owns only its section/engine field; local aliases cannot bypass that lock. */
+function sectionKeyNames(section, config, manifest, field = 'apiKeyEnv') {
+  const canonical = INTEGRATION_DEFAULTS[section][field];
+  if (manifest?.entries?.get(canonical)?.locked === true) return [canonical];
+  const name = config[field], legacy = LEGACY_KEY_ENV[section]?.[name];
+  return legacy && name === canonical ? [name, legacy] : [name];
+}
+// Each name is tried in order. A locked managed name reads only the store (the managed value); an unlocked managed
+// name lets a local environment value win over it; any other name reads the store before the environment.
+function findKey(names, env, store, manifest) {
+  for (const name of names) {
+    const entry = manifest?.entries?.get(name), stored = store?.get(name), local = env[name];
+    if (entry?.locked) { if (stored) return { value: stored, source: 'managed-locked' }; continue; }
+    if (entry) { if (local) return { value: local, source: 'env' }; if (stored) return { value: stored, source: 'managed-default' }; continue; }
+    if (stored) return { value: stored, source: 'credential' };
+    if (local) return { value: local, source: 'env' };
+  }
+  return undefined;
+}
+const storeOf = (resolved, env) => (env === resolved.env ? resolved.store : env === process.env ? credentialCache : undefined);
+const lookup = (names, resolved, env) => findKey(names, env, storeOf(resolved, env), resolved.managed)?.value;
+/** The API key for a section, read from the credential/environment variable its config names. */
+export const keyOf = (section, resolved, env = resolved.env ?? process.env) => lookup(sectionKeyNames(section, resolved.effective[section], resolved.managed), resolved, env);
+/** The key of one search/fetch engine (tavily, brave, searxng, jina, custom); undefined when not set. */
+export const engineKeyOf = (engine, resolved, env = resolved.env ?? process.env) => {
+  if (engine === 'custom') return keyOf('search', resolved, env);
+  const field = SEARCH_KEY_FIELDS[engine];
+  return field ? lookup(sectionKeyNames('search', resolved.effective.search, resolved.managed, field), resolved, env) : undefined;
+};
+/** Include effective canonical refs and local aliases for refresh and redaction, even when a lock ignores an alias. */
+export function keyNames(resolved) {
+  const names = SECTIONS.flatMap(section => [...sectionKeyNames(section, resolved.effective[section], resolved.managed), ...sectionKeyNames(section, resolved.effective[section])]);
+  for (const field of KEY_FIELDS) names.push(...sectionKeyNames('search', resolved.effective.search, resolved.managed, field), resolved.effective.search[field]);
+  return [...new Set(names)];
+}
+// DSH's credential store (ctx.credentials, the keys saved in Settings) is consulted first, so every key name
+// is a DSH credential reference and the process environment is the fallback.
+// Values are cached in memory only, refreshed before each request, and only ever placed in a request header.
+let credentialResolver;
+const credentialCache = new Map();
+export function setCredentialResolver(fn) { credentialResolver = fn; credentialCache.clear(); }
+// Managed manifest (lock policy only, never values): fed by an async reader the host plugin supplies (see
+// shared/managed-config.js readManagedManifest) and re-read with the credentials.
+let managedManifest = null, managedReader = null;
+export function setManagedReader(fn) { managedReader = typeof fn === 'function' ? fn : null; if (!managedReader) managedManifest = null; }
+/** Set the manifest directly (tests, or a host that already holds it). */
+export function setManagedManifest(manifest) { managedManifest = manifest ?? null; }
+export const managedManifestOf = () => managedManifest;
+/**
+ * Bind a DSH credential service (`ctx.credentials`): key names resolve through `resolve`, and the managed manifest is
+ * read through `readRecord` (with the file fallback). Pass null to unbind. Replaces the two separate setters.
+ */
+let boundService = null;
+export function useCredentials(service) {
+  boundService = service || null;
+  if (!service) { setCredentialResolver(null); setManagedReader(null); return; }
+  setCredentialResolver(name => service.resolve(name));
+  setManagedReader(() => readManagedManifest({ credentials: service }));
+}
+/** Unbind `service` only while it is still the bound one, so a late dispose never clears a later re-apply's binding. */
+export function releaseCredentials(service) { if (boundService === service) useCredentials(null); }
+export { resolveRef } from './managed-ref.js';
+// Re-exported so the standalone bundles (memory, search) reach the route through their shared/ closure.
+export { registerManagedConfigRoute } from './managed-config-route.js';
+/**
+ * Re-read every key name the config uses and every override name (ENV_OVERRIDES, legacy included) from the
+ * DSH credential store (no-op without the store). Values stay in memory and are never logged.
+ */
+export async function refreshCredentials(resolved = resolveIntegrations()) {
+  if (managedReader) { try { managedManifest = (await managedReader()) ?? null; } catch { managedManifest = null; } }
+  if (!credentialResolver) return;
+  const resolver = credentialResolver;
+  for (const name of new Set([...keyNames(resolved), ...overrideNames(), ...(managedManifest?.entries?.keys() ?? [])])) {
+    try {
+      const credential = await resolver(name);
+      const value = typeof credential === 'string' ? credential : credential?.value;
+      if (value) credentialCache.set(name, value); else credentialCache.delete(name);
+    } catch { credentialCache.delete(name); }
+  }
+}
+/** Every configured key value (store and environment), only for redacting them out of stored text. */
+export function knownSecretValues(resolved = resolveIntegrations()) {
+  const env = resolved.env ?? process.env;
+  return [...new Set(keyNames(resolved).map(name => lookup([name], resolved, env)).filter(Boolean))];
+}
+/**
+ * Whether each section's (and search engine's) key is configured (DSH store or environment), never the value.
+ * Each entry also carries `source` (managed-locked | credential | env | managed-default | default) and `locked`.
+ */
+export async function keyPresence(resolved) {
+  await refreshCredentials(resolved);
+  const env = resolved.env ?? process.env, store = storeOf(resolved, env);
+  const state = (names, label) => {
+    const hit = findKey(names, env, store, resolved.managed);
+    return { env: label, present: !!hit, source: hit?.source ?? 'default', locked: names.some(name => resolved.managed?.entries?.get(name)?.locked === true) };
+  };
+  const out = {};
+  for (const section of SECTIONS) {
+    const names = sectionKeyNames(section, resolved.effective[section], resolved.managed);
+    out[section] = state(names, names[0]);
+  }
+  out.search.engines = Object.fromEntries(Object.entries(SEARCH_KEY_FIELDS).map(([engine, field]) => {
+    const names = sectionKeyNames('search', resolved.effective.search, resolved.managed, field);
+    return [engine, state(names, names[0])];
+  }));
+  return out;
+}
+/** Safe view for the Overview: effective values, the layer each came from, and key presence (never key values). */
+export function describeIntegrations(resolved) {
+  return { schemaVersion: 1, revision: resolved.revision, effective: resolved.effective, sources: resolved.sources, keys: resolved.keys, file: resolved.fileLayer, envOverrides: ENV_OVERRIDES };
+}

package/integrations-messages.js

@@ -0,0 +1,62 @@
+// Validation messages of the integrations resolver, English by default; the host may switch with
+// setIntegrationsLocale(). The zh strings are kept as \u escapes so this source stays ASCII (a user-facing
+// dictionary, not hardcoded UI text).
+const dictionaries = {
+  en: {
+    notUrl: "is not a valid URL",
+    localOrHttps: "must be an https URL (http://127.0.0.1 is allowed for this machine) without credentials or query parameters",
+    httpsOnly: "must be an https URL without credentials or query parameters",
+    engineList: "must be a non-empty list of {allowed}",
+    envName: "must be an environment variable name (upper-case letters, digits, underscores)",
+    path: "must be a path starting with /",
+    headersObject: "must be a {name: value} object",
+    headerForbidden: "cannot set the request header {name} (keys are injected through apiKeyEnv)",
+    headerValue: "the value of request header {name} is invalid",
+    providerList: "must be a list of channel names",
+    noWhitespace: "must be a string without whitespace",
+    intRange: "must be an integer from {min} to {max}",
+    msRange: "must be {min}-{max} milliseconds",
+    byteRange: "must be {min}-{max} bytes",
+    oneOf: "must be {values}",
+    or: " or ",
+    accountName: "must be 1-64 letters, digits or ._@-",
+    unsupportedField: "is not a supported field",
+    integrationsObject: "integrations must be an object",
+    integrationsSection: "integrations does not support {section}",
+    integrationsSectionObject: "integrations.{section} must be an object",
+    fileCorrupt: "integrations file is corrupt: {reason}",
+  },
+  zh: {
+    notUrl: "\u4e0d\u662f\u5408\u6cd5\u5730\u5740",
+    localOrHttps: "\u987b\u4e3a https \u5730\u5740\uff08\u672c\u673a\u53ef\u7528 http://127.0.0.1\uff09\uff0c\u4e0d\u542b\u8d26\u53f7\u548c\u67e5\u8be2\u53c2\u6570",
+    httpsOnly: "\u987b\u4e3a\u4e0d\u542b\u8d26\u53f7\u3001\u67e5\u8be2\u53c2\u6570\u7684 https \u5730\u5740",
+    engineList: "\u987b\u4e3a\u975e\u7a7a\u5217\u8868\uff0c\u53d6\u503c {allowed}",
+    envName: "\u987b\u4e3a\u73af\u5883\u53d8\u91cf\u540d\uff08\u5927\u5199\u5b57\u6bcd\u3001\u6570\u5b57\u3001\u4e0b\u5212\u7ebf\uff09",
+    path: "\u987b\u4e3a\u4ee5 / \u5f00\u5934\u7684\u8def\u5f84",
+    headersObject: "\u987b\u4e3a {\u540d\u79f0: \u503c} \u5bf9\u8c61",
+    headerForbidden: "\u4e0d\u80fd\u8bbe\u7f6e\u8bf7\u6c42\u5934 {name}\uff08\u5bc6\u94a5\u901a\u8fc7 apiKeyEnv \u6ce8\u5165\uff09",
+    headerValue: "\u8bf7\u6c42\u5934 {name} \u7684\u503c\u65e0\u6548",
+    providerList: "\u987b\u4e3a\u6e20\u9053\u540d\u5217\u8868",
+    noWhitespace: "\u987b\u4e3a\u4e0d\u542b\u7a7a\u767d\u7684\u5b57\u7b26\u4e32",
+    intRange: "\u987b\u4e3a {min}\u2013{max} \u7684\u6574\u6570",
+    msRange: "\u987b\u4e3a {min}\u2013{max} \u6beb\u79d2",
+    byteRange: "\u987b\u4e3a {min}\u2013{max} \u5b57\u8282",
+    oneOf: "\u987b\u4e3a {values}",
+    or: " \u6216 ",
+    accountName: "\u987b\u4e3a 1\u201364 \u4f4d\u5b57\u6bcd\u3001\u6570\u5b57\u6216 ._@-",
+    unsupportedField: "\u4e0d\u662f\u652f\u6301\u7684\u5b57\u6bb5",
+    integrationsObject: "integrations \u987b\u4e3a\u5bf9\u8c61",
+    integrationsSection: "integrations \u4e0d\u652f\u6301 {section}",
+    integrationsSectionObject: "integrations.{section} \u987b\u4e3a\u5bf9\u8c61",
+    fileCorrupt: "\u96c6\u6210\u914d\u7f6e\u6587\u4ef6\u635f\u574f\uff1a{reason}",
+  },
+};
+let locale = 'en';
+/** 'zh', 'zh-CN', ... select Chinese; anything else English. */
+export function setIntegrationsLocale(next) { locale = String(next ?? '').toLowerCase().startsWith('zh') ? 'zh' : 'en'; }
+export const integrationsLocale = () => locale;
+/** The message for `key` with `{name}` placeholders filled from `values`. */
+export function message(key, values = {}) {
+  const text = dictionaries[locale]?.[key] ?? dictionaries.en[key] ?? key;
+  return text.replace(/\{(\w+)\}/g, (whole, name) => (name in values ? String(values[name]) : whole));
+}

package/integrations.js

@@ -0,0 +1,17 @@
+import { m as modelText } from './i18n.js';
+import { executeFreeTask } from './task-bridge.js';
+import { params } from './tool-schema.js';
+const output = { schema: { type: 'string' }, render: (_args, value) => [{ type: 'text', text: value }] };
+export function apply(ctx, team) {
+  // CPA tools are supplied by the independent profile bundle; this plugin owns only the free-task bridge.
+  ctx.effect(() => ctx.tools.register({
+    name: 'capability_free_task',
+    description: modelText('integrations.262'),
+    parameters: params({ prompt: { type: 'string', description: modelText('integrations.263') }, subject: { type: 'string', description: modelText('integrations.264') } }, ['prompt']), output,
+    async execute(args, exec) {
+      const cwd = await ctx.workingDirectory.ensure(exec.agent, exec.signal);
+      const { effective } = await team.load(exec.agent);
+      return JSON.stringify(await executeFreeTask({ teams: ctx.agentTeams, agent: exec.agent, prompt: args.prompt, subject: args.subject, cwd, signal: exec.signal, tools: effective.workflow.freeTools, models: effective.workflow.freeModels }));
+    },
+  }));
+}

package/lead-route.js

@@ -0,0 +1,30 @@
+// The Lead follows the model the user picked in the conversation. DSH puts that pick on the request config it
+// passes to agent/request; this plugin used to overwrite it with the configured lead route. Teammates keep strict
+// per-role routing. Same-tier failover still applies: configured lead routes in the chosen model's tier stay
+// as fallbacks, and a model outside that tier gets none, so a failure never degrades across tiers.
+import { routeKey, routeMatcher } from './model-policy.js';
+/** The user's pick from DSH's request config, or null when the request names no model. */
+export function userChoice(previous) {
+  const { provider, model } = previous ?? {};
+  return typeof provider === 'string' && provider && typeof model === 'string' && model ? { provider, model } : null;
+}
+/**
+ * The Lead role re-pointed at the user's pick. `tierModels` lists the model ids of the configured lead tier;
+ * `disabledRoutes` is the profile-wide model policy. A pick the policy disables keeps the configured route.
+ */
+export function followUserChoice(role, previous, { tierModels = [], disabledRoutes = [] } = {}) {
+  const choice = userChoice(previous);
+  if (!choice) return role;
+  if (routeMatcher(disabledRoutes)(routeKey(choice))) return { ...role, userChoiceRejected: routeKey(choice) };
+  const configured = role.unassigned || !role.provider ? [] : [{ provider: role.provider, model: role.model }, ...(role.fallbacks ?? [])];
+  const same = r => routeKey(r) === routeKey(choice);
+  const sameTier = configured.some(same) || tierModels.includes(choice.model);
+  // The long-context switch is a configured-route feature; the user's explicit pick is not swapped out.
+  const { longContext: _longContext, unassigned: _unassigned, ...rest } = role;
+  return { ...rest, ...choice, fallbacks: sameTier ? configured.filter(r => !same(r)) : [], userChoice: true };
+}
+/** The outgoing request: the user's own settings survive when the user's pick is the route actually used. */
+export function leadRequest(previous, selected) {
+  const choice = userChoice(previous);
+  return choice && routeKey(choice) === routeKey(selected) ? { ...previous, provider: selected.provider, model: selected.model } : null;
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "AIWUK Team",
+    "description": "Capability-routed multi-agent team for DeepSeek Harness: per-role model routing, same-tier failover and conversational team configuration."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "AI悟空 协作团队",
+    "description": "为 DeepSeek Harness 提供按能力路由的多智能体团队：按角色分配模型、同档容灾、对话式配置团队。"
+  }
+}

package/long-context.js

@@ -0,0 +1,30 @@
+// Same-tier long-context route: once the next prompt of a member's session reaches its capability's threshold,
+// requests go to the configured long-context model first. They return only after the prompt falls below 80% of
+// the threshold (for example after compaction), so a session does not flip models, and caches, on every step.
+const RELEASE = 0.8;
+/** Next-prompt size of a session from token-meter's `contextPressure` state, as its wire view computes it. */
+export function promptTokens(projections, session) {
+  try {
+    const state = projections?.stateOf(session, 'contextPressure');
+    if (!state) return undefined;
+    if (state.pressureTokens !== undefined && state.sampledSurfaceTokens !== undefined) return Math.max(0, state.pressureTokens + state.surfaceTokens - state.sampledSurfaceTokens);
+    return state.surfaceTokens; // No provider sample yet: the heuristic surface is the only estimate.
+  } catch { return undefined; }
+}
+export function createLongContext() {
+  const active = new WeakMap(); // session → whether the long-context route is engaged
+  return {
+    reset(session) { active.delete(session); },
+    /** The role with its long-context route first while the session's prompt is large; the role itself otherwise. */
+    apply(session, role, tokens) {
+      const lc = role.longContext;
+      if (!lc || tokens === undefined) return role;
+      const on = tokens >= lc.thresholdTokens * (active.get(session) ? RELEASE : 1);
+      active.set(session, on);
+      if (!on) return role;
+      const same = r => r.provider === lc.provider && r.model === lc.model;
+      const rest = [{ provider: role.provider, model: role.model }, ...(role.fallbacks ?? [])].filter(r => !same(r));
+      return { ...role, provider: lc.provider, model: lc.model, fallbacks: rest, longContextActive: true };
+    },
+  };
+}