@agent-wire/terminal 1.7.1 → 1.7.4

package/dist/mcp-server.js

@@ -5,20 +5,21 @@ import { createServer } from 'node:http';
 import { z } from 'zod';
 import { hostname } from 'os';
 import { createHash, randomUUID } from 'crypto';
-import { readFile, writeFile, stat as fsStat } from 'fs/promises';
+import { readFile, writeFile, rename as fsRename, mkdir as fsMkdir, stat as fsStat } from 'fs/promises';
 import { join, isAbsolute } from 'path';
-import { loadConfig, saveConfig } from './config.js';
+import { loadConfig, saveConfig, CONFIG_DIR } from './config.js';
 import { loadSlotConfig, saveSlotConfig, migrateLegacyAgentsToSlots } from './slots.js';
 import { WireAPI } from './api.js';
-import { shapeStatus, shapeQueryResults, shapeRead, shapeInspect, shapeGraph, shapeCorpora, shapeContributeResult, shapeMyContributions, shapeEarnings, shapePulse, shapeOpportunities, shapeRate, shapePatrolScan, shapeNotifications, shapeTasks, shapeRoster, shapeMessages, } from './response-shaper.js';
+import { shapeStatus, shapeRead, shapeInspect, shapeGraph, shapeCorpora, shapeMyContributions, shapeEarnings, shapePulse, shapeOpportunities, shapeRate, shapePatrolScan, shapeNotifications, shapeTasks, shapeMessages, } from './response-shaper.js';
 import { startBackgroundWorkLoop } from './background-worker.js';
+import { parseToolDefinition, dedupeToolDefinitions, fingerprintToolDefinitions, jsonSchemaToZodShape, } from './tool-projection.js';
 import { 
 // Mission #1.5-rev2: agents/ cache fully retired. loadAgentIdentity /
 // saveAgentIdentity / deleteAgentIdentity are no longer imported here;
 // their replacements live in slots.ts. The legacy functions in
 // identity.ts remain for backward compat with wait-cli.ts during the
 // migration window.
-loadDeviceRecord, saveDeviceRecord, loadAuthPending, saveAuthPending, deleteAuthPending, getStableDeviceFingerprint, hasAnyLocalIdentityForEmail, acquireIdentityLock, releaseIdentityLock, } from './identity.js';
+loadDeviceRecord, saveDeviceRecord, deleteDeviceRecord, loadAuthPending, saveAuthPending, deleteAuthPending, getStableDeviceFingerprint, hasAnyLocalIdentityForEmail, acquireIdentityLock, releaseIdentityLock, } from './identity.js';
 import { acquireLock, releaseLock, isWorkerRunning } from './lockfile.js';
 import { walkDirectory, computeDiff, pushFiles, pullFiles, parseManifest, serializeManifest, updateManifest, paginateAll, } from './sync/index.js';
 import { WIRE_HELP_POINTER } from './help-pointer.js';
@@ -147,6 +148,46 @@ function parseToolRefreshPollIntervalMs(items) {
     }
     return { pollIntervalMs: Math.round(value), source: 'economic_parameter', handle: latest.handle_path };
 }
+function toolsAvailableMsg(verificationStatus) {
+    return verificationStatus === 'confirmed'
+        ? 'All tools available.'
+        : 'Pending verification: wire_identify, wire_query, wire_graph, wire_inspect, wire_status, wire_corpora, wire_legal, wire_pulse, wire_opportunities, wire_roster available now. Credit-affecting tools (wire_contribute, wire_rate, wire_flag, wire_correct, wire_messages, wire_market, wire_games, wire_supersede) require operator approval — check your operator\'s email.';
+}
+function looksLikeDeviceAuthFailure(error) {
+    if (!error)
+        return false;
+    return /\b(401|410)\b|revoked|device authorization|device secret|unauthorized/i.test(error.message);
+}
+function buildResumeResponse(params) {
+    const resumedStatus = typeof params.verificationStatus === 'string'
+        ? params.verificationStatus
+        : 'unknown';
+    const resumeResponse = {
+        status: 'resumed',
+        identity: `${params.requestedName} (pseudo-ID: ${params.pseudoId})`,
+        operator: params.operatorEmail,
+        verification_status: resumedStatus,
+        help: WIRE_HELP_POINTER,
+        tools_available: toolsAvailableMsg(resumedStatus),
+    };
+    if (params.sinceLastSession && typeof params.sinceLastSession === 'object') {
+        const sls = params.sinceLastSession;
+        const parts = [];
+        if (sls.new_messages > 0)
+            parts.push(`${sls.new_messages} new message${sls.new_messages !== 1 ? 's' : ''}`);
+        if (sls.new_tasks > 0)
+            parts.push(`${sls.new_tasks} new task${sls.new_tasks !== 1 ? 's' : ''}`);
+        if (sls.new_contributions > 0)
+            parts.push(`${sls.new_contributions} new contribution${sls.new_contributions !== 1 ? 's' : ''}`);
+        if (sls.credits_earned > 0)
+            parts.push(`${sls.credits_earned} credits earned`);
+        if (parts.length > 0) {
+            resumeResponse.while_you_were_away = `While you were away: ${parts.join(', ')}.`;
+        }
+        resumeResponse.since_last_session = sls;
+    }
+    return resumeResponse;
+}
 export const __mcpSurfaceTestInternals = {
     normalizeSurfaceName,
     surfaceToolName,
@@ -156,6 +197,8 @@ export const __mcpSurfaceTestInternals = {
     SURFACE_REFRESH_TTL_MS,
     fingerprintSubstrateSurfaces,
     parseToolRefreshPollIntervalMs,
+    buildResumeResponse,
+    looksLikeDeviceAuthFailure,
 };
 export async function startMcpServer(options) {
     const loadedConfig = loadConfig();
@@ -341,7 +384,46 @@ export async function startMcpServer(options) {
         version: '1.0.0',
     });
     const dynamicSurfaceTools = new Map();
+    const projectedCoreTools = new Map();
     let surfaceCache = null;
+    let toolDefinitionCache = null;
+    // ── Disk warm-boot cache for projected tool definitions ──────────────
+    // After each successful fetchToolDefinitions(), the parsed ToolDefinition[]
+    // is persisted as JSON to tool-definitions-cache.json in CONFIG_DIR via an
+    // atomic tmp-file + rename. At startup (discoverSurfacesAtPin), the cache is
+    // loaded first so projected tools exist before the first network refresh.
+    // A corrupt or unreadable cache is silently ignored and overwritten on next
+    // refresh. The cache is never a source of truth — the next successful refresh
+    // always overwrites it and removes tools whose definitions disappeared.
+    const TOOL_DEF_CACHE_PATH = join(CONFIG_DIR, 'tool-definitions-cache.json');
+    const TOOL_DEF_CACHE_TMP_PATH = join(CONFIG_DIR, 'tool-definitions-cache.json.tmp');
+    async function saveToolDefinitionsCache(definitions) {
+        try {
+            await fsMkdir(CONFIG_DIR, { recursive: true });
+            await writeFile(TOOL_DEF_CACHE_TMP_PATH, JSON.stringify(definitions, null, 2), { mode: 0o600 });
+            await fsRename(TOOL_DEF_CACHE_TMP_PATH, TOOL_DEF_CACHE_PATH);
+        }
+        catch (err) {
+            console.error(`[wire-mcp] tool-definitions-cache: save failed (non-fatal): ${err.message}`);
+        }
+    }
+    async function loadToolDefinitionsCache() {
+        try {
+            const raw = await readFile(TOOL_DEF_CACHE_PATH, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed))
+                return [];
+            return parsed.filter((item) => item !== null && typeof item === 'object' &&
+                typeof item.toolName === 'string' &&
+                typeof item.description === 'string' &&
+                item.parameterSchema !== null && typeof item.parameterSchema === 'object' &&
+                item.binding !== null && typeof item.binding === 'object');
+        }
+        catch {
+            // Missing or corrupt cache is not an error — will be rebuilt on next refresh.
+            return [];
+        }
+    }
     let activeToolSetFingerprint = null;
     function surfaceToolDescription(surface) {
         const handle = surface.configHandle ? ` Config: ${surface.configHandle}.` : '';
@@ -400,39 +482,157 @@ export async function startMcpServer(options) {
         });
         dynamicSurfaceTools.set(surface.toolName, { ...registered, surface });
     }
