@cairnkeep/cli 2.24.0 → 2.25.0

package/mcp-memory-server/dist/team-cli.js

@@ -0,0 +1,218 @@
+import { closeSync, existsSync, openSync, writeFileSync, fsyncSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { readStableJson } from './stable-file.js';
+import { hardenPrivatePath } from './platform-security.js';
+import { openTeamStore, restoreTeamSnapshot, verifyTeamSnapshot, prepareTeamPrivateDirectory, TEAM_SNAPSHOT_MAX_BYTES, TeamError } from './team-store.js';
+import { createTeamHttpServer, teamRequest } from './team-http.js';
+import { createTeamMcpServer, teamClientToken } from './team-mcp.js';
+const HELP = `cairn team — experimental token-first team continuity (default off)
+
+CAIRN_TEAM=1 is required. Personal memory is never uploaded.
+
+  cairn team init --organization ID [--data DIR]
+  cairn team project create ID [--data DIR]
+  cairn team member set SUBJECT --project ID --roles LIST [--data DIR]
+  cairn team member remove SUBJECT --project ID [--data DIR]
+  cairn team credential issue SUBJECT --class human|workload --expires-at ISO --output FILE [--data DIR]
+  cairn team credential revoke ID [--data DIR]
+  cairn team serve [--data DIR] [--port PORT]  # requires CAIRN_TEAM_HTTP=1; loopback only
+  cairn team mcp [--project-root PATH]        # local stdio MCP; no review/admin tools
+  cairn team list --project ID
+  cairn team proposals --project ID
+  cairn team audit --project ID             # scoped, value-free metadata
+  cairn team read --project ID --key KEY [--revision DIGEST]
+  cairn team history --project ID --key KEY
+  cairn team search --project ID --query TEXT
+  cairn team proposal-show --project ID --proposal ID
+  cairn team propose --project ID --input FILE --confirm VALUE_DIGEST
+  cairn team review --project ID --proposal ID --decision approve|reject --confirm PROPOSAL_DIGEST
+  cairn team doctor [--data DIR]
+  cairn team backup --output FILE [--data DIR]
+  cairn team restore --input FILE --confirm SNAPSHOT_DIGEST --data NEW_DIR
+  cairn team memory-delete --project ID --key KEY --confirm REVISION_DIGEST [--data DIR]
+
+Clients require CAIRN_TEAM_URL, CAIRN_TEAM_ORGANIZATION and CAIRN_TEAM_TOKEN_FILE.
+Never put tokens in command arguments, source trees or harness config.
+Team API is not OAuth MCP HTTP. Independent production security review and a
+deployment-specific approved real-data pilot remain admission gates. See docs/team.md.
+`;
+function parse(args) {
+    const words = [];
+    const flags = {};
+    const known = new Set(['data', 'organization', 'project', 'roles', 'class', 'expires-at', 'output', 'port', 'project-root', 'key', 'revision', 'query', 'proposal', 'input', 'confirm', 'decision']);
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith('--')) {
+            const name = arg.slice(2);
+            if (!known.has(name) || flags[name] !== undefined || !args[i + 1] || args[i + 1].startsWith('--'))
+                throw new TeamError('invalid');
+            flags[name] = args[++i];
+        }
+        else
+            words.push(arg);
+    }
+    return { words, flags };
+}
+export function writePrivateExclusive(path, bytes) {
+    path = resolve(path);
+    const directory = dirname(path);
+    prepareTeamPrivateDirectory(directory, true);
+    const fd = openSync(path, 'wx', 0o600);
+    try {
+        hardenPrivatePath(path);
+        writeFileSync(fd, bytes, 'utf8');
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+async function main(args) {
+    if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+        console.log(HELP);
+        return;
+    }
+    if (process.env.CAIRN_TEAM !== '1')
+        throw new TeamError('disabled');
+    const { words, flags } = parse(args);
+    const [command, subcommand, subject] = words;
+    const allowed = {
+        init: ['data', 'organization'], project: ['data'], member: subcommand === 'remove' ? ['data', 'project'] : ['data', 'project', 'roles'],
+        credential: subcommand === 'issue' ? ['data', 'class', 'expires-at', 'output'] : ['data'],
+        serve: ['data', 'port'], mcp: ['project-root'], doctor: ['data'], backup: ['data', 'output'],
+        restore: ['data', 'input', 'confirm'], 'memory-delete': ['data', 'project', 'key', 'confirm'],
+        list: ['project'], proposals: ['project'], audit: ['project'], read: ['project', 'key', 'revision'],
+        history: ['project', 'key'], search: ['project', 'query'], 'proposal-show': ['project', 'proposal'],
+        propose: ['project', 'input', 'confirm'], review: ['project', 'proposal', 'decision', 'confirm'],
+    };
+    if (!allowed[command] || Object.keys(flags).some(flag => !allowed[command].includes(flag)))
+        throw new TeamError('invalid');
+    const memberRoles = (flags.roles ?? '').split(',').filter(Boolean);
+    if (command === 'member' && (!['set', 'remove'].includes(subcommand) || !subject || words.length !== 3 || !flags.project || (subcommand === 'set' && memberRoles.length === 0)))
+        throw new TeamError('invalid');
+    const root = resolve(flags.data ?? process.env.CAIRN_TEAM_BASE_DIR ?? join(homedir(), '.cairnkeep', 'team'));
+    const print = (result) => console.log(JSON.stringify(result, null, 2));
+    let store;
+    try {
+        if (command === 'mcp') {
+            if (words.length !== 1)
+                throw new TeamError('invalid');
+            teamClientToken(); // validate private credential before startup
+            const server = await createTeamMcpServer({ url: process.env.CAIRN_TEAM_URL ?? '', organization: process.env.CAIRN_TEAM_ORGANIZATION ?? '', token: () => teamClientToken(), projectRoot: flags['project-root'] });
+            await server.connect(new StdioServerTransport());
+            return;
+        }
+        if (command === 'restore') {
+            if (words.length !== 1 || !flags.input || !flags.confirm || !flags.data)
+                throw new TeamError('invalid');
+            const snapshot = verifyTeamSnapshot(readStableJson(resolve(flags.input), { label: 'Team snapshot', maxBytes: TEAM_SNAPSHOT_MAX_BYTES, private: true }));
+            store = await restoreTeamSnapshot(root, snapshot, flags.confirm);
+            print({ restored: true, organization: store.organization, credentials_revoked: true });
+            return;
+        }
+        if (['init', 'project', 'member', 'credential', 'serve', 'doctor', 'backup', 'memory-delete'].includes(command)) {
+            if (command === 'init' && (words.length !== 1 || !flags.organization))
+                throw new TeamError('invalid');
+            store = await openTeamStore(root, command === 'init' ? { create: true, organization: flags.organization } : {});
+            if (command === 'doctor' && words.length === 1) {
+                print(await store.doctor());
+                return;
+            }
+            if (command === 'backup' && words.length === 1) {
+                if (!flags.output)
+                    throw new TeamError('invalid');
+                const snapshot = await store.snapshot();
+                writePrivateExclusive(flags.output, `${JSON.stringify(snapshot)}\n`);
+                print({ snapshot_digest: snapshot.digest, written: true });
+                return;
+            }
+            if (command === 'memory-delete' && words.length === 1) {
+                await store.admin({ operation: 'memory-delete', project: flags.project, key: flags.key, confirm: flags.confirm });
+                print({ deleted: true, backup_copies_retained: true });
+                return;
+            }
+            if (command === 'init') {
+                print({ initialized: true, organization: store.organization, experimental: true });
+                return;
+            }
+            if (command === 'project' && subcommand === 'create' && subject && words.length === 3) {
+                await store.admin({ operation: 'project-create', project: subject });
+                print({ created: true });
+                return;
+            }
+            if (command === 'member') {
+                await store.admin({ operation: 'member-set', subject, project: flags.project, roles: subcommand === 'remove' ? [] : memberRoles });
+                print(subcommand === 'remove' ? { removed: true } : { updated: true });
+                return;
+            }
+            if (command === 'credential' && subcommand === 'issue' && subject && words.length === 3) {
+                if (!flags.output || existsSync(resolve(flags.output)))
+                    throw new TeamError('invalid');
+                const credential = await store.issue({ subject, credential_class: flags.class, expires_at: flags['expires-at'] });
+                try {
+                    writePrivateExclusive(flags.output, `${credential.token}\n`);
+                }
+                catch (error) {
+                    await store.admin({ operation: 'credential-revoke', credential: credential.id });
+                    throw error;
+                }
+                print({ credential_id: credential.id, token_file_created: true });
+                return;
+            }
+            if (command === 'credential' && subcommand === 'revoke' && subject && words.length === 3) {
+                await store.admin({ operation: 'credential-revoke', credential: subject });
+                print({ revoked: true });
+                return;
+            }
+            if (command === 'serve' && words.length === 1) {
+                const raw = flags.port ?? '7955';
+                if (!/^[1-9][0-9]{0,4}$/.test(raw) || Number(raw) > 65535)
+                    throw new TeamError('invalid');
+                const server = createTeamHttpServer(store);
+                await new Promise((resolve, reject) => { server.once('error', reject); server.listen(Number(raw), '127.0.0.1', resolve); });
+                process.stderr.write(`Team preview API listening on loopback port ${raw}.\n`);
+                await new Promise(resolve => {
+                    const stop = () => { server.close(() => resolve()); server.closeAllConnections(); };
+                    process.once('SIGINT', stop);
+                    process.once('SIGTERM', stop);
+                });
+                return;
+            }
+            throw new TeamError('invalid');
+        }
+        if (words.length !== 1 || !flags.project)
+            throw new TeamError('invalid');
+        const common = { organization: process.env.CAIRN_TEAM_ORGANIZATION, project: flags.project, operation: command };
+        let input;
+        if (['list', 'proposals', 'audit'].includes(command))
+            input = common;
+        else if (['read', 'history'].includes(command))
+            input = { ...common, key: flags.key, ...(flags.revision ? { revision: flags.revision } : {}) };
+        else if (command === 'search')
+            input = { ...common, query: flags.query };
+        else if (command === 'proposal-show')
+            input = { ...common, proposal_id: flags.proposal };
+        else if (command === 'review')
+            input = { ...common, proposal_id: flags.proposal, decision: flags.decision, confirm: flags.confirm };
+        else if (command === 'propose') {
+            if (!flags.input || !flags.confirm)
+                throw new TeamError('invalid');
+            const selected = readStableJson(resolve(flags.input), { label: 'Team selected proposal', maxBytes: 512 * 1024, private: true });
+            if (!selected || typeof selected !== 'object' || Array.isArray(selected))
+                throw new TeamError('invalid');
+            input = { ...selected, ...common, confirm: flags.confirm };
+        }
+        else
+            throw new TeamError('invalid');
+        print(await teamRequest(process.env.CAIRN_TEAM_URL ?? '', teamClientToken(), input));
+    }
+    finally {
+        await store?.close();
+    }
+}
+void main(process.argv.slice(2)).catch(error => {
+    process.stderr.write(`${error instanceof TeamError ? error.message : 'Team operation failed; no credential or input content is logged.'}\n`);
+    process.exitCode = 1;
+});

package/mcp-memory-server/dist/team-http.js

@@ -0,0 +1,193 @@
+import { createServer } from 'node:http';
+import { normalizeHostAuthority } from './http-security.js';
+import { TeamError, teamDigest } from './team-store.js';
+const MAX_BODY = 512 * 1024;
+const MAX_RESPONSE = 2 * 1024 * 1024;
+function reply(response, status, body) {
+    const bytes = Buffer.from(JSON.stringify(body));
+    if (bytes.byteLength > MAX_RESPONSE) {
+        reply(response, 503, { error: 'unavailable' });
+        return;
+    }
+    response.writeHead(status, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff', 'Content-Length': bytes.byteLength, ...(status >= 400 ? { Connection: 'close' } : {}) });
+    response.end(bytes);
+}
+async function body(request) {
+    if (request.headers['content-type'] !== 'application/json')
+        throw new TeamError('invalid');
+    const chunks = [];
+    await new Promise((resolve, reject) => {
+        let size = 0;
+        const cleanup = () => { request.off('data', onData); request.off('end', onEnd); request.off('error', onError); request.off('aborted', onError); };
+        const onError = () => { cleanup(); reject(new TeamError('invalid')); };
+        const onEnd = () => { cleanup(); resolve(); };
+        const onData = (chunk) => {
+            size += chunk.byteLength;
+            if (size > MAX_BODY) {
+                cleanup();
+                request.pause();
+                reject(new RangeError('body-limit'));
+            }
+            else
+                chunks.push(chunk);
+        };
+        request.on('data', onData);
+        request.once('end', onEnd);
+        request.once('error', onError);
+        request.once('aborted', onError);
+    });
+    try {
+        return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
+    }
+    catch {
+        throw new TeamError('invalid');
+    }
+}
+/** This is a token-first JSON API, not OAuth-authorized remote MCP. It only
+ * listens on loopback; use an authenticated encrypted tunnel for remote use. */
+export function createTeamHttpServer(store) {
+    if (process.env.CAIRN_TEAM !== '1' || process.env.CAIRN_TEAM_HTTP !== '1')
+        throw new TeamError('disabled');
+    const fixedWindow = (requests) => {
+        const limits = new Map();
+        return (key) => {
+            const now = Date.now();
+            for (const [id, state] of limits)
+                if (now - state.start >= 60000)
+                    limits.delete(id);
+            let state = limits.get(key);
+            if (!state) {
+                if (limits.size >= 512)
+                    return false;
+                limits.set(key, state = { start: now, count: 0 });
+            }
+            return ++state.count <= requests;
+        };
+    };
+    // Invalid authentication must remain bounded without consuming the scarce
+    // quota of an authenticated subject that happens to share loopback/tunnel.
+    const malformedAuthAdmitted = fixedWindow(120);
+    const invalidCredentialAdmitted = fixedWindow(10);
+    const subjectAdmitted = fixedWindow(120);
+    const server = createServer({ maxHeaderSize: 32 * 1024 }, (request, response) => {
+        void (async () => {
+            // Reject browser access and host rebinding before reading any body.
+            const authority = normalizeHostAuthority(request.headers.host);
+            const port = request.socket.localPort;
+            if (!['127.0.0.1', '::1', '::ffff:127.0.0.1'].includes(request.socket.localAddress ?? '') || !authority || ![`127.0.0.1:${port}`, `localhost:${port}`, `[::1]:${port}`].includes(authority) || request.headers.origin !== undefined) {
+                reply(response, 403, { error: 'denied' });
+                return;
+            }
+            if (request.url !== '/v1/team/execute') {
+                reply(response, 404, { error: 'not-found' });
+                return;
+            }
+            if (request.method !== 'POST') {
+                reply(response, 405, { error: 'method' });
+                return;
+            }
+            const authHeaders = request.rawHeaders.filter((_, i) => i % 2 === 0 && request.rawHeaders[i].toLowerCase() === 'authorization');
+            const token = /^Bearer ([A-Za-z0-9_-]{43})$/.exec(request.headers.authorization ?? '')?.[1];
+            if (!token || authHeaders.length !== 1) {
+                const key = teamDigest(`malformed:${request.socket.remoteAddress ?? ''}`);
+                const admitted = malformedAuthAdmitted(key);
+                reply(response, admitted ? 401 : 429, { error: admitted ? 'unauthorized' : 'rate-limit' });
+                return;
+            }
+            let identity;
+            try {
+                identity = await store.checkCredential(token);
+            }
+            catch (error) {
+                if (!(error instanceof TeamError) || error.code !== 'unauthorized')
+                    throw error;
+                const admitted = invalidCredentialAdmitted(teamDigest(`credential:${token}`));
+                reply(response, admitted ? 401 : 429, { error: admitted ? 'unauthorized' : 'rate-limit' });
+                return;
+            }
+            if (!subjectAdmitted(teamDigest(identity.subject))) {
+                reply(response, 429, { error: 'rate-limit' });
+                return;
+            }
+            const length = request.headers['content-length'];
+            if (length && (!/^[0-9]+$/.test(length) || Number(length) > MAX_BODY)) {
+                reply(response, 413, { error: 'body-limit' });
+                return;
+            }
+            request.setTimeout(10000, () => request.destroy());
+            const input = await body(request);
+            const result = await store.execute(token, input); // reauthorize after body receipt
+            reply(response, 200, { result });
+        })().catch(error => {
+            const status = error instanceof TeamError ? ({ unauthorized: 401, denied: 403, invalid: 400, conflict: 409, disabled: 503, integrity: 503 }[error.code]) : error instanceof RangeError ? 413 : 503;
+            if (!response.headersSent && !response.destroyed)
+                reply(response, status, { error: error instanceof TeamError ? error.code : status === 413 ? 'body-limit' : 'unavailable' });
+        });
+    });
+    server.headersTimeout = 10000;
+    server.requestTimeout = 30000;
+    server.keepAliveTimeout = 5000;
+    server.maxRequestsPerSocket = 100;
+    server.on('clientError', (_error, socket) => { if (socket.writable)
+        socket.end('HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-Length: 0\r\n\r\n'); });
+    return server;
+}
+export function validateTeamUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new TeamError('invalid');
+    }
+    const loopback = ['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname);
+    if (url.username || url.password || url.search || url.hash || url.pathname !== '/' || (url.protocol !== 'https:' && !(url.protocol === 'http:' && loopback)))
+        throw new TeamError('invalid');
+    return url;
+}
+export async function teamRequest(rawUrl, token, input) {
+    if (process.env.CAIRN_TEAM !== '1')
+        throw new TeamError('disabled');
+    const url = validateTeamUrl(rawUrl);
+    if (!/^[A-Za-z0-9_-]{43}$/.test(token))
+        throw new TeamError('unauthorized');
+    const bytes = JSON.stringify(input);
+    if (Buffer.byteLength(bytes) > MAX_BODY)
+        throw new TeamError('invalid');
+    try {
+        const response = await fetch(new URL('/v1/team/execute', url), { method: 'POST', redirect: 'error', signal: AbortSignal.timeout(15000), headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' }, body: bytes });
+        const errorCode = response.status === 401 ? 'unauthorized' : response.status === 403 ? 'denied' : response.status === 409 ? 'conflict' : response.status === 400 ? 'invalid' : 'integrity';
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new TeamError(errorCode);
+        }
+        const chunks = [];
+        let size = 0;
+        if (!response.body)
+            throw new TeamError('integrity');
+        const reader = response.body.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                size += value.byteLength;
+                if (size > MAX_RESPONSE)
+                    throw new TeamError('integrity');
+                chunks.push(value);
+            }
+        }
+        finally {
+            await reader.cancel().catch(() => undefined);
+        }
+        const parsed = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || Object.keys(parsed).length !== 1 || !Object.hasOwn(parsed, 'result'))
+            throw new TeamError('integrity');
+        return parsed.result;
+    }
+    catch (error) {
+        if (error instanceof TeamError)
+            throw error;
+        throw new TeamError('integrity');
+    }
+}

