@aiwuk/team 0.0.0-stage → 5.0.8

package/runtime-view.js

@@ -0,0 +1,21 @@
+import { m as modelText } from './i18n.js';
+// Shared read-only bridge. Keys are Agent objects, never guessed from a project or display name.
+const readers = new WeakMap();
+const writers = new WeakMap();
+export function registerPolicyWriter(agent, save) {
+  writers.set(agent, save);
+  return () => { if (writers.get(agent) === save) writers.delete(agent); };
+}
+export async function saveTeamPolicy(agent, routes, revision) {
+  const save = writers.get(agent);
+  if (!save) throw new Error(modelText('runtime-view.372'));
+  return save(routes, revision);
+}
+export function registerTeamReader(agent, read) {
+  readers.set(agent, read);
+  return () => { if (readers.get(agent) === read) readers.delete(agent); };
+}
+export async function readTeamSnapshot(agent) {
+  const read = readers.get(agent);
+  return read ? await read() : null;
+}

package/scripts/memory-cli.mjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+// Bridge from the team memory hub to outside coding agents (e.g. a Claude Code UserPromptSubmit hook).
+// Recall sees only project and global pitfalls/decisions: teammates' role-private reports and session memories
+// never leave the hub, nothing is embedded or sent over the network, and recall never updates hit counters.
+// Writes are explicit, local, redacted, and limited to project/global scope so every team role can recall them.
+import { resolve } from 'node:path';
+import { m } from '../i18n.js';
+import { pathToFileURL } from 'node:url';
+import { createMemoryStore, tokenize } from '../memory-store.js';
+import { redactSecrets } from '../memory-redact.js';
+import { defaultRoot, projectRoot } from '../theme.js';
+
+export const RECALL_KINDS = ['pitfall', 'decision'];
+export const RECALL_ROLE = 'external-agent'; // never a team role id, so role-scoped memories stay hidden
+export const RECALL_HEADER = m('memory.recallHeader');
+export const RECALL_DEFAULTS = { k: 6, maxChars: 2400, maxQuery: 2000, minShared: 2 };
+
+export const WRITE_KINDS = ['pitfall', 'decision', 'note'];
+export const WRITE_SCOPES = ['project', 'global'];
+export const WRITE_LIMITS = { minText: 4, maxText: 2000, maxKey: 120, maxTags: 10, maxTag: 64 };
+
+const meaningful = text => new Set(tokenize(text).filter(t => t.length >= 2));
+
+/** Store one memory written on purpose by an outside agent; returns what was saved, never the raw input. */
+export async function writeMemory({ kind, text, scope = 'project', key, tags = [], cwd, root = defaultRoot(), now = Date.now }) {
+  if (!WRITE_KINDS.includes(kind)) throw new Error(`kind must be one of ${WRITE_KINDS.join(', ')}`);
+  if (!WRITE_SCOPES.includes(scope)) throw new Error(`scope must be one of ${WRITE_SCOPES.join(', ')}`);
+  const body = redactSecrets(String(text ?? '').replace(/\s+/g, ' ').trim());
+  if (body.length < WRITE_LIMITS.minText) throw new Error('text is too short');
+  if (body.length > WRITE_LIMITS.maxText) throw new Error(`text exceeds ${WRITE_LIMITS.maxText} characters`);
+  const topic = key == null || key === '' ? null : redactSecrets(String(key).trim());
+  if (topic !== null && (!topic || topic.length > WRITE_LIMITS.maxKey)) throw new Error(`key must be 1-${WRITE_LIMITS.maxKey} characters`);
+  const labels = [...new Set(tags.map(t => redactSecrets(String(t).trim())).filter(Boolean))];
+  if (labels.length > WRITE_LIMITS.maxTags || labels.some(t => t.length > WRITE_LIMITS.maxTag)) throw new Error(`at most ${WRITE_LIMITS.maxTags} tags of ${WRITE_LIMITS.maxTag} characters`);
+  let target = { kind: 'global' };
+  if (scope === 'project') {
+    if (!cwd) throw new Error('project scope needs a working directory');
+    target = { kind: 'project', project: projectRoot(cwd, root) };
+  }
+  const store = createMemoryStore(root, { now });
+  const saved = await store.write({ scope: target, kind, text: body, tags: labels, key: topic, source: { member: RECALL_ROLE, at: now() } });
+  return { saved: true, id: saved.memory.id, kind, scope, merged: saved.merged, superseded: saved.superseded.length, sync: 'local-only' };
+}
+
+/** Ranked memories for `query`, keeping only those sharing at least `minShared` multi-char tokens with it. */
+export async function recall({ query, cwd, root = defaultRoot(), k = RECALL_DEFAULTS.k, minShared = RECALL_DEFAULTS.minShared }) {
+  const text = redactSecrets(String(query ?? '').replace(/\s+/g, ' ').trim().slice(0, RECALL_DEFAULTS.maxQuery));
+  if (!text) return [];
+  const project = cwd ? projectRoot(cwd, root) : null;
+  const store = createMemoryStore(root);
+  const ranked = await store.search({ project, role: RECALL_ROLE, query: text, k: k * 3, kinds: RECALL_KINDS });
+  const wanted = meaningful(text);
+  return ranked.filter(({ memory }) => {
+    if (memory.scope.kind !== 'project' && memory.scope.kind !== 'global') return false;
+    if (minShared <= 0) return true;
+    let shared = 0;
+    for (const t of meaningful(memory.text)) if (wanted.has(t) && ++shared >= minShared) return true;
+    return false;
+  }).slice(0, k);
+}
+
+/** Injection block within `maxChars`, header included; empty when nothing fits. */
+export function formatRecall(results, maxChars = RECALL_DEFAULTS.maxChars) {
+  const lines = []; let used = RECALL_HEADER.length;
+  for (const { memory: m } of results) {
+    const line = `- [${m.kind}${m.scope.kind === 'global' ? '·global' : ''}] ${redactSecrets(m.text)}`;
+    if (used + 1 + line.length > maxChars) continue;
+    used += 1 + line.length; lines.push(line);
+  }
+  return lines.length ? [RECALL_HEADER, ...lines].join('\n') : '';
+}
+
+/** Hook payload (Claude Code UserPromptSubmit JSON on stdin) → hook output JSON string, or '' to add nothing. */
+export async function hookOutput(payload, options = {}) {
+  const prompt = payload?.prompt;
+  if (typeof prompt !== 'string' || !prompt.trim()) return '';
+  const block = formatRecall(await recall({ query: prompt, cwd: payload.cwd || process.cwd(), ...options }), options.maxChars);
+  if (!block) return '';
+  return JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: block } });
+}
+
+async function readStdin() {
+  let data = '';
+  for await (const chunk of process.stdin) data += chunk;
+  return data;
+}
+
+function parseArgs(argv) {
+  const out = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (['--cwd', '--k', '--kind', '--scope', '--key', '--tags'].includes(a)) out[a.slice(2)] = argv[++i];
+    else out._.push(a);
+  }
+  return out;
+}
+
+async function main(argv) {
+  const [command, ...rest] = argv;
+  if (command === 'hook') {
+    // A recall failure must never block the user's prompt: swallow everything and add no context.
+    try { const out = await hookOutput(JSON.parse(await readStdin() || '{}')); if (out) process.stdout.write(out); }
+    catch { /* degrade silently */ }
+    return 0;
+  }
+  if (command === 'search') {
+    const args = parseArgs(rest);
+    const k = Math.min(20, Math.max(1, Number.parseInt(args.k ?? RECALL_DEFAULTS.k, 10) || RECALL_DEFAULTS.k));
+    const results = await recall({ query: args._.join(' '), cwd: args.cwd ?? process.cwd(), k });
+    process.stdout.write(JSON.stringify(results.map(({ memory: m, score }) => ({
+      id: m.id, kind: m.kind, scope: m.scope.kind, tags: m.tags, score: Number(score.toFixed(5)), text: redactSecrets(m.text),
+    })), null, 2) + '\n');
+    return 0;
+  }
+  if (command === 'write') {
+    // Text comes from the arguments, or from stdin when none are given (safer for long or quoted text).
+    const args = parseArgs(rest);
+    const text = args._.length ? args._.join(' ') : await readStdin();
+    try {
+      const result = await writeMemory({ kind: args.kind, scope: args.scope ?? 'project', key: args.key, tags: args.tags ? args.tags.split(',') : [], text, cwd: args.cwd ?? process.cwd() });
+      process.stdout.write(JSON.stringify(result) + '\n');
+      return 0;
+    } catch (error) {
+      process.stderr.write(JSON.stringify({ saved: false, error: error.message }) + '\n');
+      return 1;
+    }
+  }
+  process.stderr.write([
+    'usage: memory-cli.mjs hook < payload.json',
+    '       memory-cli.mjs search <query> [--cwd dir] [--k n]',
+    '       memory-cli.mjs write --kind pitfall|decision|note [--scope project|global] [--key topic] [--tags a,b] [--cwd dir] [text | < text]',
+  ].join('\n') + '\n');
+  return 2;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  process.exitCode = await main(process.argv.slice(2));
+}