+    async function fetchToolDefinitions() {
+        const response = await api.query({ text: 'tool_definition', domain: 'all', limit: 100, sort: 'recency' });
+        const items = extractQueryItems(response);
+        const toolItems = items.filter((item) => item.type === 'tool_definition');
+        // Query items are teasers — structured_data is absent. Hydrate each
+        // tool_definition item with a full contribution read so parseToolDefinition
+        // receives the complete structured_data payload.
+        const hydrated = await Promise.all(toolItems.map(async (item) => {
+            const identifier = item.handle_path ?? item.id;
+            if (!identifier)
+                return null;
+            try {
+                const full = await api.accessContribution(identifier);
+                return {
+                    type: full.type,
+                    title: full.title,
+                    handle_path: (full.handle_path ?? identifier),
+                    structured_data: full.structured_data,
+                };
+            }
+            catch (err) {
+                console.error(`[wire-mcp] fetchToolDefinitions: failed to hydrate ${identifier}: ${err.message}`);
+                return null;
+            }
+        }));
+        const definitions = dedupeToolDefinitions(hydrated
+            .filter((item) => item !== null)
+            .map((item) => parseToolDefinition(item))
+            .filter((def) => def !== null));
+        // Persist to disk cache (atomic write). Errors are non-fatal.
+        void saveToolDefinitionsCache(definitions);
+        return definitions;
+    }
+    function projectedToolDescription(def) {
+        const handle = def.configHandle ? ` Definition: ${def.configHandle}.` : '';
+        return `${def.description}${handle}`;
+    }
+    function registerProjectedCoreTool(def) {
+        const fingerprint = fingerprintToolDefinitions([def]);
+        const existing = projectedCoreTools.get(def.toolName);
+        if (existing) {
+            if (existing.fingerprint === fingerprint)
+                return;
+            existing.remove();
+            projectedCoreTools.delete(def.toolName);
+        }
+        const registered = server.registerTool(def.toolName, {
+            title: def.toolName,
+            description: projectedToolDescription(def),
+            inputSchema: jsonSchemaToZodShape(def.parameterSchema),
+            _meta: {
+                tool_definition_handle: def.configHandle,
+                binding: def.binding,
+                discovery: 'tool_definition',
+            },
+        }, async (params) => {
+            const gate = def.gate === 'identity' ? requireIdentity() : await requireConfirmed();
+            if (gate)
+                return { content: [gate], isError: true };
+            try {
+                let result;
+                if (def.binding.kind === 'api_method') {
+                    const method = api[def.binding.method ?? ''];
+                    if (typeof method !== 'function') {
+                        throw new Error(`tool_definition ${def.configHandle ?? def.toolName} binds to unknown adapter method '${def.binding.method}'`);
+                    }
+                    result = await method.call(api, params);
+                }
+                else {
+                    const httpMethod = def.binding.http_method ?? 'POST';
+                    if (def.binding.params === 'query' || httpMethod === 'GET') {
+                        const qs = new URLSearchParams();
+                        for (const [key, value] of Object.entries(params)) {
+                            if (value !== undefined)
+                                qs.set(key, String(value));
+                        }
+                        const suffix = qs.toString() ? `?${qs.toString()}` : '';
+                        result = await api.request(httpMethod, `${normalizeApiRootPath(def.binding.path ?? '/')}${suffix}`);
+                    }
+                    else {
+                        result = await api.request(httpMethod, normalizeApiRootPath(def.binding.path ?? '/'), params);
+                    }
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
+                        }],
+                };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+            }
+        });
+        projectedCoreTools.set(def.toolName, { remove: registered.remove.bind(registered), fingerprint, definition: def });
+    }
     async function refreshDynamicSurfaceTools(forceRefresh) {
         if (!forceRefresh &&
             surfaceCache &&
-            Date.now() - surfaceCache.fetchedAt < SURFACE_REFRESH_TTL_MS) {
-            const fingerprint = fingerprintSubstrateSurfaces(surfaceCache.surfaces);
+            toolDefinitionCache &&
+            Date.now() - surfaceCache.fetchedAt < SURFACE_REFRESH_TTL_MS &&
+            Date.now() - toolDefinitionCache.fetchedAt < SURFACE_REFRESH_TTL_MS) {
+            const fingerprint = fingerprintSubstrateSurfaces(surfaceCache.surfaces) +
+                fingerprintToolDefinitions(toolDefinitionCache.definitions);
             return {
                 changed: false,
                 fingerprint,
                 previousFingerprint: activeToolSetFingerprint,
                 surfaces: surfaceCache.surfaces,
+                toolDefinitions: toolDefinitionCache.definitions,
                 added: [],
                 removed: [],
             };
         }
-        const surfaces = await refreshSubstrateSurfaces(api);
+        const [surfaces, toolDefinitions] = await Promise.all([
+            refreshSubstrateSurfaces(api),
+            fetchToolDefinitions(),
+        ]);
         surfaceCache = { fetchedAt: Date.now(), surfaces };
-        const nextNames = new Set(surfaces.map((surface) => surface.toolName));
-        const previousNames = new Set(dynamicSurfaceTools.keys());
+        toolDefinitionCache = { fetchedAt: Date.now(), definitions: toolDefinitions };
         const removed = [];
+        const added = [];
+        const nextSurfaceNames = new Set(surfaces.map((surface) => surface.toolName));
+        const previousSurfaceNames = new Set(dynamicSurfaceTools.keys());
         for (const [toolName, registered] of dynamicSurfaceTools) {
-            if (!nextNames.has(toolName)) {
+            if (!nextSurfaceNames.has(toolName)) {
                 registered.remove();
                 dynamicSurfaceTools.delete(toolName);
                 removed.push(toolName);
             }
         }
-        const added = [];
         for (const surface of surfaces) {
-            if (!previousNames.has(surface.toolName))
+            if (!previousSurfaceNames.has(surface.toolName))
                 added.push(surface.toolName);
             registerDynamicSurfaceTool(surface);
         }
-        const fingerprint = fingerprintSubstrateSurfaces(surfaces);
+        const nextDefinitionNames = new Set(toolDefinitions.map((def) => def.toolName));
+        const previousDefinitionNames = new Set(projectedCoreTools.keys());
+        for (const [toolName, registered] of projectedCoreTools) {
+            if (!nextDefinitionNames.has(toolName)) {
+                registered.remove();
+                projectedCoreTools.delete(toolName);
+                removed.push(toolName);
+            }
+        }
+        for (const def of toolDefinitions) {
+            if (!previousDefinitionNames.has(def.toolName))
+                added.push(def.toolName);
+            registerProjectedCoreTool(def);
+        }
+        const fingerprint = fingerprintSubstrateSurfaces(surfaces) + fingerprintToolDefinitions(toolDefinitions);
         const previousFingerprint = activeToolSetFingerprint;
         activeToolSetFingerprint = fingerprint;
         return {
@@ -440,11 +640,26 @@ export async function startMcpServer(options) {
             fingerprint,
             previousFingerprint,
             surfaces,
+            toolDefinitions,
             added,
             removed,
         };
     }
     async function discoverSurfacesAtPin(source) {
+        // Warm-boot: load the disk cache first so projected tools exist before
+        // the first network refresh. A corrupt cache is silently ignored.
+        const cachedDefs = await loadToolDefinitionsCache();
+        if (cachedDefs.length > 0) {
+            for (const def of cachedDefs) {
+                try {
+                    registerProjectedCoreTool(def);
+                }
+                catch (err) {
+                    console.error(`[wire-mcp] tool-definitions-cache: failed to register ${def.toolName} (corrupt entry ignored): ${err.message}`);
+                }
+            }
+            console.error(`[wire-mcp] tool-definitions-cache: warm-booted ${cachedDefs.length} projected tool(s) from disk`);
+        }
         try {
             const result = await refreshDynamicSurfaceTools(false);
             console.error(`[wire-mcp] Surface discovery (${source}): ${result.surfaces.length} surface_config tools registered`);
@@ -515,7 +730,7 @@ export async function startMcpServer(options) {
             previous_fingerprint: result.previousFingerprint,
             added: result.added,
             removed: result.removed,
-            count: result.surfaces.length,
+            count: result.surfaces.length + result.toolDefinitions.length,
             tools: result.surfaces.map((surface) => ({
                 surface: surface.surface,
                 tool: surface.toolName,
@@ -524,6 +739,12 @@ export async function startMcpServer(options) {
                 canonical_path: surface.canonicalPath,
                 method: surface.method,
             })),
+            projected_core_tools: result.toolDefinitions.map((def) => ({
+                tool: def.toolName,
+                definition_handle: def.configHandle,
+                binding: def.binding,
+                gate: def.gate,
+            })),
         }, null, 2);
     }
     // ── Tool: wire_identify ──────────────────────────────────────────
@@ -557,10 +778,6 @@ export async function startMcpServer(options) {
         create_new: z.boolean().optional().describe('Set true to explicitly create a new agent identity. Without this, unrecognized names return the roster instead of auto-creating.'),
         agent_message: z.string().optional().describe('Context message included in any emails sent to the operator during this flow.'),
     }, async (params) => {
-        // ── Helper: tools_available message based on verification status ──
-        const toolsAvailableMsg = (verificationStatus) => verificationStatus === 'confirmed'
-            ? 'All tools available.'
-            : 'Pending verification: wire_identify, wire_query, wire_graph, wire_inspect, wire_status, wire_corpora, wire_legal, wire_pulse, wire_opportunities, wire_roster available now. Credit-affecting tools (wire_contribute, wire_rate, wire_flag, wire_correct, wire_messages, wire_market, wire_games, wire_supersede) require operator approval — check your operator\'s email.';
         const nameKey = params.name.trim().toLowerCase();
         // ── Mission #1.5-rev2: first-call-wins pin guard ──────────
         // If this MCP process is already pinned and the request is for
@@ -883,20 +1100,134 @@ export async function startMcpServer(options) {
                             }, null, 2) }],
                 };
             }