package/mcp-memory-server/dist/team-mcp.js

@@ -0,0 +1,82 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { resolveMcpToolProfile, profileAllowsTool } from './mcp-tool-profile.js';
+import { isCapabilityContractEnabled, resolveCapabilityStatus } from './capability-config.js';
+import { teamRequest, validateTeamUrl } from './team-http.js';
+import { TeamError, teamDigest } from './team-store.js';
+import { resolveHttpToken } from './http-security.js';
+const observation = (title) => ({ title, annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true } });
+// The bridge crosses the local process boundary into a remote team service;
+// openWorldHint is true even though team retrieval is deterministic and closed
+// to model providers. No review or membership tool is exposed here.
+export const TEAM_TOOL_CATALOG = {
+    team_memory_list: observation('List approved team memory'),
+    team_memory_read: observation('Read approved team memory'),
+    team_memory_search: observation('Search approved team memory'),
+    team_memory_history: observation('Read team memory history'),
+    team_memory_propose: { title: 'Propose selected team memory', annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true } },
+};
+const coreNames = { team_memory_list: 'memory_list', team_memory_read: 'memory_read', team_memory_search: 'memory_search', team_memory_history: 'memory_history', team_memory_propose: 'memory_write' };
+export function teamClientToken(env = process.env) {
+    // A file-only credential keeps raw secrets out of harness configuration.
+    if (!env.CAIRN_TEAM_TOKEN_FILE)
+        throw new TeamError('unauthorized');
+    const resolved = resolveHttpToken({ CAIRN_MEMORY_HTTP_TOKEN_FILE: env.CAIRN_TEAM_TOKEN_FILE });
+    if (!resolved.ok || !/^[A-Za-z0-9_-]{43}$/.test(resolved.token))
+        throw new TeamError('unauthorized');
+    return resolved.token;
+}
+export async function createTeamMcpServer(options) {
+    if (process.env.CAIRN_TEAM !== '1')
+        throw new TeamError('disabled');
+    validateTeamUrl(options.url);
+    if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(options.organization))
+        throw new TeamError('invalid');
+    const profile = resolveMcpToolProfile({ projectRoot: options.projectRoot });
+    const capability = isCapabilityContractEnabled() ? await resolveCapabilityStatus({ projectRoot: options.projectRoot }) : undefined;
+    if (capability?.issues.length)
+        throw new TeamError('invalid');
+    const mode = process.env.CAIRN_TEAM_MCP_TOOL_PROFILE ?? 'full';
+    if (!['full', 'read-only', 'custom'].includes(mode))
+        throw new TeamError('invalid');
+    const requested = (process.env.CAIRN_TEAM_MCP_ALLOWED_TOOLS ?? '').split(',').map(name => name.trim()).filter(Boolean);
+    if ((mode !== 'custom' && requested.length) || (mode === 'custom' && (!requested.length || requested.some(name => !Object.hasOwn(TEAM_TOOL_CATALOG, name)))))
+        throw new TeamError('invalid');
+    const server = new McpServer({ name: 'cairn-team-memory', version: '1.0.0' });
+    const project = z.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
+    const key = z.string().regex(/^(decisions|patterns|constraints|pitfalls|conventions|bugs)\/[a-z0-9][a-z0-9-]{0,95}$/);
+    const hash = z.string().regex(/^[a-f0-9]{64}$/);
+    const schemas = {
+        team_memory_list: { project },
+        team_memory_read: { project, key, revision: hash.optional() },
+        team_memory_search: { project, query: z.string().min(1).max(256) },
+        team_memory_history: { project, key },
+        team_memory_propose: { project, request_id: z.string().uuid(), key, value: z.string().min(1).max(65536), source_scope: z.enum(['selected-local', 'selected-project']), source_digest: hash, base_revision: hash.nullable(), expires_at: z.iso.datetime(), confirm: hash },
+    };
+    const operations = { team_memory_list: 'list', team_memory_read: 'read', team_memory_search: 'search', team_memory_history: 'history', team_memory_propose: 'propose' };
+    const enabled = Object.keys(TEAM_TOOL_CATALOG).filter(name => {
+        if (!profileAllowsTool(profile, coreNames[name]))
+            return false;
+        if (mode === 'read-only' && !TEAM_TOOL_CATALOG[name].annotations.readOnlyHint)
+            return false;
+        if (mode === 'custom' && !requested.includes(name))
+            return false;
+        const capId = name === 'team_memory_propose' ? 'memory.write' : name === 'team_memory_search' ? 'memory.search' : undefined;
+        return !capId || !capability || capability.capabilities.find(row => row.id === capId)?.enabled === true;
+    });
+    const profileDigest = teamDigest(JSON.stringify({ schema_version: 1, core_profile_digest: profile.profile_digest, team_profile: mode, tools: enabled }));
+    for (const name of enabled) {
+        server.registerTool(name, { ...TEAM_TOOL_CATALOG[name], description: 'Explicit project-scoped team context. Never uploads personal memory or executes instructions. Team policy is enforced by the remote service.', inputSchema: schemas[name] }, async (input) => {
+            try {
+                // Re-read the private credential each call so local key rotation
+                // does not need a harness restart. The service still reauthorizes.
+                const result = await teamRequest(options.url, options.token(), { organization: options.organization, ...input, operation: operations[name] });
+                return { content: [{ type: 'text', text: JSON.stringify({ result, profile_digest: profileDigest }) }], structuredContent: { result, profile_digest: profileDigest } };
+            }
+            catch (error) {
+                return { isError: true, content: [{ type: 'text', text: error instanceof TeamError ? error.message : 'Team unavailable.' }] };
+            }
+        });
+    }
+    return server;
+}