package/search-engines.js

@@ -0,0 +1,119 @@
+// Direct search/fetch engine drivers (Tavily, Brave, SearXNG, Jina) plus the HTTP plumbing they share with the
+// custom gateway driver in search.js. Every driver returns normalized data:
+//   search -> [{ title, url, snippet, published? }]     fetch -> { url, title?, content }
+// Errors carry `retryable`: availability failures (timeout, network, 401/403, 404, 429, 5xx, malformed 200)
+// let the dispatcher fall over to the next engine; invalid input (400, 413, 422) does not.
+// Upstream bodies are never echoed and a response that contains the key is blocked.
+/** What an upstream status means for the caller; error bodies are never echoed (they may carry secrets). */
+import { m } from './i18n.js';
+export const STATUS_HINT = Object.fromEntries([400, 401, 403, 404, 413, 422, 429, 502, 504].map((status, index) => [status, m(`search-engines.${373 + index}`)]));
+const NOT_RETRYABLE = new Set([400, 413, 422]);
+export const RESPONSE_CAP = 1024 * 1024;
+export function httpError(label, status) {
+  const error = new Error(`${label} HTTP ${status}${STATUS_HINT[status] ? ` (${STATUS_HINT[status]})` : ''}`);
+  error.status = status; error.retryable = !NOT_RETRYABLE.has(status) && (status >= 401);
+  return error;
+}
+/** An error from an engine; `retryable` decides whether the dispatcher tries the next engine. */
+export function engineError(message, retryable = true) { const error = new Error(message); error.retryable = retryable; return error; }
+/** Read a response body as text with the 1MB cap. */
+export async function readCapped(response, label) {
+  if (!response.body) throw engineError(m('search-engines.382', { 0: label }));
+  const reader = response.body.getReader(); const parts = []; let size = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read(); if (done) break;
+      size += value.byteLength;
+      if (size > RESPONSE_CAP) { await reader.cancel(); throw engineError(m('search-engines.383', { 0: label })); }
+      parts.push(value);
+    }
+  } finally { reader.releaseLock(); }
+  return Buffer.concat(parts).toString('utf8');
+}
+/** Combine the caller's abort signal with a per-request timeout. */
+export const withTimeout = (signal, ms) => { const timeout = AbortSignal.timeout(ms); return signal ? AbortSignal.any([signal, timeout]) : timeout; };
+/**
+ * One JSON request: redirects are errors, the body is capped, a body echoing the key is blocked and an error
+ * body is never read. A network failure or timeout is retryable unless the caller itself aborted.
+ */
+export async function requestJson(label, url, init, { fetcher = fetch, key, timeoutMs, signal } = {}) {
+  let response;
+  try { response = await fetcher(url, { ...init, redirect: 'error', signal: withTimeout(signal, timeoutMs) }); }
+  catch (error) {
+    if (signal?.aborted) throw error;
+    throw engineError(`${label}: ${m(error?.name === 'TimeoutError' ? 'search-engines.384' : 'search-engines.385')}`);
+  }
+  if (!response.ok) throw httpError(label, response.status);
+  const text = await readCapped(response, label);
+  if (key && text.includes(key)) throw engineError(m('search-engines.386'), false);
+  try { return JSON.parse(text); } catch { throw engineError(m('search-engines.387', { 0: label })); }
+}
+const clean = value => (typeof value === 'string' ? value.replace(/<[^>]{0,200}>/g, '').replace(/\s+/g, ' ').trim() : '');
+/** Normalize one result row; rows without a URL are dropped. */
+export function resultRow(row, { title = 'title', url = 'url', snippet = ['snippet', 'content', 'description'], published = [] } = {}) {
+  if (!row || typeof row !== 'object' || typeof row[url] !== 'string' || !row[url]) return undefined;
+  const out = { title: clean(row[title]) || row[url], url: row[url], snippet: clean(snippet.map(k => row[k]).find(v => typeof v === 'string' && v)) };
+  const date = published.map(k => row[k]).find(v => typeof v === 'string' && v);
+  if (date) out.published = date;
+  return out;
+}
+const rows = (list, limit, shape) => {
+  if (!Array.isArray(list)) return undefined;
+  return list.map(row => resultRow(row, shape)).filter(Boolean).slice(0, limit);
+};
+const noResults = label => engineError(m('search-engines.388', { 0: label }));
+const json = { 'Content-Type': 'application/json', Accept: 'application/json' };
+export const TAVILY_ORIGIN = 'https://api.tavily.com';
+export const BRAVE_ORIGIN = 'https://api.search.brave.com';
+export const JINA_READER = 'https://r.jina.ai/';
+
+/** Tavily search: POST /search with a Bearer key; news maps to topic "news". */
+export async function tavilySearch(body, { key, config, fetcher, signal }) {
+  if (!key) throw engineError(m('search-engines.389', { 0: config.tavilyKeyEnv }));
+  const payload = { query: body.query, max_results: body.max_results, topic: body.search_type === 'news' ? 'news' : 'general', search_depth: 'basic' };
+  const data = await requestJson('Tavily', `${TAVILY_ORIGIN}/search`, { method: 'POST', headers: { ...json, Authorization: `Bearer ${key}` }, body: JSON.stringify(payload) }, { fetcher, key, timeoutMs: config.engineTimeoutMs, signal });
+  return rows(data?.results, body.max_results, { snippet: ['content'], published: ['published_date'] }) ?? Promise.reject(noResults('Tavily'));
+}
+/** Brave Search API: GET web search (news uses the news endpoint) with X-Subscription-Token. */
+export async function braveSearch(body, { key, config, fetcher, signal }) {
+  if (!key) throw engineError(m('search-engines.390', { 0: config.braveKeyEnv }));
+  const news = body.search_type === 'news';
+  const url = new URL(`${BRAVE_ORIGIN}/res/v1/${news ? 'news' : 'web'}/search`);
+  url.searchParams.set('q', body.query); url.searchParams.set('count', String(Math.min(body.max_results, 20)));
+  const data = await requestJson('Brave', url.href, { method: 'GET', headers: { Accept: 'application/json', 'X-Subscription-Token': key } }, { fetcher, key, timeoutMs: config.engineTimeoutMs, signal });
+  // Brave omits the `web` block when a query has no hits; a reply of type "search" is still a valid answer.
+  const list = news ? data?.results : data?.web?.results ?? (data?.type === 'search' ? [] : undefined);
+  return rows(list, body.max_results, { snippet: ['description'], published: ['page_age', 'age'] }) ?? Promise.reject(noResults('Brave'));
+}
+/** SearXNG instance: GET {searxngUrl}/search?format=json; news and code map to the news / it categories. */
+export async function searxngSearch(body, { key, config, fetcher, signal }) {
+  if (!config.searxngUrl) throw engineError(m('search-engines.391'));
+  const url = new URL(`${config.searxngUrl}/search`);
+  url.searchParams.set('q', body.query); url.searchParams.set('format', 'json');
+  const category = { news: 'news', code: 'it' }[body.search_type];
+  if (category) url.searchParams.set('categories', category);
+  const headers = { Accept: 'application/json', ...(key ? { Authorization: `Bearer ${key}` } : {}) };
+  const data = await requestJson('SearXNG', url.href, { method: 'GET', headers }, { fetcher, key, timeoutMs: config.engineTimeoutMs, signal });
+  return rows(data?.results, body.max_results, { snippet: ['content'], published: ['publishedDate'] }) ?? Promise.reject(noResults('SearXNG'));
+}
+const pageContent = (label, url, title, content) => {
+  if (typeof content !== 'string' || !content.trim()) throw engineError(m('search-engines.392', { 0: label }));
+  return { url, ...(typeof title === 'string' && title.trim() ? { title: title.trim() } : {}), content };
+};
+/** Jina Reader: GET r.jina.ai/{url}; works without a key, an optional key raises the rate limit. */
+export async function jinaFetch(body, { key, config, fetcher, signal }) {
+  const headers = { Accept: 'application/json', 'X-Return-Format': body.format === 'html' ? 'html' : 'markdown', ...(key ? { Authorization: `Bearer ${key}` } : {}) };
+  const data = await requestJson('Jina', `${JINA_READER}${body.url}`, { method: 'GET', headers }, { fetcher, key, timeoutMs: config.engineTimeoutMs, signal });
+  const page = data?.data ?? data;
+  return pageContent('Jina', page?.url || body.url, page?.title, page?.content ?? page?.html);
+}
+/** Tavily Extract: POST /extract for one URL. */
+export async function tavilyFetch(body, { key, config, fetcher, signal }) {
+  if (!key) throw engineError(m('search-engines.389', { 0: config.tavilyKeyEnv }));
+  const payload = { urls: [body.url], format: body.format === 'html' ? 'text' : 'markdown' };
+  const data = await requestJson('Tavily', `${TAVILY_ORIGIN}/extract`, { method: 'POST', headers: { ...json, Authorization: `Bearer ${key}` }, body: JSON.stringify(payload) }, { fetcher, key, timeoutMs: config.engineTimeoutMs, signal });
+  const page = Array.isArray(data?.results) ? data.results[0] : undefined;
+  return pageContent('Tavily', page?.url || body.url, page?.title, page?.raw_content);
+}
+export const SEARCH_DRIVERS = Object.freeze({ tavily: tavilySearch, brave: braveSearch, searxng: searxngSearch });
+export const FETCH_DRIVERS = Object.freeze({ jina: jinaFetch, tavily: tavilyFetch });