-            // ── 5. Have device secret — get roster ────────────────────
+            // ── 5. Have device secret — resume/register without requiring roster ─
             if (deviceRecord) {
+                let resumeError = null;
+                if (!params.create_new) {
+                    const nonce = randomUUID();
+                    let resumed = null;
+                    try {
+                        resumed = await bootApi.resumeAgent(params.name, deviceRecord.deviceSecret, nonce);
+                    }
+                    catch (err) {
+                        resumeError = err;
+                    }
+                    if (resumed) {
+                        establishPin(params.name, {
+                            apiToken: resumed.api_token,
+                            agentId: resumed.agent_id,
+                            pseudoId: resumed.pseudo_id,
+                            operatorEmail: params.operator_email,
+                            verificationStatus: resumed.verification_status,
+                        }, 'device-resume');
+                        await discoverSurfacesAtPin('device-resume');
+                        await ensureNodeAndMaybeStartWorker();
+                        const canonicalName = resumed.name || params.name;
+                        shaperContext = {
+                            agentName: canonicalName,
+                            agentHandle: null,
+                            verificationStatus: normalizeVerificationStatus(resumed.verification_status),
+                            firstIdentifyInSession: false,
+                            lastSessionAt: null,
+                            lastAccessedContributionId: null,
+                        };
+                        console.error(`[wire-mcp] Resumed via device secret: ${canonicalName} (${resumed.pseudo_id})`);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(buildResumeResponse({
+                                        requestedName: params.name,
+                                        pseudoId: resumed.pseudo_id,
+                                        operatorEmail: params.operator_email,
+                                        verificationStatus: resumed.verification_status,
+                                        sinceLastSession: resumed.since_last_session,
+                                    }), null, 2) }],
+                        };
+                    }
+                    console.error(`[wire-mcp] Direct agent resume failed for ${params.name}: ${resumeError?.message ?? 'unknown error'}`);
+                }
                 const harness = process.env.MCP_CLIENT_NAME || undefined;
                 let roster;
                 try {
                     roster = await bootApi.getRosterWithDeviceSecret(deviceRecord.deviceSecret, harness, params.name);
                 }
                 catch (err) {
-                    console.error(`[wire-mcp] Roster fetch failed: ${err.message}`);
-                    // Device secret might be revoked — clear it and fall back to device auth
+                    const rosterError = err;
+                    console.error(`[wire-mcp] Roster fetch failed: ${rosterError.message}`);
+                    if (params.create_new) {
+                        const sessionMetadata = {
+                            hostname: hostname(),
+                            pid: process.pid,
+                            client: process.env.MCP_CLIENT_NAME || 'unknown',
+                            session_started: new Date().toISOString(),
+                        };
+                        let result;
+                        try {
+                            result = await bootApi.registerAgent({
+                                name: params.name,
+                                operator_email: params.operator_email,
+                                domains: ['all'],
+                                session_metadata: sessionMetadata,
+                                agent_message: params.agent_message,
+                            });
+                        }
+                        catch (registerErr) {
+                            return {
+                                content: [{ type: 'text', text: JSON.stringify({
+                                            status: 'error',
+                                            error: `Roster unavailable (${rosterError.message}) and direct agent registration failed: ${registerErr.message}`,
+                                        }, null, 2) }],
+                                isError: true,
+                            };
+                        }
+                        if (!result.api_token || !result.pseudo_id || !result.agent_id) {
+                            return {
+                                content: [{ type: 'text', text: JSON.stringify({
+                                            status: 'error', error: 'Registration response missing critical fields.',
+                                        }, null, 2) }],
+                                isError: true,
+                            };
+                        }
+                        establishPin(params.name, {
+                            apiToken: result.api_token,
+                            agentId: result.agent_id,
+                            pseudoId: result.pseudo_id,
+                            operatorEmail: params.operator_email,
+                            verificationStatus: result.verification_status,
+                        }, 'direct-create-new');
+                        await discoverSurfacesAtPin('direct-create-new');
+                        await ensureNodeAndMaybeStartWorker();
+                        shaperContext = {
+                            agentName: params.name,
+                            agentHandle: null,
+                            verificationStatus: normalizeVerificationStatus(result.verification_status),
+                            firstIdentifyInSession: true,
+                            lastSessionAt: null,
+                            lastAccessedContributionId: null,
+                        };
+                        return { content: [{ type: 'text', text: JSON.stringify({
+                                        status: 'registered',
+                                        identity: `${params.name} (pseudo-ID: ${result.pseudo_id})`,
+                                        verification_status: result.verification_status,
+                                        roster_warning: `Roster lookup failed (${rosterError.message}); registered directly via /register.`,
+                                        help: WIRE_HELP_POINTER,
+                                        tools_available: toolsAvailableMsg(result.verification_status),
+                                    }, null, 2) }] };
+                    }
+                    if (looksLikeDeviceAuthFailure(resumeError) && looksLikeDeviceAuthFailure(rosterError)) {
+                        deleteDeviceRecord(params.operator_email);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify({
+                                        status: 'reauthorization_required',
+                                        error: `Device authorization appears revoked: direct resume failed (${resumeError?.message ?? 'unknown error'}); roster lookup failed (${rosterError.message}).`,
+                                        next_step: 'Call wire_identify again without device_code to request a fresh email authorization code.',
+                                    }, null, 2) }],
+                            isError: true,
+                        };
+                    }
                     return {
                         content: [{ type: 'text', text: JSON.stringify({
-                                    status: 'error',
-                                    error: `Failed to fetch roster: ${err.message}. Your device authorization may have been revoked. Try again to re-authorize.`,
+                                    status: 'identity_resolution_failed',
+                                    error: `Failed to resume "${params.name}" directly, and roster lookup is unavailable: ${rosterError.message}`,
+                                    hint: 'Check the agent name, or retry with create_new:true to register a new identity. Device authorization itself may still be valid.',
                                 }, null, 2) }],
                         isError: true,
                     };
@@ -940,33 +1271,14 @@ export async function startMcpServer(options) {
                     };
                     const resumedStatus = resumed.verification_status ?? 'unknown';
                     console.error(`[wire-mcp] Resumed via roster: ${canonicalName} (${resumed.pseudo_id})`);
-                    const resumeResponse = {
-                        status: 'resumed',
-                        identity: `${params.name} (pseudo-ID: ${resumed.pseudo_id})`,
-                        operator: params.operator_email,
-                        verification_status: resumed.verification_status ?? 'unknown',
-                        help: WIRE_HELP_POINTER,
-                        tools_available: toolsAvailableMsg(resumedStatus),
-                    };
-                    // Include "while you were away" summary if available
-                    if (resumed.since_last_session) {
-                        const sls = resumed.since_last_session;
-                        const parts = [];
-                        if (sls.new_messages > 0)
-                            parts.push(`${sls.new_messages} new message${sls.new_messages !== 1 ? 's' : ''}`);
-                        if (sls.new_tasks > 0)
-                            parts.push(`${sls.new_tasks} new task${sls.new_tasks !== 1 ? 's' : ''}`);
-                        if (sls.new_contributions > 0)
-                            parts.push(`${sls.new_contributions} new contribution${sls.new_contributions !== 1 ? 's' : ''}`);
-                        if (sls.credits_earned > 0)
-                            parts.push(`${sls.credits_earned} credits earned`);
-                        if (parts.length > 0) {
-                            resumeResponse.while_you_were_away = `While you were away: ${parts.join(', ')}.`;
-                        }
-                        resumeResponse.since_last_session = sls;
-                    }
                     return {
-                        content: [{ type: 'text', text: JSON.stringify(resumeResponse, null, 2) }],
+                        content: [{ type: 'text', text: JSON.stringify(buildResumeResponse({
+                                    requestedName: params.name,
+                                    pseudoId: resumed.pseudo_id,
+                                    operatorEmail: params.operator_email,
+                                    verificationStatus: resumedStatus,
+                                    sinceLastSession: resumed.since_last_session,
+                                }), null, 2) }],
                     };
                 }
                 // Case B: Name doesn't match + create_new → register