package/search.js

@@ -0,0 +1,164 @@
+import { m as modelText } from './i18n.js';
+// Search/fetch dispatcher: picks engines from integrations.search, falls over on availability failures and
+// returns normalized results. Direct engine drivers live in search-engines.js; the `custom` engine is any
+// gateway speaking the generic search/fetch/providers protocol, implemented here by `gateway`.
+import { params } from './tool-schema.js';
+import { INTEGRATION_DEFAULTS, SEARCH_ENGINES, SEARCH_KEY_FIELDS, engineKeyOf, keyOf, refreshCredentials, resolveIntegrations } from './integrations-config.js';
+import { FETCH_DRIVERS, SEARCH_DRIVERS, engineError, httpError, readCapped, resultRow, withTimeout } from './search-engines.js';
+export { STATUS_HINT, httpError } from './search-engines.js';
+// Engine order, paths, headers and the provider lists are configuration (integrations.search), never code.
+export function requestBody(kind, args, config = INTEGRATION_DEFAULTS.search) {
+  const allowed = kind === 'search' ? ['query','max_results','search_type','provider'] : ['url','format','provider'];
+  if (!args || Object.keys(args).some(key => !allowed.includes(key))) throw new Error(modelText('search.394'));
+  const body = {};
+  if (kind === 'search') {
+    if (typeof args.query !== 'string' || !args.query.trim() || args.query.length > 4000) throw new Error(modelText('search.395'));
+    body.query = args.query; body.max_results = args.max_results ?? 5; body.search_type = args.search_type ?? 'web';
+    if (!Number.isInteger(body.max_results) || body.max_results < 1 || body.max_results > 20) throw new Error(modelText('search.396'));
+    if (!['web','news','code'].includes(body.search_type)) throw new Error(modelText('search.397'));
+  } else {
+    const url = new URL(args.url);
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || /^(localhost|127\.|0\.|10\.|192\.168\.|169\.254\.|\[|.*\.local$)/i.test(url.hostname) || /^172\.(1[6-9]|2\d|3[01])\./.test(url.hostname)) throw new Error(modelText('search.398'));
+    body.url = url.href; body.format = args.format ?? 'markdown';
+    if (!['markdown','html'].includes(body.format)) throw new Error(modelText('search.399'));
+  }
+  if (args.provider !== undefined) {
+    const allowed = kind === 'search' ? config.providers : config.fetchProviders;
+    // With a configured list only those providers pass; without one, any provider token goes to the gateway.
+    if (typeof args.provider !== 'string' || !/^[\w.:-]{1,64}$/.test(args.provider) || (allowed.length && !allowed.includes(args.provider))) throw new Error(modelText('search.400'));
+    body.provider = args.provider;
+  }
+  return body;
+}
+/**
+ * Gateway base from configuration; only a credential-free https origin (optional path prefix) is accepted.
+ * `field`/`envName` name where the address comes from, for the error message.
+ */
+export function gatewayBase(raw, { what = modelText('search.401'), field = 'search.baseUrl', envName = 'OMNI_SEARCH_BASE_URL' } = {}) {
+  if (!raw) throw new Error(modelText('search.402', { 0: what, 1: field, 2: envName }));
+  let url;
+  try { url = new URL(raw); } catch { throw new Error(modelText('search.403', { 0: envName })); }
+  if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash) throw new Error(modelText('search.404', { 0: envName }));
+  return url.href.replace(/\/+$/, '');
+}
+/** Search/fetch config and every engine key as resolved now; tests and callers may pass them explicitly. */
+export function searchSettings(resolved = resolveIntegrations()) {
+  const keys = Object.fromEntries(Object.keys(SEARCH_KEY_FIELDS).map(engine => [engine, engineKeyOf(engine, resolved)]));
+  return { config: resolved.effective.search, key: keyOf('search', resolved), keyEnv: resolved.keys.search.env, keys };
+}
+const engineKey = (settings, engine) => (engine === 'custom' ? settings.keys?.custom ?? settings.key : settings.keys?.[engine]);
+/** Whether an engine has what it needs to be tried in auto mode (a key, or a URL for SearXNG / custom). */
+export function engineConfigured(engine, settings) {
+  const { config } = settings;
+  if (engine === 'searxng') return !!config.searxngUrl;
+  if (engine === 'custom') return !!config.baseUrl;
+  return !!engineKey(settings, engine);
+}
+/** Ordered search engines: the configured list, or auto = every configured engine in default order. */
+export function activeEngines(settings) {
+  return settings.config.engines ?? SEARCH_ENGINES.filter(engine => engineConfigured(engine, settings));
+}
+/** Whether `custom` takes part in search (explicit list, or auto with a gateway address). */
+export const customActive = config => (config.engines ? config.engines.includes('custom') : !!config.baseUrl);
+const fetchEnginesOf = config => config.fetchEngines ?? INTEGRATION_DEFAULTS.search.fetchEngines;
+/** A 200 still has to carry a real result: search needs a results list, fetch needs page content. */
+export function checkResult(kind, data) {
+  if (kind === 'search' && !Array.isArray(data?.results)) throw engineError(modelText('search.405'));
+  if (kind === 'fetch' && !(typeof data?.content === 'string' && data.content.trim())) throw engineError(modelText('search.406'));
+  if (kind === 'providers' && !Array.isArray(data?.data)) throw engineError(modelText('search.407'));
+  return data;
+}
+/** The `custom` engine: one request to the configured gateway (search, fetch or providers), raw checked data. */
+export async function gateway(kind, args, { fetcher = fetch, settings, key, base, signal } = {}) {
+  if (!settings && key === undefined) await refreshCredentials();
+  const current = settings ?? searchSettings();
+  const config = { ...current.config, ...(base !== undefined ? { baseUrl: base } : {}) };
+  const secret = key !== undefined ? key : engineKey(current, 'custom');
+  const body = kind === 'providers' ? undefined : requestBody(kind, args, config);
+  if (!secret) throw engineError(modelText('search.408', { 0: current.keyEnv ?? config.apiKeyEnv }));
+  const origin = gatewayBase(config.baseUrl);
+  if (kind === 'providers' && !config.providersPath) throw new Error(modelText('search.409'));
+  const path = { search: config.searchPath, fetch: config.fetchPath, providers: config.providersPath }[kind];
+  let response;
+  try {
+    response = await fetcher(`${origin}${path}`, {
+      method: body ? 'POST' : 'GET', redirect: 'error', signal: withTimeout(signal, kind === 'fetch' ? config.fetchTimeoutMs : config.timeoutMs),
+      headers: { ...config.headers, Authorization: `Bearer ${secret}`, ...(body ? { 'Content-Type': 'application/json' } : {}) }, ...(body ? { body: JSON.stringify(body) } : {}),
+    });
+  } catch (error) { if (signal?.aborted) throw error; throw engineError(modelText('search.410', { 0: error?.name === 'TimeoutError' ? modelText('search.411') : modelText('search.412') })); }
+  // Never echo error bodies: gateways may include secrets or upstream headers.
+  if (!response.ok) throw httpError(modelText('search.413'), response.status);
+  const text = await readCapped(response, modelText('search.414'));
+  if (text.includes(secret)) throw engineError(modelText('search.415'), false);
+  let data;
+  try { data = JSON.parse(text); } catch { throw engineError(modelText('search.416')); }
+  return checkResult(kind, data);
+}
+const RESULT_SHAPE = { snippet: ['snippet', 'content', 'description'], published: ['published', 'published_date', 'publishedDate'] };
+async function customSearch(body, { args, ...opts }) {
+  const data = await gateway('search', args, opts);
+  return data.results.map(row => resultRow(row, RESULT_SHAPE)).filter(Boolean).slice(0, body.max_results);
+}
+async function customFetch(body, { args, ...opts }) {
+  const data = await gateway('fetch', args, opts);
+  return { url: typeof data.url === 'string' && data.url ? data.url : body.url, ...(typeof data.title === 'string' && data.title.trim() ? { title: data.title.trim() } : {}), content: data.content };
+}
+// Run engines in order; only a retryable failure moves on. The final error lists each engine's (safe) reason.
+async function failover(label, engines, attempt) {
+  const reasons = [];
+  for (const engine of engines) {
+    try { return await attempt(engine); }
+    catch (error) {
+      if (error?.retryable !== true) throw error;
+      reasons.push(`${engine}: ${error.message}`);
+    }
+  }
+  throw new Error(modelText('search.417', { 0: label, 1: reasons.join('；') }));
+}
+const NO_ENGINE = modelText('search.418');
+/**
+ * Search, fetch or list custom providers. Search -> { engine, results }, fetch -> { engine, url, title?, content },
+ * providers -> the custom gateway's raw list.
+ */
+export async function omni(kind, args, { fetcher = fetch, settings, signal } = {}) {
+  if (!settings) await refreshCredentials();
+  const current = settings ?? searchSettings();
+  const { config } = current;
+  if (kind === 'providers') {
+    if (!customActive(config)) throw new Error(modelText('search.419'));
+    return gateway('providers', args, { fetcher, settings: current, signal });
+  }
+  const body = requestBody(kind, args, config);
+  const opts = key => ({ key, config, fetcher, signal, args, settings: current });
+  if (kind === 'search') {
+    const engines = activeEngines(current);
+    if (args.provider !== undefined && !engines.includes('custom')) throw new Error(modelText('search.420'));
+    if (!engines.length) throw new Error(NO_ENGINE);
+    return failover(modelText('search.421'), engines, async engine => {
+      const driver = engine === 'custom' ? customSearch : SEARCH_DRIVERS[engine];
+      return { engine, results: await driver(body, opts(engineKey(current, engine))) };
+    });
+  }
+  const engines = fetchEnginesOf(config);
+  if (args.provider !== undefined && !engines.includes('custom')) throw new Error(modelText('search.422'));
+  return failover(modelText('search.423'), engines, async engine => {
+    const driver = engine === 'custom' ? customFetch : FETCH_DRIVERS[engine];
+    return { engine, ...(await driver(body, opts(engineKey(current, engine)))) };
+  });
+}
+/**
+ * Tool schemas. `provider` exists only when the custom engine takes part; a configured provider list becomes
+ * its enum. The providers tool needs the custom engine and a providersPath.
+ */
+export function searchSchemas(config = INTEGRATION_DEFAULTS.search) {
+  const provider = list => (list.length ? { type: 'string', enum: list } : { type: 'string', description: modelText('search.424') });
+  const custom = customActive(config);
+  return {
+    omni_search: params({ query: { type: 'string', description: modelText('search.425') }, max_results: { type: 'integer', description: modelText('search.426') }, search_type: { type: 'string', enum: ['web','news','code'] },
+      ...(custom ? { provider: provider(config.providers) } : {}) }, ['query']),
+    omni_fetch: params({ url: { type: 'string', description: modelText('search.427') }, format: { type: 'string', enum: ['markdown','html'] },
+      ...(fetchEnginesOf(config).includes('custom') ? { provider: provider(config.fetchProviders) } : {}) }, ['url']),
+    ...(custom && config.providersPath ? { omni_search_providers: params({}, []) } : {}),
+  };
+}
+export const schemas = searchSchemas();