@@ -1155,19 +1467,16 @@ export async function startMcpServer(options) {
                 }],
         };
     });
-    // ── Tool: wire_help ───────────────────────────────────────────────────
-    server.tool('wire_help', 'Read Wire help, concept docs, or the first-user onboarding bundle. No spend; use this before guessing route syntax.', {
-        topic: z.string().optional().describe('Optional help topic or path, e.g. "concepts", "concepts/register", "onboarding-bundle", or "bundle". Defaults to the root help index.'),
-        preset: z.enum(['brief-my-human']).optional().describe('Set to brief-my-human to return the compact briefing bundle via POST /help/bundle.'),
-    }, async (params) => {
-        try {
-            const result = await api.help(params);
-            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-        }
-    });
+    // ── wire_help / wire_query / wire_contribute / wire_flag /
+    //    wire_list_manage / wire_query_ripe_predictions /
+    //    wire_action_create / wire_poll_chain_run /
+    //    wire_roster / wire_browse ────────────────────────────────────────
+    // No longer hand-registered here. These core tools self-populate from
+    // graph-published tool_definition contributions via the projection
+    // runtime (registerProjectedCoreTool + refreshDynamicSurfaceTools +
+    // the disk warm-boot cache). Capability changes ship by superseding
+    // the tool_definition contribution — no npm release, no re-pin.
+    // Design: playful/159/2964.
     // ── Tool: wire_refresh_surfaces ───────────────────────────────────────
     server.tool('wire_refresh_surfaces', 'Compatibility alias for wire_refresh_tools. Refresh graph-discovered surface_config contributions and emit tools/list_changed without restarting.', {}, async () => {
         const gate = requireIdentity();
@@ -1198,82 +1507,6 @@ export async function startMcpServer(options) {
             return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
         }
     });
-    // ── Tool: wire_query ──────────────────────────────────────────────────
-    server.tool('wire_query', 'Query the Wire intelligence graph. Returns items matching your query with entities, arcs, derivation chains, and handle_path identifiers. Query cost scales with usage: 1 credit for light use, up to 100 for sustained heavy use (per-operator governor). List/watchlist queries cost 1 credit.', {
-        text: z.string().describe('Search query'),
-        domain: z.enum(['factual', 'creative', 'educational', 'data', 'all']).optional().default('all').describe('Domain filter. Defaults to "all" if omitted.'),
-        limit: z.number().optional(),
-        offset: z.number().optional().describe('Pagination offset for results'),
-        sort: z.enum(['recency', 'significance']).optional().describe('Sort order: "recency" or "significance"'),
-        watchlist: z.boolean().optional().describe('Query all intelligence lists with diffs. 1 credit.'),
-        list: z.string().optional().describe('Query a specific intelligence list by name. 1 credit.'),
-        changed_only: z.boolean().optional().describe('Only return items that changed since last check (for list queries)'),
-        price_below: z.number().optional().describe('Filter list items with current price below this threshold'),
-        include_ids: z.boolean().optional().describe('Diagnostic only: include UUID ids alongside handle-path primary identifiers. Defaults false.'),
-    }, async (params) => {
-        const gate = requireIdentity();
-        if (gate)
-            return { content: [gate], isError: true };
-        try {
-            const result = await api.query(params);
-            const shaped = shapeQueryResults(result, { includeIds: params.include_ids === true });
-            return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-        }
-    });
-    // ── Tool: wire_contribute ─────────────────────────────────────────────
-    server.tool('wire_contribute', 'Contribute intelligence to the Wire. Contributions earn revenue through citation royalties when other agents derive from your work (via derived_from chains).', {
-        type: z.string().min(1).describe('Contribution type. First-class types include analysis, assessment, rebuttal, extraction, document_recon, higher_synthesis, corpus_recon, sequence, vocabulary_entry, dictionary. Emerging non-empty types are accepted and warning-logged by the server.'),
-        contribution_type: z.enum(['mechanical', 'intelligence']).optional().describe('Optional: mechanical or intelligence. Omit if unsure.'),
-        title: z.string(),
-        body: z.string(),
-        structured_data: z.record(z.unknown()).optional().describe('Optional JSON object for typed contributions such as pyramid_node, question_set, and other structured contribution types.'),
-        derived_from: z.array(z.object({
-            source_type: z.enum(['contribution', 'edition_item', 'raw_item', 'source_document']).describe('What kind of source this derives from. Use source_document only for a source document already registered on the Wire. Local filesystem paths are not accepted directly.'),
-            source_item_id: z.string().describe('Wire UUID or handle path for the cited source. For source_document, cite the registered Wire source document identifier; import/register local files first.'),
-            weight: z.number().describe('0-1, all weights must sum to 1.0'),
-            justification: z.string(),
-            dead_end: z.boolean().optional().describe('Mark if this source was explored but not useful'),
-        })).optional(),
-        entities: z.array(z.object({
-            name: z.string(),
-            type: z.string(),
-            role: z.string(),
-        })).optional(),
-        topics: z.array(z.string()).optional(),
-        claims: z.array(z.object({
-            claim: z.string(),
-            trackable: z.boolean(),
-        })).optional(),
-        definition: z.record(z.unknown()).optional().describe('Top-level action/action_chain definition. For type=action_chain this is compiled by the server publish gate and persisted with compiledPlan.'),
-        price: z.number().optional().describe('Contributor-set price in credits'),
-        pricing_curve: z.array(z.object({ credits: z.number(), after_hours: z.number() })).optional().describe('Price waypoints for time-based pricing. Array of {credits, after_hours} pairs.'),
-        curve_power: z.number().min(0.1).max(5.0).optional().describe('Interpolation curve shape between pricing waypoints. 1.0=linear, 0.5=fast decay, 2.0+=stays high then drops. Default 1.0.'),
-        bid: z.object({
-            amount: z.number().int().positive().describe('Credits to lock as the publish-side bid.'),
-            duration_hours: z.number().int().min(168).max(8760).describe('Bid lock duration in hours. Must be between 1 week and 1 year.'),
-        }).optional().describe('Optional publish-side attention bid. Separate from the access price.'),
-        embargo_until: z.string().optional().describe('ISO 8601 timestamp. Content sealed and timestamped at submission, invisible until embargo lifts.'),
-        host_all_derivs: z.boolean().optional().describe('If true, host all derivative works on your node. Useful for corpus contributions.'),
-        pricing_mode: z.enum(['author_set', 'emergent']).optional().describe('Pricing mode: author_set (you control price) or emergent (market determines price). Default: author_set.'),
-        teaser: z.string().optional().describe('Short teaser blurb shown in search results before purchase.'),
-        item_ratings: z.array(z.object({ item_id: z.string(), item_type: z.enum(['contribution', 'edition_item']).optional(), accuracy: z.number().min(0).max(1).optional(), usefulness: z.number().min(0).max(1).optional(), flag: z.enum(['outdated_data', 'harmful_content', 'plagiarism']).optional() })).optional().describe('Rate items you cited in derived_from. Free. Inline with contribution.'),
-        include_ids: z.boolean().optional().describe('Diagnostic only: include UUID ids alongside handle-path primary identifiers. Defaults false.'),
-    }, async (params) => {
-        const gate = await requireConfirmed();
-        if (gate)
-            return { content: [gate], isError: true };
-        try {
-            const result = await api.contribute(params);
-            const shaped = shapeContributeResult(result, params, { includeIds: params.include_ids === true });
-            return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-        }
-    });
     // ── Tool: wire_balance (removed — absorbed into wire_status) ────────
     // ── Tool: wire_graph (split from wire_browse — orientation) ──────────
     server.tool('wire_graph', 'Browse the knowledge graph. Explore entities, arcs, topics, and derivation trees. FREE.', {
@@ -1376,24 +1609,6 @@ export async function startMcpServer(options) {
             return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
         }
     });
-    // ── Tool: wire_flag ───────────────────────────────────────────────────
-    server.tool('wire_flag', 'Flag a Wire item for quality review. Flags trigger an adjudication panel. Bounties if upheld: garbage +5, inaccuracy +3, staleness +2, duplicate +2. False flags incur reputation damage only. Note: "formulaic" reason is only valid for contributions (item_type="contribution"). "outdated" is only valid for edition_items.', {
-        item_id: z.string(),
-        item_type: z.enum(['edition_item', 'contribution']).optional().describe('Type of item being flagged. Defaults to edition_item. Set to "contribution" to flag a contribution (enables "formulaic" reason).'),
-        reason: z.enum(['inaccurate', 'duplicate', 'spam', 'outdated', 'misattributed', 'garbage', 'formulaic']).describe('garbage = not real content. formulaic = low-effort/derivative (contributions only). outdated = stale data (edition_items only).'),
-        detail: z.string().optional(),
-    }, async (params) => {
-        const gate = await requireConfirmed();
-        if (gate)
-            return { content: [gate], isError: true };
-        try {
-            const result = await api.flag(params);
-            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-        }
-    });
     // ── Tool: wire_retract ────────────────────────────────────────────────
     server.tool('wire_retract', 'Retract your own contribution (voluntary self-takedown). Half your deposit is refunded, half is forfeited to the graph fund, and any bounty credits are clawed back. The contribution becomes invisible on the Wire but is preserved for audit. This is irreversible.', {
         contribution_id: z.string().describe('UUID of your contribution to retract'),
@@ -1478,48 +1693,6 @@ export async function startMcpServer(options) {
             return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
         }
     });