package/session-policy.js

@@ -0,0 +1,59 @@
+import { m as modelText } from './i18n.js';
+import { mkdir, readFile, writeFile, rename, unlink } from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { defaultRoot, acquireLock } from './theme.js';
+import { validateDisabledRoutes } from './model-policy.js';
+const profileNamespace = () => process.env.DSH_PROFILE_DIR ?? process.env.DSH_PROFILE ?? 'default';
+export function sessionPolicyPath(sessionId, root = defaultRoot()) {
+  if (typeof sessionId !== 'string' || !sessionId) throw new Error(modelText('session-policy.428'));
+  return join(root, 'sessions', createHash('sha256').update(JSON.stringify([profileNamespace(), sessionId])).digest('hex') + '.json');
+}
+/** One model policy per DSH profile, shared by every capability-team session. */
+export function globalPolicyPath(root = defaultRoot()) {
+  return join(root, 'model-policy', createHash('sha256').update(JSON.stringify([profileNamespace(), 'global'])).digest('hex') + '.json');
+}
+function parsePolicy(raw) {
+  try {
+    const data = JSON.parse(raw);
+    if (!Number.isSafeInteger(data.revision) || data.revision < 1) throw new Error(modelText('session-policy.429'));
+    return { revision: data.revision, disabledRoutes: validateDisabledRoutes(data.disabledRoutes) };
+  } catch (error) { throw new Error(modelText('session-policy.430', { 0: error.message })); }
+}
+async function readPolicyAt(path) {
+  let raw;
+  try { raw = await readFile(path, 'utf8'); }
+  catch (error) { if (error.code === 'ENOENT') return { revision: 0, disabledRoutes: [] }; throw error; }
+  return parsePolicy(raw);
+}
+function readPolicyAtSync(path) {
+  let raw;
+  try { raw = readFileSync(path, 'utf8'); }
+  catch (error) { if (error.code === 'ENOENT') return { revision: 0, disabledRoutes: [] }; throw error; }
+  return parsePolicy(raw);
+}
+export const readSessionPolicy = (sessionId, root) => readPolicyAt(sessionPolicyPath(sessionId, root));
+export const readSessionPolicySync = (sessionId, root) => readPolicyAtSync(sessionPolicyPath(sessionId, root));
+export const saveSessionPolicy = (sessionId, disabledRoutes, expectedRevision, root) => savePolicyAt(sessionPolicyPath(sessionId, root), disabledRoutes, expectedRevision);
+export const readGlobalPolicy = root => readPolicyAt(globalPolicyPath(root));
+export const readGlobalPolicySync = root => readPolicyAtSync(globalPolicyPath(root));
+export const saveGlobalPolicy = (disabledRoutes, expectedRevision, root) => savePolicyAt(globalPolicyPath(root), disabledRoutes, expectedRevision);
+async function savePolicyAt(path, disabledRoutes, expectedRevision) {
+  const disabled = validateDisabledRoutes(disabledRoutes);
+  if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0) throw new Error(modelText('session-policy.431'));
+  await mkdir(join(path, '..'), { recursive: true });
+  const lock = await acquireLock(path + '.lock');
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    const current = await readPolicyAt(path);
+    if (current.revision !== expectedRevision) throw new Error(modelText('session-policy.432'));
+    const next = { revision: current.revision + 1, disabledRoutes: disabled };
+    await writeFile(temporary, JSON.stringify(next, null, 2) + '\n', { flag: 'wx' });
+    await rename(temporary, path);
+    return next;
+  } finally {
+    try { await unlink(temporary).catch(error => { if (error.code !== 'ENOENT') throw error; }); }
+    finally { try { await lock.close(); } finally { await unlink(path + '.lock').catch(error => { if (error.code !== 'ENOENT') throw error; }); } }
+  }
+}