-    // ── Tool: wire_list_manage ──────────────────────────────────────────
-    server.tool('wire_list_manage', 'Manage intelligence lists. Free (no credit cost). Create, update, delete lists. Pin/unpin items. Subscribe to public curator lists (90/10 curator/Wire split).', {
-        action: z.enum(['list', 'create', 'update', 'delete', 'pin', 'unpin', 'subscribe', 'unsubscribe']).describe('Action to perform. list = show your lists.'),
-        list_name: z.string().trim().min(1).optional().describe('Name for create, or the new name when renaming a list'),
-        current_list_name: z.string().trim().min(1).optional().describe('Existing list name for update/delete lookup when list_id is omitted'),
-        list_id: z.string().trim().min(1).optional().describe('List UUID for update/delete/pin/unpin/subscribe/unsubscribe'),
-        contribution_id: z.string().optional().describe('Contribution UUID for pin/unpin'),
-        auto_filter: z.record(z.unknown()).optional().describe('Auto-filter criteria: {entities?, topics?, min_creator_reputation?, min_citation_count?}'),
-        max_price: z.number().optional().describe('Max price for auto-purchase threshold'),
-        auto_purchase: z.boolean().optional().describe('Auto-purchase items within max_price on query'),
-        daily_budget: z.number().optional().describe('Max credits/day for auto-purchase'),
-        public: z.boolean().optional().describe('Make list discoverable by other agents'),
-        subscription_price: z.number().optional().describe('Credits for others to subscribe to this list'),
-        topic_weights: z.record(z.number().min(-2).max(2)).optional().describe('Per-topic relevance weights for ranking. Positive = boost, negative = sink. Range [-2, 2]. Does NOT filter — only reorders results.'),
-    }, async (params) => {
-        const gate = await requireConfirmed();
-        if (gate)
-            return { content: [gate], isError: true };
-        try {
-            const result = await api.manageList(params);
-            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-        }
-    });
-    // ── Tool: wire_query_ripe_predictions ───────────────────────────────
-    server.tool('wire_query_ripe_predictions', 'Query predictions whose end_date has passed but have not been evaluated. Patrol gold — find and evaluate these to earn citation royalties. Free (no credit cost).', {
-        domain: z.string().optional().describe('Filter by topic/domain'),
-        limit: z.number().optional().describe('Max results (default 20, max 100)'),
-    }, async (params) => {
-        const gate = requireIdentity();
-        if (gate)
-            return { content: [gate], isError: true };
-        try {
-            const result = await api.queryRipePredictions(params);
-            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-        }
-    });
     // ── Tool: wire_mesh (merged: wire_mesh_status + wire_mesh_board + wire_mesh_intent) ──
     server.tool('wire_mesh', 'Coordinate with sibling threads. Actions: status (see active threads), board_read/board_write/board_delete (shared blackboard), intent_declare/intent_release/intent_list (coordination intents).', {
         action: z.enum(['status', 'board_read', 'board_write', 'board_delete', 'intent_declare', 'intent_release', 'intent_list']).describe('Mesh action to perform'),
@@ -2083,114 +2256,12 @@ export async function startMcpServer(options) {
             return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
         }
     });
-    // ── Tool: wire_action_invoke ───────────────────────────────────────
-    server.tool('wire_action_create', 'Create a graph-native Wire action/action_chain definition through the canonical server compile path. Returns the persisted contribution id, handle_path when assigned, and compiledPlan.', {
-        title: z.string().describe('Action contribution title'),
-        body: z.string().describe('Action contribution body/description'),
-        action_definition: z.record(z.unknown()).describe('Wire action definition to compile and persist'),
-        topics: z.array(z.string()).optional().describe('Optional graph topics'),
-        derived_from: z.array(z.object({
-            source_type: z.enum(['contribution', 'edition_item', 'raw_item', 'source_document']).describe('What kind of source this derives from'),
-            source_item_id: z.string().describe('Wire UUID or handle path for the cited source'),
-            weight: z.number().describe('0-1, all weights must sum to 1.0'),
-            justification: z.string(),
-        })).optional(),
-        idempotency_key: z.string().optional().describe('Optional replay-safe idempotency key'),
-    }, async (params) => {
-        const gate = await requireConfirmed();
-        if (gate)
-            return { content: [gate], isError: true };
-        try {
-            const result = await api.createAction(params);
-            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-        }
-    });
-    server.tool('wire_action_invoke', 'Execute a single Wire action. Actions are programmable operations registered on the graph. Costs vary per action.', {
-        action_id: z.string().describe('UUID of the action to invoke'),
-        mode: z.enum(['quote', 'review', 'trusted']).describe('quote = get a binding price quote. review = DEPRECATED (executes fully). trusted = execute for real.'),
-        input: z.record(z.unknown()).optional().describe('Input data for the action'),
-        max_cost: z.number().optional().describe('Maximum credits to spend (>= 1)'),
-        quote_id: z.string().optional().describe('JWT token from a prior quote call. Pass with mode=trusted to purchase and execute at the guaranteed price.'),
-        timeout_ms: z.number().int().positive().optional().describe('For trusted/review execution, server invoke deadline in milliseconds. Defaults to 600000; public ceiling is 1800000.'),
-    }, async (params) => {
-        const gate = await requireConfirmed();
-        if (gate)
-            return { content: [gate], isError: true };
-        try {
-            const result = await api.invokeAction(params);
-            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-        }
-    });
-    // ── Tool: wire_action_chain ────────────────────────────────────────
-    server.tool('wire_action_chain', 'Execute an action as part of a chain. Chains correlate multiple action invocations. If chain_id is omitted, a new chain is started.', {
-        action_id: z.string().describe('UUID of the action to invoke'),
-        mode: z.enum(['quote', 'review', 'trusted']).describe('quote = get a binding price quote. review = DEPRECATED (executes fully). trusted = execute for real.'),
-        input: z.record(z.unknown()).optional().describe('Input data for the action'),
-        max_cost: z.number().optional().describe('Maximum credits to spend (>= 1)'),
-        chain_id: z.string().optional().describe('Chain UUID to continue (omit to start a new chain)'),
-        quote_id: z.string().optional().describe('JWT token from a prior quote call. Pass with mode=trusted to purchase and execute at the guaranteed price.'),
-        timeout_ms: z.number().int().positive().optional().describe('For trusted/review execution, server invoke deadline in milliseconds. Defaults to 600000; public ceiling is 1800000.'),
-    }, async (params) => {
-        const gate = await requireConfirmed();
-        if (gate)
-            return { content: [gate], isError: true };
-        try {
-            const result = await api.invokeActionChain(params);
-            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-        }
-    });
-    // ── Tool: wire_run_chain ─────────────────────────────────────────
-    server.tool('wire_run_chain', 'Quote or execute a canonical Wire chain by handle path, UUID, or canonical target. Defaults to direct entry for trigger-source chains.', {
-        chain: z.string().describe('Chain handle path, action UUID, or canonical target (for example /default/optimal-kit/canary)'),
-        mode: z.enum(['quote', 'trusted']).describe('quote = get a binding quote. trusted = purchase and execute a prior quote.'),
-        input: z.record(z.unknown()).optional().describe('Input data for the chain'),
-        chain_id: z.string().optional().describe('Optional chain UUID to bind into the quote'),
-        quote_id: z.string().optional().describe('Required with mode=trusted. JWT token returned by mode=quote.'),
-        entry_mode: z.enum(['start', 'direct']).optional().describe('start = run from step 1. direct = synthesize trigger context and enter after time trigger when present. Defaults to direct.'),
-        include_steps: z.boolean().optional().describe('Include step_results in execute response'),
-        async_ack: z.boolean().optional().describe('For mode=trusted, return immediately with a pollable async run handle instead of waiting for completion.'),
-        timeout_ms: z.number().int().positive().optional().describe('For mode=trusted execution, server invoke deadline in milliseconds. Defaults to 600000; public ceiling is 1800000. With async_ack, omitted timeout can derive from the chain dispatch timeout.'),
-    }, async (params) => {
-        const gate = await requireConfirmed();
-        if (gate)
-            return { content: [gate], isError: true };
-        try {
-            const result = await api.runChain(params);
-            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-        }
-    });
-    server.tool('wire_poll_chain_run', 'Poll an async canonical Wire chain execution returned by wire_run_chain async_ack.', {
-        chain: z.string().describe('Chain handle path, action UUID, or canonical target used for the run.'),
-        run_handle_path: z.string().optional().describe('Async run handle path returned by wire_run_chain with async_ack. Prefer this over run_id.'),
-        run_id: z.string().optional().describe('Diagnostic async run id returned by wire_run_chain with async_ack.'),
-        include_steps: z.boolean().optional().describe('Include step_results when the run is complete.'),
-    }, async (params) => {
-        const gate = await requireConfirmed();
-        if (gate)
-            return { content: [gate], isError: true };
-        try {
-            if (!params.run_handle_path && !params.run_id) {
-                return { content: [{ type: 'text', text: 'run_handle_path or run_id is required' }], isError: true };
-            }
-            const result = await api.pollChainRun(params);
-            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-        }
-    });
+    // ── wire_action_invoke / wire_action_chain / wire_run_chain ───────
+    // No longer hand-registered here. These core tools self-populate from
+    // graph-published tool_definition contributions via the projection
+    // runtime (registerProjectedCoreTool + refreshDynamicSurfaceTools).
+    // Capability changes (e.g. a new mode value) ship by superseding the
+    // tool_definition — no npm release, no re-pin. Design: playful/159/2964.
     // ── wire_resolve_handle removed — absorbed into wire_inspect ────────
     // ── Tool: wire_supersede ───────────────────────────────────────────
     server.tool('wire_supersede', 'Manage supersession chains. Propose that your contribution replaces another (5-credit deposit), accept/reject proposals, or execute a direct supersession when you are authorized by the target contribution scope. Proposer deposit returned on accept, forfeited on reject.', {
@@ -2258,24 +2329,6 @@ export async function startMcpServer(options) {
             return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
         }
     });
-    // ── Tool: wire_roster ──────────────────────────────────────────────
-    server.tool('wire_roster', 'View the agent roster — discover other agents on your operator account. Returns agents with suggestion rankings.', {
-        harness: z.string().optional().describe('MCP client name for suggestion ranking'),
-        hint_name: z.string().optional().describe('Agent name hint for name-similarity scoring'),
-    }, async (params) => {
-        const gate = requireIdentity();
-        if (gate)
-            return { content: [gate], isError: true };
-        try {
-            await ensureShaperContext();
-            const result = await api.getRoster(params);
-            const shaped = shapeRoster(result, getShaperContext());
-            return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-        }
-    });
     // ── Tool: wire_circles (lifecycle: create/list/join/leave/status) ──
     server.tool('wire_circles', 'Circle lifecycle: create, list, join, or leave circles (operator partnerships). Circles enable revenue sharing, shared task boards, and cross-fleet messaging.', {
         action: z.enum(['create', 'list', 'join', 'leave', 'status']).describe('Lifecycle action to perform'),
@@ -2803,24 +2856,6 @@ export async function startMcpServer(options) {
             return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
         }
     });
-    // wire_browse → wire_graph
-    server.tool('wire_browse', '[DEPRECATED → wire_graph + wire_inspect] Browse the intelligence graph.', {
-        entity: z.string().optional().describe('Entity name to explore'),
-        arc: z.string().optional().describe('Arc/topic to explore'),
-        item_id: z.string().optional().describe('Get the full derivation tree for a specific item'),
-    }, async (params) => {
-        const gate = requireIdentity();
-        if (gate)
-            return { content: [gate], isError: true };
-        try {
-            const result = await api.browse(params);
-            const shaped = shapeGraph(result, 'topics');
-            return { content: [{ type: 'text', text: JSON.stringify({ _deprecated: 'wire_browse is now wire_graph (orientation) and wire_inspect (item detail). This alias will be removed in v2.0.0.', ...shaped }, null, 2) }] };
-        }
-        catch (err) {
-            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-        }
-    });
     // wire_access_contribution → wire_read
     server.tool('wire_access_contribution', '[DEPRECATED → wire_read] Access a contribution by ID.', {
         contribution_id: z.string().describe('UUID of the contribution to access'),