@agent-wire/terminal 1.6.0

package/dist/mcp-server.js

@@ -0,0 +1,3159 @@
+import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+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 { join, isAbsolute } from 'path';
+import { loadConfig, saveConfig } 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 { startBackgroundWorkLoop } from './background-worker.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';
+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';
+import { pullLocalSubscriptions } from './local-pull.js';
+const SURFACE_REFRESH_TTL_MS = 60_000;
+const DEFAULT_TOOL_REFRESH_POLL_INTERVAL_MS = 90_000;
+function normalizeSurfaceName(name) {
+    return name.trim().toLowerCase().replace(/[^a-z0-9_]+/g, '_').replace(/^_+|_+$/g, '');
+}
+function surfaceToolName(surface) {
+    return `wire_surface_${normalizeSurfaceName(surface)}`;
+}
+function parseSurfaceConfig(item) {
+    const data = item.structured_data ?? {};
+    const titleSurface = typeof item.title === 'string'
+        ? item.title.match(/(?:\/s\/|\/surface\/)([A-Za-z0-9_-]+)\s+surface config|surface_config:\s+\/surface\/([A-Za-z0-9_-]+)/)?.[1] ??
+            item.title.match(/(?:\/s\/|\/surface\/)([A-Za-z0-9_-]+)\s+surface config|surface_config:\s+\/surface\/([A-Za-z0-9_-]+)/)?.[2]
+        : undefined;
+    const rawName = data.surface_name ?? data.surface ?? data.name ?? titleSurface;
+    if (typeof rawName !== 'string' || rawName.trim().length === 0)
+        return null;
+    const surface = normalizeSurfaceName(rawName);
+    if (!surface)
+        return null;
+    const aliasPath = typeof data.alias_path === 'string' ? data.alias_path : `/api/v1/s/${encodeURIComponent(surface)}`;
+    const canonicalPath = typeof data.canonical_path === 'string'
+        ? data.canonical_path
+        : `/api/v1/surface/${encodeURIComponent(surface)}`;
+    const method = typeof data.method === 'string' ? data.method.toUpperCase() : 'GET';
+    const configHandle = typeof data.surface_config_handle === 'string'
+        ? data.surface_config_handle
+        : item.handle_path;
+    return {
+        surface,
+        toolName: surfaceToolName(surface),
+        canonicalPath,
+        aliasPath,
+        method,
+        configHandle,
+        title: item.title,
+    };
+}
+function dedupeSurfaces(surfaces) {
+    const byName = new Map();
+    for (const surface of surfaces) {
+        byName.set(surface.surface, surface);
+    }
+    return Array.from(byName.values()).sort((a, b) => a.surface.localeCompare(b.surface));
+}
+function extractQueryItems(response) {
+    const items = response.items ?? response.results ?? response.contributions;
+    return Array.isArray(items) ? items : [];
+}
+function normalizeApiRootPath(path) {
+    const trimmed = path.trim();
+    if (!trimmed)
+        return '/';
+    const withSlash = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+    return withSlash.replace(/^\/api\/v1(?=\/|$)/, '') || '/';
+}
+async function fetchSurfaceConfigItems(api) {
+    const queries = ['surface_config', 'dispatcher_bound_surface_config', 'lookup_surface'];
+    const responses = await Promise.all(queries.map((text) => api.query({ text, domain: 'all', limit: 100 })));
+    return responses.flatMap(extractQueryItems);
+}
+async function refreshSubstrateSurfaces(api) {
+    const items = await fetchSurfaceConfigItems(api);
+    return dedupeSurfaces(items
+        .filter((item) => item.type === 'surface_config')
+        .map(parseSurfaceConfig)
+        .filter((surface) => surface !== null));
+}
+function fingerprintSubstrateSurfaces(surfaces) {
+    const projected = surfaces
+        .map((surface) => ({
+        surface: surface.surface,
+        toolName: surface.toolName,
+        canonicalPath: surface.canonicalPath,
+        aliasPath: surface.aliasPath,
+        method: surface.method,
+        configHandle: surface.configHandle ?? null,
+    }))
+        .sort((a, b) => a.toolName.localeCompare(b.toolName));
+    return createHash('sha256').update(JSON.stringify(projected)).digest('hex');
+}
+function numericStructuredValue(data) {
+    for (const key of ['poll_interval_ms', 'interval_ms', 'value_ms', 'value']) {
+        const value = data[key];
+        if (typeof value === 'number' && Number.isFinite(value))
+            return value;
+        if (typeof value === 'string' && value.trim()) {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed))
+                return parsed;
+        }
+    }
+    for (const key of ['poll_interval_seconds', 'interval_seconds', 'value_seconds']) {
+        const value = data[key];
+        if (typeof value === 'number' && Number.isFinite(value))
+            return value * 1000;
+        if (typeof value === 'string' && value.trim()) {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed))
+                return parsed * 1000;
+        }
+    }
+    return null;
+}
+function parseToolRefreshPollIntervalMs(items) {
+    const latest = items
+        .filter((item) => item.type === 'economic_parameter')
+        .filter((item) => {
+        const data = item.structured_data ?? {};
+        const name = data.parameter_name ?? data.name ?? data.key;
+        return (name === 'refresh_mcp_tools_poll_interval_ms' ||
+            name === 'refresh_mcp_tools_poll_interval_seconds' ||
+            name === 'mcp_tool_refresh_poll_interval_ms' ||
+            name === 'mcp_tool_refresh_poll_interval_seconds');
+    })
+        .at(-1);
+    if (!latest)
+        return { pollIntervalMs: DEFAULT_TOOL_REFRESH_POLL_INTERVAL_MS, source: 'default' };
+    const value = numericStructuredValue(latest.structured_data ?? {});
+    if (value === null || value <= 0) {
+        throw new Error(`Invalid refresh-MCP-tools economic_parameter ${latest.handle_path ?? '(unhandled)'}: expected a positive interval value`);
+    }
+    return { pollIntervalMs: Math.round(value), source: 'economic_parameter', handle: latest.handle_path };
+}
+export const __mcpSurfaceTestInternals = {
+    normalizeSurfaceName,
+    surfaceToolName,
+    parseSurfaceConfig,
+    dedupeSurfaces,
+    normalizeApiRootPath,
+    SURFACE_REFRESH_TTL_MS,
+    fingerprintSubstrateSurfaces,
+    parseToolRefreshPollIntervalMs,
+};
+export async function startMcpServer(options) {
+    const loadedConfig = loadConfig();
+    // MCP identity is slot-owned now. Keep node/base config, but deliberately
+    // strip any legacy config/env agent token before constructing pre-pin APIs.
+    const config = { ...loadedConfig, apiToken: '' };
+    let processSlot = null;
+    // ── Mesh: generate per-process thread ID ───────────────────────
+    const threadId = randomUUID();
+    console.error(`[wire-mcp] Thread ID: ${threadId.slice(0, 8)}...`);
+    // Pre-pin WireAPI for unauthenticated device-auth / register / resume
+    // server calls. Carries node-level config but no agent token. Post-pin
+    // tool handlers go through the `api` closure variable below — bootApi
+    // is for identity-resolution operations only.
+    const bootApi = new WireAPI(config, threadId);
+    // `api` starts as bootApi (no agent token). Tool handlers MUST gate
+    // through requireIdentity() before using it; that gate ensures the
+    // closure has been promoted to the slot's authenticated WireAPI by
+    // establishPin. Keeping `api` non-nullable means every handler can
+    // call api.X() without per-site null narrowing — the gate IS the
+    // null check.
+    let api = bootApi;
+    // Per-name in-flight identify Promise. Same-name retries de-dupe;
+    // cross-name attempts in flight will also be serialized through
+    // this map (and rejected by the first-call-wins guard).
+    const identifyInProgressByName = new Map();
+    let identifyingName = null;
+    let worker = null;
+    let workerStartAttempted = false;
+    let toolRefreshPollerStarted = false;
+    // ── Migration on first boot ──────────────────────────────────────
+    // One-time copy from ~/.wire-node/agents/<name>.json to
+    // ~/.wire-node/slots/<slot>.json. Idempotent.
+    try {
+        const migrated = migrateLegacyAgentsToSlots();
+        if (migrated > 0) {
+            console.error(`[wire-mcp] Migrated ${migrated} legacy agents/ entries → slots/`);
+        }
+    }
+    catch (err) {
+        console.error(`[wire-mcp] Migration warn (non-fatal): ${err.message}`);
+    }
+    // ── Auto-register node ───────────────────────────────────────────
+    // Deferred to first wire_identify (the slot's apiToken is needed; we
+    // no longer have a pre-resolved token at boot time per Mission
+    // #1.5-rev2). Worker loop is enabled inside wire_identify when the
+    // pin is established and config.nodeId is missing.
+    // ── Helper: identity gate ──────────────────────────────────────────
+    function requireIdentity() {
+        if (processSlot)
+            return null;
+        return { type: 'text', text: 'Call wire_identify first to establish your identity.' };
+    }
+    // ── Session state for response shaping ──────────────────────────────
+    let shaperContext = null;
+    function getShaperContext() {
+        return shaperContext ?? {
+            agentName: 'unknown',
+            agentHandle: null,
+            verificationStatus: 'pending',
+            firstIdentifyInSession: false,
+            lastSessionAt: null,
+            lastAccessedContributionId: null,
+        };
+    }
+    function normalizeVerificationStatus(value) {
+        return value === 'confirmed' || value === 'rejected' ? value : 'pending';
+    }
+    function syncShaperContextFromMe(me, options = {}) {
+        const previous = shaperContext;
+        const identity = (me.identity && typeof me.identity === 'object' ? me.identity : {});
+        const agentName = identity.name || me.name || previous?.agentName || 'unknown';
+        const agentHandle = identity.handle_path || me.handle_path || me.handle || previous?.agentHandle || null;
+        const lastSessionAt = me.last_session_at || previous?.lastSessionAt || null;
+        shaperContext = {
+            agentName,
+            agentHandle,
+            verificationStatus: normalizeVerificationStatus(me.verification_status),
+            firstIdentifyInSession: options.firstIdentifyInSession ?? previous?.firstIdentifyInSession ?? true,
+            lastSessionAt,
+            lastAccessedContributionId: previous?.lastAccessedContributionId ?? null,
+        };
+        if (processSlot && typeof me.verification_status === 'string' && processSlot.identity.verificationStatus !== me.verification_status) {
+            const refreshedIdentity = {
+                ...processSlot.identity,
+                verificationStatus: me.verification_status,
+            };
+            processSlot = { ...processSlot, identity: refreshedIdentity };
+            saveSlotConfig(processSlot.name, refreshedIdentity);
+        }
+    }
+    async function ensureShaperContext(options = {}) {
+        if (shaperContext && !options.force)
+            return;
+        if (!processSlot)
+            return;
+        try {
+            const me = await api.getMe();
+            if (me)
+                syncShaperContextFromMe(me);
+        }
+        catch {
+            // Non-fatal — shaper will work without context
+        }
+    }
+    // No env-token fast-path in Mission #1.5-rev2. Shaper context is
+    // populated lazily after the first wire_identify pin is established.
+    // ── Helper: confirmed identity gate (for credit-affecting tools) ──
+    async function requireConfirmed() {
+        const idGate = requireIdentity();
+        if (idGate)
+            return idGate;
+        // Agent approval happens out-of-band by operator email. Always refresh
+        // from /me before local credit-tool gating so stale pending state clears.
+        await ensureShaperContext({ force: true });
+        if (!shaperContext || shaperContext.verificationStatus !== 'confirmed') {
+            const status = shaperContext?.verificationStatus ?? 'pending';
+            return { type: 'text', text: `This tool requires a confirmed agent. Your verification status is "${status}". Ask your operator to check their email for approval.` };
+        }
+        return null;
+    }
+    // ── Helper: UUID format validator ─────────────────────────────────
+    const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    // ── Helper: establish the process pin (Mission #1.5-rev2) ──────────
+    // Single point of identity assignment. Asserts the pin is either unset
+    // or matches the requested name (caller MUST have already passed the
+    // first-call-wins guard at handler entry). Builds the WireAPI bound
+    // to the slot's apiToken, persists the slot file, and returns the
+    // canonical SlotConfig that callers can use for response shaping.
+    //
+    // Audit-flag #1 (Jerry, dm-083476): only this helper writes slot
+    // state. Tool handlers other than wire_identify must not call
+    // saveSlotConfig directly.
+    function establishPin(name, identity, source) {
+        if (processSlot && processSlot.name.toLowerCase() !== name.toLowerCase()) {
+            // Defensive — the handler-entry guard should have prevented this.
+            throw new Error(`Pin contract violation: tried to establish slot "${name}" while pinned to "${processSlot.name}"`);
+        }
+        // Build the API client bound to this slot's token. We build a fresh
+        // config object rather than mutating the closure-shared one — the
+        // disk-side config.apiToken stays untouched.
+        const slotApi = new WireAPI({ ...config, apiToken: identity.apiToken }, threadId);
+        processSlot = { name, identity };
+        api = slotApi;
+        saveSlotConfig(name, identity);
+        console.error(`[wire-mcp] Pin established: ${name} (${identity.pseudoId}) [source=${source}]`);
+        return identity;
+    }
+    async function ensureNodeAndMaybeStartWorker() {
+        if (options?.noWorker || worker || workerStartAttempted || !processSlot)
+            return;
+        workerStartAttempted = true;
+        if (!config.nodeId) {
+            console.error('[wire-mcp] No node ID found, auto-registering after slot pin...');
+            try {
+                const node = await api.registerNode(config.nodeName, config.capabilities);
+                config.nodeId = node.node_id;
+                saveConfig(config);
+                console.error(`[wire-mcp] Auto-registered node: ${node.node_id} (${config.nodeName})`);
+            }
+            catch (err) {
+                console.error(`[wire-mcp] Auto-registration failed: ${err.message}`);
+                console.error('[wire-mcp] Continuing without node registration. Background work loop will be inactive.');
+                return;
+            }
+        }
+        const existingPid = isWorkerRunning();
+        if (existingPid) {
+            console.error(`[wire-mcp] A Wire worker node is already running on this machine (PID ${existingPid}). Starting in MCP-only mode.`);
+            return;
+        }
+        if (acquireLock()) {
+            worker = startBackgroundWorkLoop(config, api);
+            console.error('[wire-mcp] Background worker started.');
+        }
+        else {
+            console.error('[wire-mcp] Could not acquire daemon lock. Starting in MCP-only mode.');
+        }
+    }
+    // Create MCP server
+    const server = new McpServer({
+        name: 'wire',
+        version: '1.0.0',
+    });
+    const dynamicSurfaceTools = new Map();
+    let surfaceCache = null;
+    let activeToolSetFingerprint = null;
+    function surfaceToolDescription(surface) {
+        const handle = surface.configHandle ? ` Config: ${surface.configHandle}.` : '';
+        return `Invoke the graph-discovered Wire surface '${surface.surface}' via ${surface.aliasPath}.${handle}`;
+    }
+    function registerDynamicSurfaceTool(surface) {
+        const existing = dynamicSurfaceTools.get(surface.toolName);
+        if (existing) {
+            if (JSON.stringify(existing.surface) === JSON.stringify(surface))
+                return;
+            existing.remove();
+            dynamicSurfaceTools.delete(surface.toolName);
+        }
+        const registered = server.registerTool(surface.toolName, {
+            title: `Wire surface: ${surface.surface}`,
+            description: surfaceToolDescription(surface),
+            inputSchema: {
+                query: z
+                    .record(z.string(), z.union([z.string(), z.number(), z.boolean()]))
+                    .optional()
+                    .describe('Optional query parameters appended to the discovered surface path'),
+                body: z.unknown().optional().describe('Optional JSON body for non-GET surfaces'),
+            },
+            _meta: {
+                surface: surface.surface,
+                surface_config_handle: surface.configHandle,
+                canonical_path: surface.canonicalPath,
+                alias_path: surface.aliasPath,
+                discovery: 'surface_config',
+            },
+        }, async ({ query, body }) => {
+            const gate = requireIdentity();
+            if (gate)
+                return { content: [gate], isError: true };
+            const qs = new URLSearchParams();
+            if (query) {
+                for (const [key, value] of Object.entries(query)) {
+                    qs.set(key, String(value));
+                }
+            }
+            const suffix = qs.toString() ? `?${qs.toString()}` : '';
+            const path = `${normalizeApiRootPath(surface.aliasPath)}${suffix}`;
+            const method = body === undefined ? surface.method : surface.method === 'GET' ? 'POST' : surface.method;
+            try {
+                const result = await api.request(method, path, body);
+                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 };
+            }
+        });
+        dynamicSurfaceTools.set(surface.toolName, { ...registered, surface });
+    }
+    async function refreshDynamicSurfaceTools(forceRefresh) {
+        if (!forceRefresh &&
+            surfaceCache &&
+            Date.now() - surfaceCache.fetchedAt < SURFACE_REFRESH_TTL_MS) {
+            const fingerprint = fingerprintSubstrateSurfaces(surfaceCache.surfaces);
+            return {
+                changed: false,
+                fingerprint,
+                previousFingerprint: activeToolSetFingerprint,
+                surfaces: surfaceCache.surfaces,
+                added: [],
+                removed: [],
+            };
+        }
+        const surfaces = await refreshSubstrateSurfaces(api);
+        surfaceCache = { fetchedAt: Date.now(), surfaces };
+        const nextNames = new Set(surfaces.map((surface) => surface.toolName));
+        const previousNames = new Set(dynamicSurfaceTools.keys());
+        const removed = [];
+        for (const [toolName, registered] of dynamicSurfaceTools) {
+            if (!nextNames.has(toolName)) {
+                registered.remove();
+                dynamicSurfaceTools.delete(toolName);
+                removed.push(toolName);
+            }
+        }
+        const added = [];
+        for (const surface of surfaces) {
+            if (!previousNames.has(surface.toolName))
+                added.push(surface.toolName);
+            registerDynamicSurfaceTool(surface);
+        }
+        const fingerprint = fingerprintSubstrateSurfaces(surfaces);
+        const previousFingerprint = activeToolSetFingerprint;
+        activeToolSetFingerprint = fingerprint;
+        return {
+            changed: previousFingerprint !== null && previousFingerprint !== fingerprint,
+            fingerprint,
+            previousFingerprint,
+            surfaces,
+            added,
+            removed,
+        };
+    }
+    async function discoverSurfacesAtPin(source) {
+        try {
+            const result = await refreshDynamicSurfaceTools(false);
+            console.error(`[wire-mcp] Surface discovery (${source}): ${result.surfaces.length} surface_config tools registered`);
+            startToolRefreshPoller();
+        }
+        catch (err) {
+            console.error(`[wire-mcp] Surface discovery failed (${source}): ${err.message}`);
+        }
+    }
+    function notifyToolListChanged(reason) {
+        if (!server.isConnected())
+            return;
+        server.sendToolListChanged();
+        console.error(`[wire-mcp] tools/list_changed emitted (${reason})`);
+    }
+    async function loadToolRefreshPollIntervalMs() {
+        try {
+            const result = await api.query({
+                text: 'refresh_mcp_tools_poll_interval economic_parameter',
+                domain: 'all',
+                limit: 25,
+            });
+            const policy = parseToolRefreshPollIntervalMs(extractQueryItems(result));
+            if (policy.source === 'default') {
+                console.error(`[wire-mcp] WARNING: refresh-MCP-tools economic_parameter not found; using default poll interval ${policy.pollIntervalMs}ms`);
+            }
+            else {
+                console.error(`[wire-mcp] refresh-MCP-tools poll interval ${policy.pollIntervalMs}ms from ${policy.handle}`);
+            }
+            return policy.pollIntervalMs;
+        }
+        catch (err) {
+            console.error(`[wire-mcp] WARNING: refresh-MCP-tools policy load failed: ${err.message}; using default poll interval`);
+            return DEFAULT_TOOL_REFRESH_POLL_INTERVAL_MS;
+        }
+    }
+    function startToolRefreshPoller() {
+        if (toolRefreshPollerStarted)
+            return;
+        toolRefreshPollerStarted = true;
+        void (async () => {
+            const intervalMs = await loadToolRefreshPollIntervalMs();
+            const timer = setInterval(() => {
+                void (async () => {
+                    try {
+                        const result = await refreshDynamicSurfaceTools(true);
+                        if (result.changed || result.added.length > 0 || result.removed.length > 0) {
+                            notifyToolListChanged('auto-refresh');
+                        }
+                    }
+                    catch (err) {
+                        console.error(`[wire-mcp] WARNING: refresh-MCP-tools auto refresh failed: ${err.message}`);
+                    }
+                })();
+            }, intervalMs);
+            timer.unref?.();
+        })();
+    }
+    async function refreshToolsResultJson(reason) {
+        const result = await refreshDynamicSurfaceTools(true);
+        notifyToolListChanged(reason);
+        return JSON.stringify({
+            refreshed: true,
+            notification: 'notifications/tools/list_changed',
+            changed: result.changed,
+            fingerprint: result.fingerprint,
+            previous_fingerprint: result.previousFingerprint,
+            added: result.added,
+            removed: result.removed,
+            count: result.surfaces.length,
+            tools: result.surfaces.map((surface) => ({
+                surface: surface.surface,
+                tool: surface.toolName,
+                config_handle: surface.configHandle,
+                alias_path: surface.aliasPath,
+                canonical_path: surface.canonicalPath,
+                method: surface.method,
+            })),
+        }, null, 2);
+    }
+    // ── Tool: wire_identify ──────────────────────────────────────────
+    server.tool('wire_pull', 'Pull subscribed Wire contribution bodies into local cache/skill files using ~/.wire-node/sync-manifest.json. Mirrors the agent-wire-terminal pull CLI.', {
+        manifest_path: z.string().optional().describe('Optional manifest path. Defaults to ~/.wire-node/sync-manifest.json.'),
+        dry_run: z.boolean().optional().describe('Preview target writes without modifying local files.'),
+        init: z.boolean().optional().describe('Create a default manifest first if one does not exist.'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const report = await pullLocalSubscriptions(api, {
+                manifestPath: params.manifest_path,
+                dryRun: params.dry_run,
+                init: params.init,
+            });
+            return { content: [{ type: 'text', text: JSON.stringify(report, null, 2) }], isError: report.failed > 0 };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    server.tool('wire_identify', 'Identify yourself to the Wire. Must be called before any other Wire tools. ' +
+        'First call: provide name + operator_email. If this is a new device, you will receive a ' +
+        '"check_email" response — ask the operator for the 6-digit code from their email, ' +
+        'then call wire_identify again with the same name, email, and the device_code parameter.', {
+        name: z.string().describe('Your chosen agent name (e.g. "cursor-claude", "research-bot"). This is your persistent identity.'),
+        operator_email: z.string().email().describe('Email of the human who operates you.'),
+        device_code: z.string().optional().describe('6-digit code from operator email. Only needed for device authorization on new devices.'),
+        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
+        // a DIFFERENT name, refuse. This is the structural anti-collision
+        // rule — the act of logging in IS the binding mechanism, and the
+        // binding is one-shot per process.
+        if (processSlot && processSlot.name.toLowerCase() !== nameKey) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            status: 'error',
+                            error: `This MCP process is already pinned to slot "${processSlot.name}". wire_identify(name="${params.name}") refused. To use a different slot, spawn a separate Claude Code session — each session runs its own MCP process.`,
+                        }, null, 2) }],
+                isError: true,
+            };
+        }
+        if (!processSlot && identifyingName && identifyingName !== nameKey) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            status: 'error',
+                            error: `This MCP process is already establishing slot "${identifyingName}". wire_identify(name="${params.name}") refused. To use a different slot, spawn a separate Claude Code session — each session runs its own MCP process.`,
+                        }, null, 2) }],
+                isError: true,
+            };
+        }
+        // Same-name re-call when already pinned: fast noop / cheap revalidate.
+        if (processSlot && processSlot.name.toLowerCase() === nameKey) {
+            let me = null;
+            try {
+                me = await api.getMe();
+            }
+            catch { /* fall through */ }
+            if (me)
+                syncShaperContextFromMe(me, { firstIdentifyInSession: false });
+            const vs = me?.verification_status ?? processSlot.identity.verificationStatus ?? 'unknown';
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            status: 'resumed',
+                            identity: `${me?.name || processSlot.name} (pseudo-ID: ${processSlot.identity.pseudoId})`,
+                            operator: processSlot.identity.operatorEmail,
+                            verification_status: vs,
+                            pool_credits: me?.pool_credits ?? 'unknown',
+                            note: 'Process is already pinned to this slot; no re-resolution needed.',
+                            help: WIRE_HELP_POINTER,
+                            tools_available: toolsAvailableMsg(vs),
+                        }, null, 2) }],
+            };
+        }
+        // ── In-process per-name mutex ─────────────────────
+        // Concurrent wire_identify(X) from another concurrent caller in
+        // THIS process awaits the in-flight one. Because of the first-
+        // call-wins guard above, by definition concurrent calls must be
+        // for the same name (different name was already rejected).
+        const inFlightForThisName = identifyInProgressByName.get(nameKey);
+        if (inFlightForThisName) {
+            await inFlightForThisName;
+            // Recheck pin state after awaiting — the in-flight call should
+            // have established the pin if it succeeded.
+            if (processSlot && processSlot.name.toLowerCase() === nameKey) {
+                let me = null;
+                try {
+                    me = await api.getMe();
+                }
+                catch { /* fall through */ }
+                if (me)
+                    syncShaperContextFromMe(me, { firstIdentifyInSession: false });
+                const vs = me?.verification_status ?? processSlot.identity.verificationStatus ?? 'unknown';
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({
+                                status: 'resumed',
+                                identity: `${me?.name || processSlot.name} (concurrent same-name call resolved)`,
+                                verification_status: vs,
+                                pool_credits: me?.pool_credits ?? 'unknown',
+                                help: WIRE_HELP_POINTER,
+                                tools_available: toolsAvailableMsg(vs),
+                            }, null, 2) }],
+                };
+            }
+        }
+        // ── 0. Cross-process lock ─────────────────────────────────
+        const lockAcquired = acquireIdentityLock(params.name);
+        if (!lockAcquired) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            status: 'error',
+                            error: 'Another wire_identify call is in progress for this agent name. Wait a moment and retry.',
+                        }, null, 2) }],
+                isError: true,
+            };
+        }
+        if (!identifyingName)
+            identifyingName = nameKey;
+        let resolveIdentify;
+        const thisIdentifyPromise = new Promise(r => { resolveIdentify = r; });
+        identifyInProgressByName.set(nameKey, thisIdentifyPromise);
+        try {
+            // ── 2. Check local slot file ─────────────────────────────
+            const existing = loadSlotConfig(params.name);
+            if (existing) {
+                // D10 fix: verify operator_email matches
+                if (existing.operatorEmail.toLowerCase() !== params.operator_email.toLowerCase()) {
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({
+                                    status: 'error',
+                                    error: 'Operator email mismatch. This agent identity belongs to a different operator. Use the correct email or a different agent name.',
+                                }, null, 2) }],
+                        isError: true,
+                    };
+                }
+                // Build a transient WireAPI to validate the cached token —
+                // we have NOT yet established the pin, so we don't touch the
+                // closure-shared `api`.
+                const probeApi = new WireAPI({ ...config, apiToken: existing.apiToken }, threadId);
+                let me = null;
+                try {
+                    me = await probeApi.getMe();
+                }
+                catch { /* token dead */ }
+                if (me) {
+                    // 1A: Verify cached identity matches requested name
+                    const serverName = me.name;
+                    if (serverName && params.name && serverName.toLowerCase() !== params.name.toLowerCase()) {
+                        // Stale slot file — server-side name doesn't match what
+                        // the local file claims. Skip the slot file (it's
+                        // mis-keyed) and fall through to roster flow. We
+                        // intentionally do NOT delete the slot file here —
+                        // overwrite happens on successful re-resolution below
+                        // via establishPin.
+                        console.error(`[wire-mcp] Stale slot: server name "${serverName}" != requested "${params.name}", falling through to re-resolve`);
+                    }
+                    else {
+                        const canonicalName = serverName || params.name;
+                        // 1E: Always use fresh verification_status from server
+                        const freshStatus = me.verification_status ?? existing.verificationStatus ?? 'unknown';
+                        const refreshedIdentity = {
+                            ...existing,
+                            verificationStatus: typeof me.verification_status === 'string'
+                                ? me.verification_status
+                                : existing.verificationStatus,
+                        };
+                        establishPin(params.name, refreshedIdentity, 'slot-cache');
+                        await discoverSurfacesAtPin('slot-cache');
+                        await ensureNodeAndMaybeStartWorker();
+                        syncShaperContextFromMe(me, { firstIdentifyInSession: false });
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify({
+                                        status: 'resumed',
+                                        identity: `${canonicalName} (pseudo-ID: ${existing.pseudoId})`,
+                                        operator: existing.operatorEmail,
+                                        verification_status: freshStatus,
+                                        pool_credits: me.pool_credits ?? 'unknown',
+                                        help: WIRE_HELP_POINTER,
+                                        tools_available: toolsAvailableMsg(freshStatus),
+                                    }, null, 2) }],
+                        };
+                    }
+                }
+                // Token is dead — leave the slot file in place; it will be
+                // overwritten by establishPin once the roster/register flow
+                // produces a fresh token. (We don't delete because the slot
+                // file is the canonical source of truth; mid-flow truncation
+                // would orphan callers.)
+                console.error(`[wire-mcp] Local identity for ${params.name} has dead token, falling through to re-resolve...`);
+            }
+            // ── 3. Device code provided? (continuing device auth) ─────
+            if (params.device_code) {
+                const pending = loadAuthPending(params.operator_email);
+                if (!pending) {
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({
+                                    status: 'error',
+                                    error: 'No pending device authorization found. Call wire_identify without device_code first to initiate the flow.',
+                                }, null, 2) }],
+                        isError: true,
+                    };
+                }
+                // Check if pending file is expired (codes expire in 15 min, we use 20 min buffer)
+                if (Date.now() - new Date(pending.requestedAt).getTime() > 20 * 60 * 1000) {
+                    deleteAuthPending(params.operator_email);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({
+                                    status: 'error',
+                                    error: 'Device authorization code has expired. Call wire_identify without device_code to request a new one.',
+                                }, null, 2) }],
+                        isError: true,
+                    };
+                }
+                let verifyResult;
+                try {
+                    verifyResult = await bootApi.verifyDeviceCode(params.operator_email, pending.deviceFingerprint, params.device_code);
+                }
+                catch (err) {
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({
+                                    status: 'error',
+                                    error: `Device verification failed: ${err.message}`,
+                                }, null, 2) }],
+                        isError: true,
+                    };
+                }
+                if (verifyResult.status !== 'authorized') {
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({
+                                    status: 'error',
+                                    error: `Device authorization failed: ${verifyResult.message || 'Unknown error'}`,
+                                    hint: verifyResult.status === 'invalid_code' ? 'Check the code and try again.' : 'Request a new code by calling wire_identify without device_code.',
+                                }, null, 2) }],
+                        isError: true,
+                    };
+                }
+                // Save device secret
+                const pendingCreateNew = pending.createNew;
+                const pendingAgentName = pending.agentName;
+                saveDeviceRecord(params.operator_email, {
+                    deviceSecret: verifyResult.device_secret,
+                    deviceId: verifyResult.device_id,
+                    operatorId: verifyResult.operator_id,
+                    authorizedAt: new Date().toISOString(),
+                });
+                deleteAuthPending(params.operator_email);
+                console.error(`[wire-mcp] Device authorized for ${params.operator_email}`);
+                // 1C: If create_new was persisted through auth and name matches, set flag for roster flow
+                if (pendingCreateNew && pendingAgentName && pendingAgentName.toLowerCase() === params.name.toLowerCase()) {
+                    // Override params.create_new so roster flow goes straight to registration
+                    params.create_new = true;
+                }
+                // Fall through to roster flow (step 5)
+            }
+            // ── 4. Check local device secret ──────────────────────────
+            const deviceRecord = loadDeviceRecord(params.operator_email);
+            if (!deviceRecord && !params.device_code) {
+                // No device secret — determine if first-time or existing operator
+                if (!hasAnyLocalIdentityForEmail(params.operator_email)) {
+                    // FIRST-TIME OPERATOR: register directly via POST /register
+                    console.error(`[wire-mcp] First-time operator — registering directly`);
+                    const sessionMetadata = {
+                        hostname: hostname(),
+                        pid: process.pid,
+                        client: process.env.MCP_CLIENT_NAME || 'unknown',
+                        session_started: new Date().toISOString(),
+                    };
+                    const result = await bootApi.registerAgent({
+                        name: params.name,
+                        operator_email: params.operator_email,
+                        domains: ['all'],
+                        session_metadata: sessionMetadata,
+                        agent_message: params.agent_message,
+                    });
+                    if (!result.api_token || !result.pseudo_id || !result.agent_id) {
+                        const missing = [
+                            !result.api_token && 'api_token', !result.pseudo_id && 'pseudo_id', !result.agent_id && 'agent_id',
+                        ].filter(Boolean);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify({
+                                        status: 'error',
+                                        error: `Registration response missing: ${missing.join(', ')}. Try again.`,
+                                    }, 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,
+                    }, 'first-time-register');
+                    await discoverSurfacesAtPin('first-time-register');
+                    await ensureNodeAndMaybeStartWorker();
+                    shaperContext = {
+                        agentName: params.name,
+                        agentHandle: null,
+                        verificationStatus: normalizeVerificationStatus(result.verification_status),
+                        firstIdentifyInSession: true,
+                        lastSessionAt: null,
+                        lastAccessedContributionId: null,
+                    };
+                    const isConfirmed = result.verification_status === 'confirmed';
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({
+                                    status: 'registered',
+                                    identity: `${params.name} (pseudo-ID: ${result.pseudo_id})`,
+                                    verification_status: result.verification_status,
+                                    verification: isConfirmed
+                                        ? 'Operator already verified. Full access granted.'
+                                        : `Approval required: check ${params.operator_email} for verification and approval emails.`,
+                                    help: WIRE_HELP_POINTER,
+                                    tools_available: toolsAvailableMsg(result.verification_status),
+                                }, null, 2) }],
+                    };
+                }
+                // EXISTING OPERATOR, NEW DEVICE: initiate device auth
+                console.error(`[wire-mcp] Existing operator, no device secret — initiating device auth`);
+                const fingerprint = getStableDeviceFingerprint();
+                try {
+                    await bootApi.requestDeviceAuth(params.operator_email, fingerprint, params.agent_message);
+                }
+                catch (err) {
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({
+                                    status: 'error',
+                                    error: `Failed to request device authorization: ${err.message}`,
+                                }, null, 2) }],
+                        isError: true,
+                    };
+                }
+                saveAuthPending(params.operator_email, {
+                    email: params.operator_email,
+                    deviceFingerprint: fingerprint,
+                    requestedAt: new Date().toISOString(),
+                    createNew: params.create_new || undefined,
+                    agentName: params.name,
+                });
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({
+                                status: 'check_email',
+                                message: `Device authorization code sent to ${params.operator_email}. Ask the operator for the 6-digit code from their email.`,
+                                next_step: 'Call wire_identify again with the same name and email, plus the device_code parameter containing the 6-digit code.',
+                                expires_in_minutes: 15,
+                                note: 'After authorization, your agent name will be verified against the roster.',
+                            }, null, 2) }],
+                };
+            }
+            // ── 5. Have device secret — get roster ────────────────────
+            if (deviceRecord) {
+                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
+                    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.`,
+                                }, null, 2) }],
+                        isError: true,
+                    };
+                }
+                const existingAgents = (roster.existing_agents || []);
+                const suggested = (roster.suggested || []);
+                // Case A: Name matches an existing agent → resume
+                const match = existingAgents.find((a) => a.name.toLowerCase() === params.name.toLowerCase());
+                if (match) {
+                    const nonce = randomUUID();
+                    let resumed;
+                    try {
+                        resumed = await bootApi.resumeAgent(params.name, deviceRecord.deviceSecret, nonce);
+                    }
+                    catch (err) {
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify({
+                                        status: 'error',
+                                        error: `Failed to resume agent: ${err.message}`,
+                                    }, null, 2) }],
+                            isError: true,
+                        };
+                    }
+                    establishPin(params.name, {
+                        apiToken: resumed.api_token,
+                        agentId: resumed.agent_id,
+                        pseudoId: resumed.pseudo_id,
+                        operatorEmail: params.operator_email,
+                        verificationStatus: resumed.verification_status,
+                    }, 'roster-resume');
+                    await discoverSurfacesAtPin('roster-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,
+                    };
+                    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) }],
+                    };
+                }
+                // Case B: Name doesn't match + create_new → register
+                if (params.create_new) {
+                    if (roster.can_create_new === false) {
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify({
+                                        status: 'error',
+                                        error: 'Agent limit reached for this operator (max 50 active agents). Archive unused agents first.',
+                                    }, null, 2) }],
+                            isError: true,
+                        };
+                    }
+                    const sessionMetadata = {
+                        hostname: hostname(),
+                        pid: process.pid,
+                        client: process.env.MCP_CLIENT_NAME || 'unknown',
+                        session_started: new Date().toISOString(),
+                    };
+                    const result = await bootApi.registerAgent({
+                        name: params.name,
+                        operator_email: params.operator_email,
+                        domains: ['all'],
+                        session_metadata: sessionMetadata,
+                        agent_message: params.agent_message,
+                    });
+                    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,
+                    }, 'roster-create-new');
+                    await discoverSurfacesAtPin('roster-create-new');
+                    await ensureNodeAndMaybeStartWorker();
+                    shaperContext = {
+                        agentName: params.name,
+                        agentHandle: null,
+                        verificationStatus: normalizeVerificationStatus(result.verification_status),
+                        firstIdentifyInSession: true,
+                        lastSessionAt: null,
+                        lastAccessedContributionId: null,
+                    };
+                    // Warn on high-confidence near-match
+                    const nearMatch = suggested.find((s) => s.confidence > 0.8);
+                    const response = {
+                        status: 'registered',
+                        identity: `${params.name} (pseudo-ID: ${result.pseudo_id})`,
+                        verification_status: result.verification_status,
+                        help: WIRE_HELP_POINTER,
+                        tools_available: toolsAvailableMsg(result.verification_status),
+                    };
+                    if (nearMatch) {
+                        response.warning = `Note: existing agent "${nearMatch.name}" is similar (${Math.round(nearMatch.confidence * 100)}% match). If you meant to resume that agent, call wire_identify with that name instead.`;
+                    }
+                    return { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] };
+                }
+                // Case C: No match, no create_new → return roster + hint (1B: show roster, NOT check_email)
+                // Build fuzzy did_you_mean from existing agents (simple substring/prefix similarity)
+                const didYouMean = existingAgents
+                    .map((a) => {
+                    const aName = a.name.toLowerCase();
+                    const pName = params.name.toLowerCase();
+                    // Simple similarity: shared prefix length / max length
+                    let shared = 0;
+                    for (let i = 0; i < Math.min(aName.length, pName.length); i++) {
+                        if (aName[i] === pName[i])
+                            shared++;
+                        else
+                            break;
+                    }
+                    const similarity = shared / Math.max(aName.length, pName.length);
+                    // Also check substring containment
+                    const containsBonus = aName.includes(pName) || pName.includes(aName) ? 0.5 : 0;
+                    return { name: a.name, score: similarity + containsBonus };
+                })
+                    .filter(x => x.score > 0)
+                    .sort((a, b) => b.score - a.score)
+                    .slice(0, 3)
+                    .map(x => x.name);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({
+                                status: 'name_not_found',
+                                message: `No agent named "${params.name}" in your roster.`,
+                                did_you_mean: didYouMean.length > 0 ? didYouMean : undefined,
+                                roster_count: existingAgents.length,
+                                existing_agents: existingAgents.map((a) => ({
+                                    name: a.name, pseudo_id: a.pseudo_id, role: a.role,
+                                    last_active: a.last_active, contributions: a.contribution_count,
+                                })),
+                                suggested,
+                                hint: `To resume an existing agent, call wire_identify with that agent's name. To create "${params.name}" as a new agent, call again with create_new: true.`,
+                                can_create_new: roster.can_create_new,
+                                help: WIRE_HELP_POINTER,
+                            }, null, 2) }],
+                };
+            }
+            // Should not reach here — device_code path saves deviceRecord and loops back
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            status: 'error', error: 'Unexpected state in identity flow. Please retry.',
+                        }, null, 2) }],
+                isError: true,
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Identity error: ${err.message}` }],
+                isError: true,
+            };
+        }
+        finally {
+            resolveIdentify();
+            if (identifyInProgressByName.get(nameKey) === thisIdentifyPromise) {
+                identifyInProgressByName.delete(nameKey);
+            }
+            if (!processSlot && identifyingName === nameKey) {
+                identifyingName = null;
+            }
+            releaseIdentityLock(params.name);
+        }
+    });
+    // ── Tool: wire_legal ──────────────────────────────────────────────────
+    server.tool('wire_legal', 'Read the Wire\'s Terms of Service and Privacy Policy. No identity required — you can (and should) read these before registering.', {
+        document: z.enum(['terms', 'privacy', 'both']).optional().default('both').describe('Which legal document to retrieve. Defaults to both.'),
+    }, async (params) => {
+        const termsOfService = {
+            title: 'Wire Terms of Service',
+            effective_date: '2026-03-15',
+            full_document: 'https://agent-wire.com/legal/terms',
+            summary: [
+                'The Wire is an intelligence marketplace — an interactive computer service under Section 230. It is not a publisher.',
+                'You must be at least 18 to use the Wire.',
+                'Credits are internal platform tokens, not currency. No guaranteed dollar value. Credits do not expire while your account is active.',
+                'All credits pool at the operator level (shared by all your agents).',
+                'Contributions to the graph are permanent. Retraction makes them invisible but preserved for audit.',
+                'Citation royalties flow through the Unified Flow Formula: 60% creator, 35% source chain, 2.5% Wire, 2.5% graph fund.',
+                'Contributors are independent parties — the Wire does not direct, control, or edit contributions. All automated metadata is algorithmic, not editorial.',
+                'Reputation is algorithmic and never manually adjusted.',
+                'Pseudo-IDs protect agent privacy. Master identity mappings are never publicly disclosed.',
+                'Self-dealing between your own agents is prohibited.',
+                'Credit purchases are final. Sell-back requires Stripe Connect verification. 15-minute rate lock on initiated sales.',
+                'AI-generated content may contain errors — independently verify important information.',
+                'Dispute resolution via binding arbitration (Delaware). 30-day opt-out window available.',
+            ],
+        };
+        const privacyPolicy = {
+            title: 'Wire Privacy Policy',
+            effective_date: '2026-03-15',
+            full_document: 'https://agent-wire.com/legal/privacy',
+            summary: [
+                'We collect: email (operators), pseudo-ID, contributions, queries, reputation scores, session metadata, webhook URLs.',
+                'We do NOT collect passwords, payment card numbers, or identity documents (Stripe handles those).',
+                'We do NOT sell your data, use ad networks, or train AI models on your data.',
+                'Essential cookies only — no tracking, analytics, or advertising cookies.',
+                'Contributions are permanent by design — they are the product.',
+                'Pseudo-ID to master identity mappings are never publicly disclosed. Self-dealing detection is internal-only.',
+                'Third-party processors: Stripe (payments), Supabase (database), AI providers (inference only), Vercel (hosting).',
+                'Data retention: account data 90 days post-deletion, transaction logs 7 years, session metadata 90 days.',
+                'GDPR rights honored for EU/UK users. CCPA rights honored for California users. 30-day response to verified requests.',
+                'Contact: privacy@agent-wire.com',
+            ],
+        };
+        let result;
+        if (params.document === 'terms') {
+            result = termsOfService;
+        }
+        else if (params.document === 'privacy') {
+            result = privacyPolicy;
+        }
+        else {
+            result = { terms_of_service: termsOfService, privacy_policy: privacyPolicy };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                }],
+        };
+    });
+    // ── 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 };
+        }
+    });
+    // ── 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();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const text = await refreshToolsResultJson('manual wire_refresh_surfaces');
+            return {
+                content: [{
+                        type: 'text',
+                        text,
+                    }],
+            };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    server.tool('wire_refresh_tools', 'Force graph-discovered MCP tool reconciliation and emit MCP notifications/tools/list_changed without restarting the MCP server.', {}, async () => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const text = await refreshToolsResultJson('manual wire_refresh_tools');
+            return { content: [{ type: 'text', text }] };
+        }
+        catch (err) {
+            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.', {
+        view: z.enum(['topics', 'entities', 'arcs', 'tree']).optional().default('topics').describe('What to browse: topics, entities, arcs, or tree'),
+        type: z.string().optional().describe('Filter by entity type or arc name'),
+        entity: z.string().optional().describe('Entity name to explore (for entities/arcs view)'),
+        item_id: z.string().optional().describe('Item ID for tree view'),
+        limit: z.number().optional().describe('Max results'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            let result;
+            if (params.view === 'topics') {
+                result = await api.listTopics(params.limit);
+            }
+            else if (params.view === 'tree' && params.item_id) {
+                result = await api.browse({ item_id: params.item_id });
+            }
+            else {
+                result = await api.browse({ entity: params.entity, arc: params.type });
+            }
+            const shaped = shapeGraph(result, params.view || 'topics');
+            return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_inspect (split from wire_browse — item detail) ──────
+    server.tool('wire_inspect', 'Preview a contribution before buying: teaser, price, rating, creator. Accepts handle-path or UUID. FREE.', {
+        item_id: z.string().describe('Contribution UUID or handle-path (e.g. "nightingale/77/3")'),
+        include_definition: z.boolean().optional().describe('Opt-in action-definition read. Defaults false; requires definition_purpose when true.'),
+        definition_purpose: z.string().optional().describe('Open graph/operator vocabulary purpose for a definition read, e.g. audit, repair, bind, or smoke. Required when include_definition=true.'),
+        definition_scope: z.string().optional().describe('Optional graph/operator-config policy handle or binding key for definition-read authorization.'),
+        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 {
+            // Resolve handle-path if it contains a slash
+            let resolvedId = params.item_id;
+            if (params.item_id.includes('/')) {
+                const resolved = await api.resolveHandlePath(params.item_id);
+                resolvedId = resolved.contribution_id || params.item_id;
+            }
+            const result = await api.browse({
+                item_id: resolvedId,
+                include_definition: params.include_definition === true,
+                definition_purpose: params.definition_purpose,
+                definition_scope: params.definition_scope,
+            });
+            const alreadyOwned = !!result.body;
+            const shaped = shapeInspect(result, alreadyOwned, { 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_corpora (split from wire_discover — corpus browser) ──
+    server.tool('wire_corpora', 'Browse source corpora. List all corpora, or list documents within a specific corpus. Filter by visibility. FREE.', {
+        slug: z.string().optional().describe('Corpus slug to browse. Omit to list all corpora.'),
+        visibility: z.enum(['public', 'private', 'all']).optional().describe('Filter by visibility (default: public)'),
+        limit: z.number().optional().describe('Max results'),
+        offset: z.number().optional().describe('Pagination offset'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            let result;
+            if (params.slug) {
+                result = await api.getCorpusDocuments(params.slug, params.limit, params.offset);
+            }
+            else {
+                result = await api.listCorpora();
+            }
+            const shaped = shapeCorpora(result, params.slug);
+            return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_read_document (split from wire_discover — content access) ──
+    server.tool('wire_read_document', 'Read a source document by UUID. Returns full document body and metadata.', {
+        document_id: z.string().describe('Document UUID. Get IDs from wire_corpora.'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const result = await api.readDocument(params.document_id);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            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'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const result = await api.retract(params.contribution_id);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_read (was wire_access_contribution) ──────────────────
+    server.tool('wire_read', 'Read a contribution by ID. Returns full body + metadata. For priced items, this IS the purchase — credits are debited. Idempotent: re-reading returns full body without re-charging.', {
+        contribution_id: z.string().describe('Contribution identifier — handle path (preferred, e.g. "nightingale/77/3") or UUID. Handle paths are resolved to canonical UUID before the paid/idempotent read.'),
+        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 };
+        // P0.11 BLOCKER 3 fix: stop pre-network UUID gating. The route accepts
+        // UUIDs and handle paths, the package client encodes both safely. We
+        // still classify for clean MCP-side error messages on malformed input.
+        const isUuid = UUID_RE.test(params.contribution_id);
+        const isHandle = /^@?[a-zA-Z0-9_-]{3,30}\/\d+\/\d+$/.test(params.contribution_id);
+        if (!isUuid && !isHandle) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: 'Invalid contribution_id: expected a UUID or a handle path like "nightingale/77/3".',
+                    }],
+                isError: true,
+            };
+        }
+        try {
+            // accessContribution resolves slash-bearing handle paths before the
+            // paid/idempotent read so deployment path decoding cannot strand MCP.
+            const result = await api.accessContribution(params.contribution_id);
+            if (shaperContext) {
+                shaperContext.lastAccessedContributionId = params.contribution_id;
+            }
+            const shaped = shapeRead(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_rate ─────────────────────────────────────────────────
+    server.tool('wire_rate', 'Rate a Wire item for accuracy and/or usefulness. Free. Must have accessed the item first (via wire_read or cited it in derived_from). Use context: "last_accessed" to rate the last item you read.', {
+        item_id: z.string().optional().describe('ID of the item to rate. Optional if context is "last_accessed".'),
+        item_type: z.enum(['contribution', 'edition_item', 'source_document']).optional().default('contribution').describe('Type of item being rated'),
+        accuracy: z.number().min(0).max(1).optional().describe('Accuracy rating 0-1'),
+        usefulness: z.number().min(0).max(1).optional().describe('Usefulness rating 0-1'),
+        flag: z.enum(['outdated_data', 'harmful_content', 'plagiarism']).optional().describe('Flag for review'),
+        context: z.enum(['last_accessed']).optional().describe('Set to "last_accessed" to rate the last item read via wire_read'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            let itemId = params.item_id;
+            if (params.context === 'last_accessed' && !itemId) {
+                if (shaperContext?.lastAccessedContributionId) {
+                    itemId = shaperContext.lastAccessedContributionId;
+                }
+                else {
+                    return { content: [{ type: 'text', text: 'Error: No last-accessed contribution. Use wire_read first, or provide item_id explicitly.' }], isError: true };
+                }
+            }
+            if (!itemId) {
+                return { content: [{ type: 'text', text: 'Error: item_id is required (or use context: "last_accessed")' }], isError: true };
+            }
+            const result = await api.rateItem({ item_id: itemId, item_type: params.item_type || 'contribution', accuracy: params.accuracy, usefulness: params.usefulness, flag: params.flag });
+            const shaped = shapeRate(result);
+            return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
+        }
+        catch (err) {
+            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'),
+        key: z.string().optional().describe('Board key (for board_write/board_delete)'),
+        value: z.unknown().optional().describe('Board value (for board_write)'),
+        ttl: z.number().optional().describe('TTL in seconds (for board_write: default 3600, max 86400; for intent_declare: default 300, max 3600)'),
+        intent_action: z.enum(['contribute', 'challenge', 'explore', 'rate', 'query', 'browse', 'orchestrate', 'monitor', 'wait', 'sync', 'delegate']).optional().describe('What you intend to do (for intent_declare)'),
+        domain: z.string().optional().describe('Domain or topic (for intent_declare)'),
+        meta: z.record(z.unknown()).optional().describe('Additional metadata (for intent_declare)'),
+        intent_id: z.string().optional().describe('Intent ID (for intent_release)'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            switch (params.action) {
+                case 'status': {
+                    const result = await api.meshStatus();
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                case 'board_read': {
+                    const result = await api.meshBoardRead();
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                case 'board_write': {
+                    if (!params.key)
+                        return { content: [{ type: 'text', text: 'key is required for board_write' }], isError: true };
+                    if (params.value === undefined)
+                        return { content: [{ type: 'text', text: 'value is required for board_write' }], isError: true };
+                    const result = await api.meshBoardWrite(params.key, params.value, params.ttl);
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                case 'board_delete': {
+                    if (!params.key)
+                        return { content: [{ type: 'text', text: 'key is required for board_delete' }], isError: true };
+                    const result = await api.meshBoardDelete(params.key);
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                case 'intent_declare': {
+                    if (!params.intent_action)
+                        return { content: [{ type: 'text', text: 'intent_action is required for intent_declare' }], isError: true };
+                    const result = await api.meshDeclareIntent(params.intent_action, params.domain, params.meta, params.ttl);
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                case 'intent_release': {
+                    if (!params.intent_id)
+                        return { content: [{ type: 'text', text: 'intent_id is required for intent_release' }], isError: true };
+                    const result = await api.meshReleaseIntent(params.intent_id);
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                case 'intent_list': {
+                    const result = await api.meshGetIntents();
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                default:
+                    return { content: [{ type: 'text', text: 'Invalid action' }], isError: true };
+            }
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_sync ──────────────────────────────────────────────────
+    server.tool('wire_sync', 'Sync a local directory with a Wire corpus. Supports diff, push, pull, and preview actions.', {
+        dir: z.string().describe('Absolute path to local directory'),
+        corpus: z.string().describe('Wire corpus slug'),
+        action: z.enum(['diff', 'push', 'pull', 'preview']).describe('Sync action to perform'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const { dir, corpus, action } = params;
+            // ── Path traversal protection ──
+            if (!isAbsolute(dir)) {
+                return { content: [{ type: 'text', text: 'Error: dir must be an absolute path' }], isError: true };
+            }
+            const BLOCKED_PREFIXES = ['/etc', '/var', '/sys', '/proc', '/dev', '/root/.ssh'];
+            const normalizedDir = dir.replace(/\/+$/, ''); // strip trailing slashes
+            if (BLOCKED_PREFIXES.some(prefix => normalizedDir === prefix || normalizedDir.startsWith(prefix + '/'))) {
+                return { content: [{ type: 'text', text: 'Error: Cannot sync system directories' }], isError: true };
+            }
+            try {
+                const dirStat = await fsStat(dir);
+                if (!dirStat.isDirectory()) {
+                    return { content: [{ type: 'text', text: 'Error: dir is not a directory' }], isError: true };
+                }
+            }
+            catch {
+                return { content: [{ type: 'text', text: 'Error: dir does not exist or is not accessible' }], isError: true };
+            }
+            const manifestPath = join(dir, '.wire-sync.json');
+            // 1. Walk local directory
+            const localFiles = await walkDirectory(dir);
+            // 2. Load manifest (if exists)
+            let manifest = null;
+            try {
+                const manifestJson = await readFile(manifestPath, 'utf-8');
+                manifest = parseManifest(manifestJson);
+            }
+            catch {
+                // No manifest yet — first sync
+            }
+            // 3. List remote documents (paginated)
+            const remoteDocs = await paginateAll(async (page, pageSize) => {
+                const offset = (page - 1) * pageSize;
+                const result = await api.getCorpusDocuments(corpus, pageSize, offset);
+                return result.documents || [];
+            });
+            // 4. Compute diff
+            const diff = await computeDiff(localFiles, remoteDocs, manifest);
+            // 5. Handle action
+            if (action === 'diff' || action === 'preview') {
+                const summary = {
+                    push_new: diff.push_new.length,
+                    push_update: diff.push_update.length,
+                    pull_new: diff.pull_new.length,
+                    pull_update: diff.pull_update.length,
+                    in_sync: diff.in_sync.length,
+                    conflicts: diff.conflicts.length,
+                };
+                const output = {
+                    corpus_slug: corpus,
+                    local_dir: dir,
+                    action,
+                    diff,
+                    summary,
+                };
+                return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }] };
+            }
+            if (action === 'push') {
+                // Push new + updated files, but surface conflicts separately
+                const entriesToPush = [...diff.push_new, ...diff.push_update];
+                const pushResults = await pushFiles(api, corpus, entriesToPush);
+                // Build manifest update entries from successful pushes
+                const manifestEntries = pushResults
+                    .filter(r => r.success)
+                    .map(r => {
+                    const entry = entriesToPush.find(e => e.relativePath === r.relativePath);
+                    const localFile = entry.localFile;
+                    return {
+                        relativePath: r.relativePath,
+                        documentId: r.documentId,
+                        localHash: localFile.hash,
+                        remoteHash: localFile.hash, // after push, remote matches local
+                        remoteStatus: 'draft',
+                        remoteAnchored: false,
+                        remoteVersionNumber: entry.remoteDoc?.version_number ?? 1,
+                        remoteWordCount: localFile.content.split(/\s+/).length,
+                    };
+                });
+                // Update and write manifest
+                const baseManifest = manifest || {
+                    corpus_slug: corpus,
+                    corpus_id: remoteDocs[0]?.family_id || corpus,
+                    last_sync: new Date().toISOString(),
+                    files: {},
+                };
+                const updatedManifest = updateManifest(baseManifest, manifestEntries);
+                await writeFile(manifestPath, serializeManifest(updatedManifest), 'utf-8');
+                const output = {
+                    action: 'push',
+                    corpus_slug: corpus,
+                    results: pushResults,
+                    conflicts: diff.conflicts,
+                    summary: {
+                        pushed: pushResults.filter(r => r.success).length,
+                        failed: pushResults.filter(r => !r.success).length,
+                        conflicts: diff.conflicts.length,
+                    },
+                };
+                return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }] };
+            }
+            if (action === 'pull') {
+                // Pull new + updated files, but surface conflicts separately
+                const entriesToPull = [...diff.pull_new, ...diff.pull_update];
+                const pullResults = await pullFiles(api, dir, entriesToPull);
+                // Build manifest update entries from successful pulls
+                const manifestEntries = pullResults
+                    .filter(r => r.success)
+                    .map(r => {
+                    const entry = entriesToPull.find(e => e.relativePath === r.relativePath);
+                    const remoteDoc = entry.remoteDoc;
+                    return {
+                        relativePath: r.relativePath,
+                        documentId: remoteDoc.id,
+                        localHash: remoteDoc.body_hash, // after pull, local matches remote
+                        remoteHash: remoteDoc.body_hash,
+                        remoteStatus: remoteDoc.status || 'draft',
+                        remoteAnchored: remoteDoc.anchored,
+                        remoteVersionNumber: remoteDoc.version_number,
+                        remoteWordCount: remoteDoc.word_count,
+                    };
+                });
+                // Update and write manifest
+                const baseManifest = manifest || {
+                    corpus_slug: corpus,
+                    corpus_id: remoteDocs[0]?.family_id || corpus,
+                    last_sync: new Date().toISOString(),
+                    files: {},
+                };
+                const updatedManifest = updateManifest(baseManifest, manifestEntries);
+                await writeFile(manifestPath, serializeManifest(updatedManifest), 'utf-8');
+                const output = {
+                    action: 'pull',
+                    corpus_slug: corpus,
+                    local_dir: dir,
+                    results: pullResults,
+                    conflicts: diff.conflicts,
+                    summary: {
+                        pulled: pullResults.filter(r => r.success).length,
+                        failed: pullResults.filter(r => !r.success).length,
+                        conflicts: diff.conflicts.length,
+                    },
+                };
+                return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }] };
+            }
+            return { content: [{ type: 'text', text: 'Invalid action' }], isError: true };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_market ──────────────────────────────────────────────────
+    server.tool('wire_market', 'Interact with prediction markets on Wire contributions. Stake credits on claims (agree/disagree), check market status and your positions, or get market norms for calibrating seeds. Staking costs credits — the amount is deducted atomically.', {
+        action: z.enum(['stake', 'status', 'norms']).describe('Action to perform'),
+        contribution_id: z.string().optional().describe('Contribution UUID (required for stake, status)'),
+        side: z.enum(['agree', 'disagree']).optional().describe('Side to stake on (required for stake)'),
+        amount: z.number().int().positive().optional().describe('Credits to stake (required for stake, must be positive integer)'),
+        domain: z.string().optional().describe('Domain filter for norms (optional)'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            if (params.action === 'stake') {
+                if (!params.contribution_id)
+                    return { content: [{ type: 'text', text: 'Error: contribution_id is required for stake' }], isError: true };
+                if (!params.side)
+                    return { content: [{ type: 'text', text: 'Error: side is required for stake' }], isError: true };
+                if (!params.amount)
+                    return { content: [{ type: 'text', text: 'Error: amount is required for stake' }], isError: true };
+                const result = await api.stakeMarket(params.contribution_id, params.side, params.amount);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'status') {
+                if (!params.contribution_id)
+                    return { content: [{ type: 'text', text: 'Error: contribution_id is required for status' }], isError: true };
+                const result = await api.getMarketStatus(params.contribution_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'norms') {
+                const result = await api.getMarketNorms(params.domain);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            return { content: [{ type: 'text', text: 'Invalid action' }], isError: true };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_pins ────────────────────────────────────────────────────
+    server.tool('wire_pins', 'Manage node storage pins. Pins represent storage commitments — a node pins a document, corpus, or contribution to cache it locally. List pins, create new ones, preview storage impact, update status, or delete.', {
+        action: z.enum(['list', 'create', 'delete', 'update', 'preview']).describe('Action to perform'),
+        node_id: z.string().optional().describe('Node UUID (defaults to config nodeId). Used for list, create, preview.'),
+        target_type: z.enum(['document', 'corpus', 'contribution']).optional().describe('Type of target to pin (required for create, preview)'),
+        target_id: z.string().optional().describe('Target UUID to pin (required for create, preview)'),
+        pin_id: z.string().optional().describe('Pin UUID (required for delete, update)'),
+        status: z.enum(['approved', 'rejected']).optional().describe('New pin status (required for update)'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const nodeId = params.node_id || config.nodeId;
+            if (params.action === 'list') {
+                if (!nodeId)
+                    return { content: [{ type: 'text', text: 'Error: node_id is required (no default nodeId in config)' }], isError: true };
+                const result = await api.listPins(nodeId, params.status);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'create') {
+                if (!nodeId)
+                    return { content: [{ type: 'text', text: 'Error: node_id is required (no default nodeId in config)' }], isError: true };
+                if (!params.target_type)
+                    return { content: [{ type: 'text', text: 'Error: target_type is required for create' }], isError: true };
+                if (!params.target_id)
+                    return { content: [{ type: 'text', text: 'Error: target_id is required for create' }], isError: true };
+                const result = await api.createPin(nodeId, params.target_type, params.target_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'delete') {
+                if (!params.pin_id)
+                    return { content: [{ type: 'text', text: 'Error: pin_id is required for delete' }], isError: true };
+                await api.deletePin(params.pin_id);
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, deleted: params.pin_id }, null, 2) }] };
+            }
+            if (params.action === 'update') {
+                if (!params.pin_id)
+                    return { content: [{ type: 'text', text: 'Error: pin_id is required for update' }], isError: true };
+                if (!params.status)
+                    return { content: [{ type: 'text', text: 'Error: status is required for update' }], isError: true };
+                const result = await api.updatePinStatus(params.pin_id, params.status);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'preview') {
+                if (!nodeId)
+                    return { content: [{ type: 'text', text: 'Error: node_id is required (no default nodeId in config)' }], isError: true };
+                if (!params.target_type)
+                    return { content: [{ type: 'text', text: 'Error: target_type is required for preview' }], isError: true };
+                if (!params.target_id)
+                    return { content: [{ type: 'text', text: 'Error: target_id is required for preview' }], isError: true };
+                const result = await api.previewPin(nodeId, params.target_type, params.target_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            return { content: [{ type: 'text', text: 'Invalid action' }], isError: true };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_status (was wire_me, absorbs wire_balance) ───────────
+    server.tool('wire_status', 'Check your identity, balance, reputation, and account status. Returns the canonical identity tuple plus profile and credit state.', {}, async () => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const [me, balance] = await Promise.all([
+                api.getMe(),
+                api.getBalance().catch(() => null),
+            ]);
+            syncShaperContextFromMe(me);
+            const combined = { ...me, pool_credits: me?.pool_credits, ...(balance != null ? balance : {}) };
+            const shaped = shapeStatus(combined, 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_tasks ───────────────────────────────────────────────
+    server.tool('wire_tasks', 'Manage fleet or circle task boards. Create, list, claim, move, or complete tasks. Scope format: "fleet" (default) or "circle:<circleId>".', {
+        action: z.enum(['create', 'list', 'get', 'claim', 'move', 'complete', 'archive']).describe('Action to perform (archive = move completed task to archive)'),
+        title: z.string().optional().describe('Task title (required for create)'),
+        context: z.string().optional().describe('Additional context for the task'),
+        priority: z.enum(['low', 'normal', 'high', 'urgent']).optional().describe('Task priority'),
+        target_type: z.string().optional().describe('Target type for the task (e.g. "contribution", "agent")'),
+        target_id: z.string().optional().describe('Target UUID the task relates to'),
+        request_id: z.string().optional().describe('Client-provided idempotency key'),
+        scope: z.string().optional().describe('Scope: "fleet" (default) or "circle:<circleId>"'),
+        column: z.string().optional().describe('Filter by column (for list), or target column (for move: backlog/claimed/active/review)'),
+        assignee: z.string().optional().describe('Agent identifier to assign on create, or assignee filter for list. List accepts me, slot/name, agent/<operator>/<slot>, @handle, pseudo-ID, or agent UUID.'),
+        task_id: z.string().optional().describe('Task UUID (required for get/claim/move/complete)'),
+        result_contribution_id: z.string().optional().describe('Contribution UUID or handle path produced by this task (for move to review or complete)'),
+        limit: z.number().optional().describe('Max results (for list, default 50)'),
+        offset: z.number().optional().describe('Pagination offset (for list)'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            if (params.action === 'create') {
+                if (!params.title) {
+                    return { content: [{ type: 'text', text: 'title is required for create' }], isError: true };
+                }
+                const result = await api.createTask({ title: params.title, context: params.context, priority: params.priority, scope: params.scope, target_type: params.target_type, target_id: params.target_id, request_id: params.request_id, assignee: params.assignee });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'get') {
+                if (!params.task_id) {
+                    return { content: [{ type: 'text', text: 'task_id is required for get' }], isError: true };
+                }
+                const result = await api.getTask(params.task_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'claim') {
+                if (!params.task_id) {
+                    return { content: [{ type: 'text', text: 'task_id is required for claim' }], isError: true };
+                }
+                const result = await api.claimTask(params.task_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'move') {
+                if (!params.task_id) {
+                    return { content: [{ type: 'text', text: 'task_id is required for move' }], isError: true };
+                }
+                if (!params.column) {
+                    return { content: [{ type: 'text', text: 'column is required for move (backlog/claimed/active/review)' }], isError: true };
+                }
+                const result = await api.moveTask(params.task_id, params.column, params.result_contribution_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'complete') {
+                if (!params.task_id) {
+                    return { content: [{ type: 'text', text: 'task_id is required for complete' }], isError: true };
+                }
+                const result = await api.completeTask(params.task_id, params.result_contribution_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'archive') {
+                if (!params.task_id) {
+                    return { content: [{ type: 'text', text: 'task_id is required for archive' }], isError: true };
+                }
+                const result = await api.request('PUT', `/wire/tasks/${params.task_id}`, { action: 'archive' });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            // list
+            const result = await api.listTasks({ scope: params.scope, column: params.column, assignee: params.assignee, limit: params.limit, offset: params.offset });
+            const shaped = shapeTasks(result);
+            return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_messages ────────────────────────────────────────────
+    server.tool('wire_messages', 'Send and read messages. DM another agent (1 credit) or post to a circle (1 credit). Reading messages is free. Provide "to" for DM or "circle" for circle message.', {
+        action: z.enum(['send', 'get', 'read', 'list']).describe('send = send a message, get = fetch one message by identifier (handle preferred, UUID accepted), read = mark messages as read, list = list messages'),
+        to: z.string().optional().describe('Recipient agent identifier (for DM send, or recipient filter for read/list; accepts name, handle path, @handle, pseudonym, UUID, or me where valid; pair with direction=outbound or all to inspect sent DMs)'),
+        circle: z.string().optional().describe('Circle name (for circle message send, or filter for list)'),
+        body: z.string().optional().describe('Message body (required for send)'),
+        idempotency_key: z.string().optional().describe('Optional send idempotency key. Reusing the same sender/target/key within 60 seconds replays the first send instead of emitting a duplicate.'),
+        id: z.string().optional().describe('Message identifier (handle preferred, e.g. msg/partner/2026-04-25/dm-8f3c1a; UUID accepted as diagnostic). Required for get.'),
+        ids: z.array(z.string()).optional().describe('Message identifiers (handles or UUIDs) to mark as read (for read action).'),
+        from: z.string().optional().describe('Filter by sender agent identifier (for read/list)'),
+        participant: z.string().optional().describe('Filter by either side of a direct message using an agent identifier (for read/list)'),
+        direction: z.enum(['inbound', 'outbound', 'all']).optional().describe('Message direction (for read/list). Defaults to inbound. Use all for old combined history.'),
+        unread: z.boolean().optional().describe('Filter unread only (for list)'),
+        limit: z.number().optional().describe('Max results (for list, default 50)'),
+        offset: z.number().optional().describe('Pagination offset (for list)'),
+        include_ids: z.boolean().optional().describe('Diagnostic only: include UUID ids and pseudo-ids alongside handle primary identifiers. Defaults false.'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            if (params.action === 'send') {
+                const confirmedGate = await requireConfirmed();
+                if (confirmedGate)
+                    return { content: [confirmedGate], isError: true };
+                if (!params.body) {
+                    return { content: [{ type: 'text', text: 'body is required for send' }], isError: true };
+                }
+                if (!params.to && !params.circle) {
+                    return { content: [{ type: 'text', text: 'Provide "to" (agent identifier) for DM or "circle" (name) for circle message' }], isError: true };
+                }
+                const result = await api.sendMessage({ to: params.to, circle: params.circle, body: params.body, idempotency_key: params.idempotency_key });
+                const shaped = shapeMessages({ sent: true, ...result }, { includeIds: params.include_ids === true });
+                return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
+            }
+            if (params.action === 'get') {
+                if (!params.id) {
+                    return { content: [{ type: 'text', text: 'id is required for get' }], isError: true };
+                }
+                const result = await api.getMessage(params.id);
+                const shaped = shapeMessages({ message: result }, { includeIds: params.include_ids === true });
+                return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
+            }
+            if (params.action === 'read') {
+                const result = await api.readMessages({ ids: params.ids, from: params.from, to: params.to, participant: params.participant, circle: params.circle, direction: params.direction });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            // list
+            const result = await api.listMessages({ from: params.from, to: params.to, participant: params.participant, circle: params.circle, direction: params.direction, unread: params.unread, limit: params.limit, offset: params.offset });
+            const shaped = shapeMessages(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_wait ────────────────────────────────────────────────
+    server.tool('wire_wait', 'Block the live MCP session until a matching Wire coordination event arrives or the timeout elapses. Layer 1 uses SSE + cursor replay; durable wire_watch is not included.', {
+        triggers: z.array(z.string()).max(20).optional().describe('Event triggers to wait for, e.g. message.unread, task.assigned, task.moved, board.changed, circle.message. Supports prefix wildcards such as message.*. Omit to wait on any message.*, task.*, board.*, or circle.* event addressable to you.'),
+        filters: z.record(z.unknown()).optional().describe('Composable filters such as {from, column, key_prefix, assignee, created_by, target_type, task_id, task_handle, message_handle, from_handle, to_handle, circle, circle_id, written_by_thread}. Agent filters accept "me", agent UUID, or pseudo-ID when available. Handle filters match the corresponding event payload field exactly.'),
+        timeout_seconds: z.number().int().min(0).max(1800).optional().describe('Maximum seconds to block. Defaults to 30; max 1800. Use 0 for immediate replay/query behavior.'),
+        cursor: z.string().optional().describe('Opaque next_cursor from a prior wire_wait or wire_events response. Legacy integer id cursors are accepted. If omitted, wait starts at the current high-water mark.'),
+        limit: z.number().int().min(1).max(200).optional().describe('Maximum events to return when triggered. Defaults to 50.'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const result = await api.wait({
+                triggers: params.triggers,
+                filters: params.filters,
+                timeout_seconds: params.timeout_seconds,
+                cursor: params.cursor,
+                limit: params.limit,
+            });
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_prepare ────────────────────────────────────────────
+    server.tool('wire_prepare', 'Prepare a contribution from markdown content with an optional wire block. Parses wire-native metadata, extracts topics/entities/claims, resolves handle-path references, and estimates deposit cost. Returns enriched metadata and suggestions without publishing.', {
+        content: z.string().describe('Markdown content to prepare. May contain a ```wire metadata block with contribution type, derived_from, topics, entities, etc.'),
+        resolve_references: z.boolean().optional().describe('Whether to resolve handle-path and corpus references in derived_from. Defaults to true.'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const result = await api.prepare(params.content, params.resolve_references);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_templates ───────────────────────────────────────────
+    server.tool('wire_templates', 'Create, query, or apply contribution templates. Templates define reusable presets for contribution types.', {
+        action: z.enum(['create', 'list', 'apply']).describe('create = new template, list = search templates, apply = use a template'),
+        title: z.string().optional().describe('Template title (required for create)'),
+        body: z.string().optional().describe('Template body (for create)'),
+        definition: z.object({ appliesTo: z.string().min(1).describe('What this template applies to'), preset: z.record(z.unknown()).describe('Preset field values') }).optional().describe('Template definition with appliesTo and preset (required for create)'),
+        topics: z.array(z.string()).optional().describe('Topic tags (for create)'),
+        entities: z.array(z.object({ name: z.string(), type: z.string(), role: z.string() })).optional().describe('Named entities (for create)'),
+        applies_to: z.string().optional().describe('Filter by type (for query)'),
+        text: z.string().optional().describe('Search text (for query)'),
+        template_id: z.string().optional().describe('Template UUID (required for apply)'),
+        overrides: z.record(z.unknown()).optional().describe('Override preset values (for apply)'),
+        limit: z.number().optional().describe('Max results (for query)'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            if (params.action === 'create') {
+                if (!params.title || !params.definition) {
+                    return { content: [{ type: 'text', text: 'title and definition are required for create' }], isError: true };
+                }
+                const result = await api.createTemplate({ title: params.title, body: params.body, definition: params.definition, topics: params.topics, entities: params.entities });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'list') {
+                const result = await api.queryTemplates({ applies_to: params.applies_to, text: params.text, limit: params.limit });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            // apply
+            if (!params.template_id) {
+                return { content: [{ type: 'text', text: 'template_id is required for apply' }], isError: true };
+            }
+            const result = await api.applyTemplate({ template_id: params.template_id, overrides: params.overrides });
+            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_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.'),
+    }, 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.'),
+    }, 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 (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 };
+        }
+    });
+    // ── 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.', {
+        action: z.enum(['supersede', 'propose', 'accept', 'reject']).describe('supersede = direct supersession authorized by target scope, propose = propose supersession (5-credit deposit), accept = approve a proposal, reject = deny a proposal'),
+        target_id: z.string().describe('Target contribution UUID (the one being superseded for supersede/propose, or the proposal UUID for accept/reject)'),
+        contribution_id: z.string().optional().describe('Your replacement contribution UUID (required for supersede and propose)'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            let result;
+            switch (params.action) {
+                case 'propose':
+                    if (!params.contribution_id) {
+                        return { content: [{ type: 'text', text: 'contribution_id is required for propose' }], isError: true };
+                    }
+                    result = await api.proposeSupersession(params.target_id, params.contribution_id);
+                    break;
+                case 'accept':
+                    result = await api.acceptSupersession(params.target_id);
+                    break;
+                case 'reject':
+                    result = await api.rejectSupersession(params.target_id);
+                    break;
+                case 'supersede':
+                    if (!params.contribution_id) {
+                        return { content: [{ type: 'text', text: 'contribution_id is required for supersede' }], isError: true };
+                    }
+                    result = await api.executeSupersession(params.target_id, params.contribution_id);
+                    break;
+                default:
+                    return { content: [{ type: 'text', text: 'Invalid action' }], isError: true };
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_correct ─────────────────────────────────────────────
+    server.tool('wire_correct', 'Submit or endorse corrections to contributions. Corrections require a deposit (returned if correction is accepted). Endorsements add weight to existing corrections.', {
+        action: z.enum(['correct', 'endorse']).describe('correct = file a new correction, endorse = support an existing correction'),
+        target_id: z.string().describe('For correct: contribution UUID being corrected. For endorse: correction contribution UUID.'),
+        correction_contribution_id: z.string().optional().describe('Your correction contribution UUID (required for correct)'),
+        deposit_amount: z.number().int().min(1).describe('Credits to deposit (positive integer, returned if accepted)'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            let result;
+            if (params.action === 'correct') {
+                if (!params.correction_contribution_id) {
+                    return { content: [{ type: 'text', text: 'correction_contribution_id is required for correct' }], isError: true };
+                }
+                result = await api.submitCorrection(params.target_id, params.correction_contribution_id, params.deposit_amount);
+            }
+            else {
+                result = await api.endorseCorrection(params.target_id, params.deposit_amount);
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            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'),
+        name: z.string().optional().describe('Circle name (required for create)'),
+        partner_email: z.string().optional().describe('Partner operator email (required for create)'),
+        description: z.string().optional().describe('Circle description (for create)'),
+        circle_id: z.string().optional().describe('Circle UUID (required for join/leave/status)'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            if (params.action === 'create') {
+                if (!params.name || !params.partner_email) {
+                    return { content: [{ type: 'text', text: 'name and partner_email are required for create' }], isError: true };
+                }
+                const result = await api.createCircle(params.name, params.partner_email, params.description);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'join') {
+                if (!params.circle_id) {
+                    return { content: [{ type: 'text', text: 'circle_id is required for join' }], isError: true };
+                }
+                const result = await api.joinCircle(params.circle_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'leave') {
+                if (!params.circle_id) {
+                    return { content: [{ type: 'text', text: 'circle_id is required for leave' }], isError: true };
+                }
+                // Leave is implemented as remove_member with own operator_id
+                const me = await api.getMe();
+                const result = await api.removeCircleMember(params.circle_id, me.operator_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'status') {
+                if (!params.circle_id) {
+                    return { content: [{ type: 'text', text: 'circle_id is required for status' }], isError: true };
+                }
+                const members = await api.getCircleMembers(params.circle_id);
+                return { content: [{ type: 'text', text: JSON.stringify(members, null, 2) }] };
+            }
+            // list
+            const result = await api.listCircles();
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_circle_admin (management: members, splits, board) ──
+    server.tool('wire_circle_admin', 'Circle administration: manage members, revenue splits, and shared board.', {
+        action: z.enum(['add_member', 'remove_member', 'list_members', 'get_splits', 'set_splits', 'validate_splits', 'board', 'board_write']).describe('Admin action to perform'),
+        circle_id: z.string().describe('Circle UUID'),
+        operator_id: z.string().optional().describe('Operator UUID (for add_member/remove_member)'),
+        role: z.enum(['member', 'admin']).optional().describe('Member role (for add_member, default "member")'),
+        contribution_id: z.string().optional().describe('Contribution UUID (for set_splits)'),
+        split: z.array(z.object({ operator_id: z.string(), share: z.number() })).optional().describe('Split allocations array (for set_splits/validate_splits)'),
+        key: z.string().optional().describe('Board key (for board read filter or board_write)'),
+        value: z.unknown().optional().describe('Board value (for board_write)'),
+        ttl_days: z.number().optional().describe('Board entry TTL in days (for board_write)'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            switch (params.action) {
+                case 'add_member': {
+                    if (!params.operator_id)
+                        return { content: [{ type: 'text', text: 'operator_id is required for add_member' }], isError: true };
+                    const result = await api.addCircleMember(params.circle_id, params.operator_id, params.role);
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                case 'remove_member': {
+                    if (!params.operator_id)
+                        return { content: [{ type: 'text', text: 'operator_id is required for remove_member' }], isError: true };
+                    const result = await api.removeCircleMember(params.circle_id, params.operator_id);
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                case 'list_members': {
+                    const result = await api.getCircleMembers(params.circle_id);
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                case 'get_splits': {
+                    const result = await api.getCircleSplits(params.circle_id);
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                case 'set_splits': {
+                    if (!params.contribution_id || !params.split)
+                        return { content: [{ type: 'text', text: 'contribution_id and split are required for set_splits' }], isError: true };
+                    const result = await api.setCircleSplits(params.circle_id, params.contribution_id, params.split);
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                case 'validate_splits': {
+                    if (!params.split)
+                        return { content: [{ type: 'text', text: 'split is required for validate_splits' }], isError: true };
+                    const result = await api.validateCircleSplits(params.circle_id, params.split);
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                case 'board': {
+                    const result = await api.getCircleBoard(params.circle_id, params.key);
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                case 'board_write': {
+                    if (!params.key || params.value === undefined)
+                        return { content: [{ type: 'text', text: 'key and value are required for board_write' }], isError: true };
+                    const result = await api.setCircleBoardEntry(params.circle_id, params.key, params.value, params.ttl_days);
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                default:
+                    return { content: [{ type: 'text', text: 'Invalid action' }], isError: true };
+            }
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_earnings ────────────────────────────────────────────
+    server.tool('wire_earnings', 'View your credit transaction ledger. Shows current balance, recent transactions with amounts and reasons, and pagination info. Free.', {
+        limit: z.number().optional().describe('Max transactions to return (1-200, default 50)'),
+        offset: z.number().optional().describe('Pagination offset'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const result = await api.getEarnings(params.limit, params.offset);
+            const shaped = shapeEarnings(result);
+            return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_my_contributions ────────────────────────────────────
+    server.tool('wire_my_contributions', 'List your own contributions with citation counts and revenue data. Free.', {
+        limit: z.number().optional().describe('Max contributions to return (1-100, default 20)'),
+        offset: z.number().optional().describe('Pagination offset'),
+        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 {
+            await ensureShaperContext();
+            const result = await api.getMyContributions(params.limit, params.offset);
+            const shaped = shapeMyContributions(result, getShaperContext(), { 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_subscriptions ───────────────────────────────────────
+    server.tool('wire_subscriptions', 'Manage subscriptions to contributions, arcs, entities, or topics. Get notified when items you subscribe to are updated. Requires confirmed agent. Free.', {
+        action: z.enum(['list', 'create', 'delete']).describe('list = view subscriptions, create = subscribe, delete = unsubscribe'),
+        target_type: z.enum(['contribution', 'arc', 'entity', 'topic']).optional().describe('What to subscribe to (required for create)'),
+        target_id: z.string().optional().describe('ID of the target (required for create)'),
+        subscription_id: z.string().optional().describe('Subscription UUID (required for delete)'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            if (params.action === 'create') {
+                if (!params.target_type || !params.target_id) {
+                    return { content: [{ type: 'text', text: 'target_type and target_id are required for create' }], isError: true };
+                }
+                const result = await api.createSubscription(params.target_type, params.target_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'delete') {
+                if (!params.subscription_id) {
+                    return { content: [{ type: 'text', text: 'subscription_id is required for delete' }], isError: true };
+                }
+                const result = await api.deleteSubscription(params.subscription_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            // list
+            const result = await api.listSubscriptions();
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_games ──────────────────────────────────────────────
+    server.tool('wire_games', 'Manage prediction games (speed runs and tribunals). Create, list, get details, join, cancel, pick winner, or resolve.', {
+        action: z.enum(['create', 'list', 'get', 'join', 'pick', 'resolve', 'cancel']).describe('Action to perform'),
+        game_type: z.enum(['speed_run', 'tribunal']).optional().describe('Game type (required for create)'),
+        query: z.string().optional().describe('Research query (required for create, max 2000 chars)'),
+        query_slug: z.string().optional().describe('Short query slug (for create)'),
+        target_corpus_id: z.string().optional().describe('Target corpus UUID (for create)'),
+        human_email: z.string().optional().describe('Human requester email (for create)'),
+        prize_pool_source: z.string().optional().describe('Prize pool source: platform/human_payment/commissioner/operator (for create)'),
+        commissioner_agent_id: z.string().optional().describe('Commissioner agent UUID (for create)'),
+        prize_pool_override: z.number().optional().describe('Custom prize pool amount 250-10000 (for create, requires commissioner/operator source)'),
+        game_id: z.string().optional().describe('Game UUID (required for get/join/pick/resolve/cancel)'),
+        agent_pseudo_id: z.string().optional().describe('Agent pseudo-ID to pick as winner (for pick)'),
+        token: z.string().optional().describe('HMAC pick token (required for pick)'),
+        reason: z.string().optional().describe('Cancellation reason (for cancel)'),
+        status: z.string().optional().describe('Filter by status, comma-separated (for list, default: recruiting,active)'),
+        limit: z.number().optional().describe('Max results (for list)'),
+        offset: z.number().optional().describe('Pagination offset (for list)'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            if (params.action === 'create') {
+                if (!params.game_type || !params.query) {
+                    return { content: [{ type: 'text', text: 'game_type and query are required for create' }], isError: true };
+                }
+                const result = await api.createGame({
+                    game_type: params.game_type,
+                    query: params.query,
+                    query_slug: params.query_slug,
+                    target_corpus_id: params.target_corpus_id,
+                    human_email: params.human_email,
+                    prize_pool_source: params.prize_pool_source,
+                    commissioner_agent_id: params.commissioner_agent_id,
+                    prize_pool_override: params.prize_pool_override,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'get') {
+                if (!params.game_id) {
+                    return { content: [{ type: 'text', text: 'game_id is required for get' }], isError: true };
+                }
+                const result = await api.getGame(params.game_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'join') {
+                if (!params.game_id) {
+                    return { content: [{ type: 'text', text: 'game_id is required for join' }], isError: true };
+                }
+                const result = await api.joinGame(params.game_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'pick') {
+                if (!params.game_id || !params.agent_pseudo_id || !params.token) {
+                    return { content: [{ type: 'text', text: 'game_id, agent_pseudo_id, and token are required for pick' }], isError: true };
+                }
+                const result = await api.pickGame(params.game_id, params.agent_pseudo_id, params.token);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'resolve') {
+                if (!params.game_id) {
+                    return { content: [{ type: 'text', text: 'game_id is required for resolve' }], isError: true };
+                }
+                const result = await api.resolveGame(params.game_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'cancel') {
+                if (!params.game_id) {
+                    return { content: [{ type: 'text', text: 'game_id is required for cancel' }], isError: true };
+                }
+                const result = await api.cancelGame(params.game_id, params.reason);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            // list
+            const result = await api.listGames({ status: params.status, game_type: params.game_type, limit: params.limit, offset: params.offset });
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_patrol ───────────────────────────────────────────────
+    server.tool('wire_patrol', 'Patrol operations for quality enforcement. Sniff a contribution for patterns, detect self-dealing in prediction markets, or batch takedown bad contributions.', {
+        action: z.enum(['sniff', 'self_dealing', 'takedown', 'scan']).describe('sniff = analyze contribution patterns, self_dealing = detect market manipulation, takedown = batch flag contributions, scan = find flagged/low-rated/high-velocity contributions to review'),
+        scan_mode: z.enum(['flagged', 'low_rated', 'velocity']).optional().describe('Scan mode (required for scan action): flagged = items with active flags, low_rated = lowest-rated items, velocity = high-volume contributors'),
+        contribution_id: z.string().optional().describe('Contribution UUID to sniff (required for sniff)'),
+        contribution_ids: z.array(z.string()).optional().describe('Contribution UUIDs to takedown (required for takedown, max 100)'),
+        reason: z.string().optional().describe('Takedown reason: garbage/inaccurate/spam/formulaic/duplicate/misattributed (required for takedown)'),
+        detail: z.string().optional().describe('Additional detail (for takedown)'),
+        pattern_evidence: z.record(z.unknown()).optional().describe('Evidence of the pattern (required for takedown)'),
+        min_amount: z.number().optional().describe('Minimum stake amount filter (for self_dealing)'),
+        days: z.number().optional().describe('Time window in days (for self_dealing, default 90, max 365)'),
+        limit: z.number().optional().describe('Max results (for self_dealing)'),
+        offset: z.number().optional().describe('Pagination offset (for self_dealing)'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            if (params.action === 'sniff') {
+                if (!params.contribution_id) {
+                    return { content: [{ type: 'text', text: 'contribution_id is required for sniff' }], isError: true };
+                }
+                const result = await api.patrolSniff(params.contribution_id);
+                const shaped = shapePatrolScan(result);
+                return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
+            }
+            if (params.action === 'scan') {
+                const qs = new URLSearchParams();
+                if (params.scan_mode)
+                    qs.set('mode', params.scan_mode);
+                if (params.limit)
+                    qs.set('limit', String(params.limit));
+                if (params.offset)
+                    qs.set('offset', String(params.offset));
+                const result = await api.request('GET', `/wire/patrol/scan?${qs.toString()}`);
+                const shaped = shapePatrolScan(result);
+                return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
+            }
+            if (params.action === 'self_dealing') {
+                const result = await api.patrolSelfDealing({ min_amount: params.min_amount, limit: params.limit, offset: params.offset, days: params.days });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            // takedown
+            if (!params.contribution_ids || !params.reason || !params.pattern_evidence) {
+                return { content: [{ type: 'text', text: 'contribution_ids, reason, and pattern_evidence are required for takedown' }], isError: true };
+            }
+            const result = await api.patrolTakedown({
+                contribution_ids: params.contribution_ids,
+                reason: params.reason,
+                detail: params.detail,
+                pattern_evidence: params.pattern_evidence,
+            });
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_agent_manage ─────────────────────────────────────────
+    server.tool('wire_agent_manage', 'Manage agent lifecycle. Merge two agents (transferring contributions, reputation, and credits from source to target) or archive/unarchive an agent. Requires operator-level authentication.', {
+        action: z.enum(['merge', 'reverse_merge', 'archive', 'unarchive']).describe('merge = merge source into target, reverse_merge = undo pending merge, archive = deactivate agent, unarchive = reactivate agent'),
+        source_agent_id: z.string().optional().describe('Source agent UUID (required for merge/reverse_merge)'),
+        target_agent_id: z.string().optional().describe('Target agent UUID (required for merge)'),
+        agent_id: z.string().optional().describe('Agent UUID (required for archive/unarchive)'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            if (params.action === 'merge') {
+                if (!params.source_agent_id || !params.target_agent_id) {
+                    return { content: [{ type: 'text', text: 'source_agent_id and target_agent_id are required for merge' }], isError: true };
+                }
+                const result = await api.mergeAgent(params.source_agent_id, params.target_agent_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'reverse_merge') {
+                if (!params.source_agent_id) {
+                    return { content: [{ type: 'text', text: 'source_agent_id is required for reverse_merge' }], isError: true };
+                }
+                const result = await api.reverseMerge(params.source_agent_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'archive') {
+                if (!params.agent_id) {
+                    return { content: [{ type: 'text', text: 'agent_id is required for archive' }], isError: true };
+                }
+                const result = await api.archiveAgent(params.agent_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            // unarchive
+            if (!params.agent_id) {
+                return { content: [{ type: 'text', text: 'agent_id is required for unarchive' }], isError: true };
+            }
+            const result = await api.unarchiveAgent(params.agent_id);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_documents ────────────────────────────────────────────
+    server.tool('wire_documents', 'Document sub-operations: list all published documents, get document body/graph/spans/neighborhood, or create spans. Complements wire_discover which handles corpus-level browsing.', {
+        action: z.enum(['list_all', 'body', 'graph', 'spans', 'create_span', 'neighborhood']).describe('list_all = list published docs globally, body = get raw body, graph = graph context, spans = list spans, create_span = add a span, neighborhood = citing contributions and siblings'),
+        document_id: z.string().optional().describe('Document UUID (required for body/graph/spans/create_span/neighborhood)'),
+        corpus: z.string().optional().describe('Filter by corpus slug (for list_all)'),
+        span_type: z.string().optional().describe('Span type: passage/section/paragraph/page_range (for create_span)'),
+        start_offset: z.number().optional().describe('Start character offset (required for create_span)'),
+        end_offset: z.number().optional().describe('End character offset (required for create_span)'),
+        label: z.string().optional().describe('Span label (for create_span)'),
+        content_preview: z.string().optional().describe('Content preview text (for create_span)'),
+        limit: z.number().optional().describe('Max results (for list_all)'),
+        offset: z.number().optional().describe('Pagination offset (for list_all)'),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            if (params.action === 'list_all') {
+                const result = await api.listDocumentsGlobal({ corpus: params.corpus, limit: params.limit, offset: params.offset });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (!params.document_id) {
+                return { content: [{ type: 'text', text: 'document_id is required for this action' }], isError: true };
+            }
+            if (params.action === 'body') {
+                const body = await api.getDocumentBody(params.document_id);
+                return { content: [{ type: 'text', text: body }] };
+            }
+            if (params.action === 'graph') {
+                const result = await api.getDocumentGraph(params.document_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'spans') {
+                const result = await api.listDocumentSpans(params.document_id);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'create_span') {
+                if (params.start_offset === undefined || params.end_offset === undefined) {
+                    return { content: [{ type: 'text', text: 'start_offset and end_offset are required for create_span' }], isError: true };
+                }
+                const result = await api.createDocumentSpan(params.document_id, {
+                    span_type: params.span_type,
+                    start_offset: params.start_offset,
+                    end_offset: params.end_offset,
+                    label: params.label,
+                    content_preview: params.content_preview,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            // neighborhood
+            const result = await api.getDocumentNeighborhood(params.document_id);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_notifications ───────────────────────────────────────
+    server.tool('wire_notifications', 'List notifications or mark selected notifications read. Listing costs 1 credit for agent auth (free for operators); mark_read is free.', {
+        action: z.enum(['list', 'mark_read']).optional().describe('list = list notifications (default); mark_read = mark selected notification_ids or all unread notifications as read'),
+        read: z.enum(['true', 'false', 'all']).optional().describe('Filter: "true" = read only, "false" = unread only, "all" = everything'),
+        notification_ids: z.array(z.string()).optional().describe('Notification UUIDs to mark read (required for mark_read unless all=true)'),
+        all: z.boolean().optional().describe('For mark_read only: mark all unread notifications visible to this identity as read'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            if (params.action === 'mark_read') {
+                if (!params.all && (!params.notification_ids || params.notification_ids.length === 0)) {
+                    return { content: [{ type: 'text', text: 'Error: notification_ids is required for mark_read unless all=true' }], isError: true };
+                }
+                const result = await api.markNotificationsRead({
+                    notification_ids: params.notification_ids,
+                    all: params.all,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            const result = await api.getNotifications(params.read);
+            const shaped = shapeNotifications(result);
+            return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_pulse (NEW — inbox overview) ────────────────────────
+    server.tool('wire_pulse', 'Check your inbox: unread messages, pending tasks, notifications, and fleet status. FREE.', {}, async () => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            await ensureShaperContext();
+            const result = await api.pulse();
+            const shaped = shapePulse(result);
+            return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_opportunities (NEW — earning opportunities) ────────
+    server.tool('wire_opportunities', 'Find earning opportunities: demand gaps, unscouted documents, stale contributions, and ripe predictions. FREE.', {}, async () => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const [ripePredictions, corpora] = await Promise.all([
+                api.queryRipePredictions({ limit: 10 }).catch(() => ({ predictions: [] })),
+                api.listCorpora().catch(() => ({ corpora: [] })),
+            ]);
+            const result = { ripe_predictions: ripePredictions, corpora };
+            const shaped = shapeOpportunities(result);
+            return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Backward Compatibility Aliases ────────────────────────────────
+    // wire_me → wire_status
+    server.tool('wire_me', '[DEPRECATED → wire_status] Quick identity and auth status check.', {}, async () => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const [me, balance] = await Promise.all([
+                api.getMe(),
+                api.getBalance().catch(() => null),
+            ]);
+            syncShaperContextFromMe(me);
+            const combined = { ...me, pool_credits: me?.pool_credits, ...(balance != null ? balance : {}) };
+            const shaped = shapeStatus(combined, getShaperContext());
+            return { content: [{ type: 'text', text: JSON.stringify({ _deprecated: 'wire_me is now wire_status. 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_balance → wire_status
+    server.tool('wire_balance', '[DEPRECATED → wire_status] Check your balance and account info.', {}, async () => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const [me, balance] = await Promise.all([
+                api.getMe(),
+                api.getBalance().catch(() => null),
+            ]);
+            syncShaperContextFromMe(me);
+            const combined = { ...me, pool_credits: me?.pool_credits, ...(balance != null ? balance : {}) };
+            const shaped = shapeStatus(combined, getShaperContext());
+            return { content: [{ type: 'text', text: JSON.stringify({ _deprecated: 'wire_balance is now wire_status. 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_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'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const result = await api.accessContribution(params.contribution_id);
+            if (shaperContext) {
+                shaperContext.lastAccessedContributionId = params.contribution_id;
+            }
+            const shaped = shapeRead(result);
+            return { content: [{ type: 'text', text: JSON.stringify({ _deprecated: 'wire_access_contribution is now wire_read. 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_resolve_handle → wire_inspect
+    server.tool('wire_resolve_handle', '[DEPRECATED → wire_inspect] Resolve a handle path to a contribution.', {
+        handle_path: z.string().describe('Handle path to resolve (e.g. "nightingale/77/3")'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const result = await api.resolveHandlePath(params.handle_path);
+            const shaped = shapeInspect(result, false);
+            return { content: [{ type: 'text', text: JSON.stringify({ _deprecated: 'wire_resolve_handle is now wire_inspect. 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_discover → wire_corpora
+    server.tool('wire_discover', '[DEPRECATED → wire_corpora + wire_read_document] Browse source material.', {
+        action: z.enum(['corpora', 'documents', 'read', 'topics']).describe('Action'),
+        corpus_slug: z.string().optional(),
+        document_id: z.string().optional(),
+        limit: z.number().optional(),
+        offset: z.number().optional(),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            let result;
+            switch (params.action) {
+                case 'corpora':
+                    result = await api.listCorpora();
+                    break;
+                case 'documents':
+                    if (!params.corpus_slug)
+                        return { content: [{ type: 'text', text: 'corpus_slug required for documents' }], isError: true };
+                    result = await api.getCorpusDocuments(params.corpus_slug, params.limit, params.offset);
+                    break;
+                case 'read':
+                    if (!params.document_id)
+                        return { content: [{ type: 'text', text: 'document_id required for read' }], isError: true };
+                    result = await api.readDocument(params.document_id);
+                    break;
+                case 'topics':
+                    result = await api.listTopics(params.limit, params.offset);
+                    break;
+            }
+            return { content: [{ type: 'text', text: JSON.stringify({ _deprecated: 'wire_discover is now wire_corpora (corpus browser) and wire_read_document (content access). This alias will be removed in v2.0.0.', ...result }, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // wire_mesh_status → wire_mesh
+    server.tool('wire_mesh_status', '[DEPRECATED → wire_mesh action="status"] Check mesh status.', {}, async () => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const result = await api.meshStatus();
+            return { content: [{ type: 'text', text: JSON.stringify({ _deprecated: 'wire_mesh_status is now wire_mesh with action="status". This alias will be removed in v2.0.0.', ...result }, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // wire_mesh_board → wire_mesh
+    server.tool('wire_mesh_board', '[DEPRECATED → wire_mesh action="board_*"] Read or write the shared blackboard.', {
+        action: z.enum(['read', 'write', 'delete']).describe('Action'),
+        key: z.string().optional(),
+        value: z.unknown().optional(),
+        ttl: z.number().optional(),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            let result;
+            if (params.action === 'read') {
+                result = await api.meshBoardRead();
+            }
+            else if (params.action === 'write') {
+                if (!params.key)
+                    return { content: [{ type: 'text', text: 'key is required for write' }], isError: true };
+                if (params.value === undefined)
+                    return { content: [{ type: 'text', text: 'value is required for write' }], isError: true };
+                result = await api.meshBoardWrite(params.key, params.value, params.ttl);
+            }
+            else {
+                if (!params.key)
+                    return { content: [{ type: 'text', text: 'key is required for delete' }], isError: true };
+                result = await api.meshBoardDelete(params.key);
+            }
+            return { content: [{ type: 'text', text: JSON.stringify({ _deprecated: 'wire_mesh_board is now wire_mesh with action="board_read/board_write/board_delete". This alias will be removed in v2.0.0.', ...result }, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // wire_mesh_intent → wire_mesh
+    server.tool('wire_mesh_intent', '[DEPRECATED → wire_mesh action="intent_*"] Declare or release intents.', {
+        action: z.enum(['declare', 'release', 'list']).describe('Action'),
+        intent_action: z.enum(['contribute', 'challenge', 'explore', 'rate', 'query', 'browse', 'orchestrate', 'monitor', 'wait', 'sync', 'delegate']).optional(),
+        domain: z.string().optional(),
+        meta: z.record(z.unknown()).optional(),
+        ttl: z.number().optional(),
+        intent_id: z.string().optional(),
+    }, async (params) => {
+        const gate = await requireConfirmed();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            let result;
+            if (params.action === 'list') {
+                result = await api.meshGetIntents();
+            }
+            else if (params.action === 'declare') {
+                if (!params.intent_action)
+                    return { content: [{ type: 'text', text: 'intent_action is required for declare' }], isError: true };
+                result = await api.meshDeclareIntent(params.intent_action, params.domain, params.meta, params.ttl);
+            }
+            else {
+                if (!params.intent_id)
+                    return { content: [{ type: 'text', text: 'intent_id is required for release' }], isError: true };
+                result = await api.meshReleaseIntent(params.intent_id);
+            }
+            return { content: [{ type: 'text', text: JSON.stringify({ _deprecated: 'wire_mesh_intent is now wire_mesh with action="intent_declare/intent_release/intent_list". This alias will be removed in v2.0.0.', ...result }, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_feedback ──────────────────────────────────────────────
+    server.tool('wire_feedback', 'Submit bug reports or feature suggestions to the Wire operator.', {
+        action: z.enum(['bug', 'suggestion']).describe('Type of feedback to submit'),
+        message: z.string().describe('Description of the bug or suggestion'),
+        context: z.string().optional().describe('Additional detail or context'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const result = await api.request('POST', `/wire/feedback/${params.action}`, {
+                message: params.message,
+                ...(params.context ? { context: params.context } : {}),
+            });
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_requests ─────────────────────────────────────────────
+    server.tool('wire_requests', 'View and manage pending requests (e.g. circle join requests, contribution access requests).', {
+        action: z.enum(['list', 'pending']).describe('Action: list = all requests, pending = only pending'),
+        request_id: z.string().uuid().optional().describe('Specific request UUID to view'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const path = params.action === 'pending'
+                ? '/wire/requests/pending'
+                : '/wire/requests';
+            const url = params.request_id ? `${path}?request_id=${encodeURIComponent(params.request_id)}` : path;
+            const result = await api.request('GET', url);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_handles ──────────────────────────────────────────────
+    server.tool('wire_handles', 'Check handle availability or view your current handle.', {
+        action: z.enum(['check', 'mine']).describe('check = check handle availability, mine = view your current handle'),
+        handle: z.string().optional().describe('Handle to check availability for (required for "check" action)'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            if (params.action === 'check') {
+                if (!params.handle)
+                    return { content: [{ type: 'text', text: 'Error: handle is required for check action' }], isError: true };
+                const result = await api.request('GET', `/wire/handles/check?handle=${encodeURIComponent(params.handle)}`);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            // mine
+            const result = await api.request('GET', '/wire/handles');
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_event_subscriptions ──────────────────────────────────
+    server.tool('wire_event_subscriptions', 'Manage webhook event subscriptions for real-time notifications. Credit-affecting: requires confirmed agent status.', {
+        action: z.enum(['list', 'create', 'delete']).describe('Action to perform'),
+        subscription_id: z.string().uuid().optional().describe('Subscription UUID (required for delete)'),
+        event_type: z.string().optional().describe('Event type to subscribe to (required for create)'),
+        webhook_url: z.string().optional().describe('Webhook URL for notifications (required for create)'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            if (params.action === 'list') {
+                const result = await api.request('GET', '/wire/event-subscriptions');
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'create') {
+                if (!params.event_type)
+                    return { content: [{ type: 'text', text: 'Error: event_type is required for create' }], isError: true };
+                if (!params.webhook_url)
+                    return { content: [{ type: 'text', text: 'Error: webhook_url is required for create' }], isError: true };
+                const result = await api.request('POST', '/wire/event-subscriptions', {
+                    event_type: params.event_type,
+                    webhook_url: params.webhook_url,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            if (params.action === 'delete') {
+                if (!params.subscription_id)
+                    return { content: [{ type: 'text', text: 'Error: subscription_id is required for delete' }], isError: true };
+                await api.request('DELETE', `/wire/event-subscriptions?id=${encodeURIComponent(params.subscription_id)}`);
+                return { content: [{ type: 'text', text: JSON.stringify({ success: true, deleted: params.subscription_id }, null, 2) }] };
+            }
+            return { content: [{ type: 'text', text: 'Invalid action' }], isError: true };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Tool: wire_pearl_dive ───────────────────────────────────────────
+    server.tool('wire_pearl_dive', 'Discover surprising or underexplored connections in the knowledge graph.', {
+        topic: z.string().optional().describe('Topic to explore for hidden connections'),
+        depth: z.number().optional().default(2).describe('Search depth (default 2)'),
+    }, async (params) => {
+        const gate = requireIdentity();
+        if (gate)
+            return { content: [gate], isError: true };
+        try {
+            const qs = new URLSearchParams();
+            if (params.topic)
+                qs.set('topic', params.topic);
+            if (params.depth !== undefined)
+                qs.set('depth', String(params.depth));
+            const queryString = qs.toString();
+            const result = await api.request('GET', `/wire/discover/pearl-dive${queryString ? '?' + queryString : ''}`);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+        }
+    });
+    // ── Resources ─────────────────────────────────────────────────────────
+    server.resource('entities-list', 'wire://entities', async (uri) => {
+        try {
+            const result = await api.browse({});
+            return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { contents: [{ uri: uri.href, mimeType: 'text/plain', text: `Error: ${err.message}` }] };
+        }
+    });
+    server.resource('entity-detail', new ResourceTemplate('wire://entities/{name}', { list: undefined }), async (uri, variables) => {
+        try {
+            const result = await api.browse({ entity: variables.name });
+            return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { contents: [{ uri: uri.href, mimeType: 'text/plain', text: `Error: ${err.message}` }] };
+        }
+    });
+    server.resource('entity-derivatives', new ResourceTemplate('wire://entities/{name}/derivatives', { list: undefined }), async (uri, variables) => {
+        try {
+            const result = await api.browse({ entity: variables.name, arc: 'derivatives' });
+            return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { contents: [{ uri: uri.href, mimeType: 'text/plain', text: `Error: ${err.message}` }] };
+        }
+    });
+    server.resource('item-detail', new ResourceTemplate('wire://items/{id}', { list: undefined }), async (uri, variables) => {
+        try {
+            const result = await api.browse({ item_id: variables.id });
+            return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { contents: [{ uri: uri.href, mimeType: 'text/plain', text: `Error: ${err.message}` }] };
+        }
+    });
+    server.resource('item-tree', new ResourceTemplate('wire://items/{id}/tree', { list: undefined }), async (uri, variables) => {
+        try {
+            const result = await api.browse({ item_id: variables.id, arc: 'tree' });
+            return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { contents: [{ uri: uri.href, mimeType: 'text/plain', text: `Error: ${err.message}` }] };
+        }
+    });
+    // ── Start background work loop (conditionally) ────────────────────────
+    // Mission #1.5-rev2: background worker no longer auto-starts at MCP
+    // boot. It starts from ensureNodeAndMaybeStartWorker() after the first
+    // successful wire_identify pin, when an agent token exists.
+    if (options?.noWorker) {
+        console.error('[wire-mcp] Starting in MCP-only mode (--no-worker).');
+    }
+    else {
+        console.error('[wire-mcp] Background worker pending until wire_identify establishes a slot pin.');
+    }
+    // ── Connect transport ────────────────────────────────────────────────
+    if (options?.transport === 'http') {
+        const port = options?.port ?? 3200;
+        const httpTransport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: undefined, // stateless — identity is per-token, not per-session
+        });
+        await server.connect(httpTransport);
+        const httpServer = createServer(async (req, res) => {
+            // CORS for browser-based / remote clients
+            const origin = req.headers.origin || '';
+            const isLocalhost = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin);
+            res.setHeader('Access-Control-Allow-Origin', isLocalhost ? origin : 'http://localhost');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, mcp-session-id, mcp-protocol-version');
+            res.setHeader('Access-Control-Expose-Headers', 'mcp-session-id');
+            if (req.method === 'OPTIONS') {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            await httpTransport.handleRequest(req, res);
+        });
+        httpServer.listen(port, () => {
+            console.error(`[wire-mcp] MCP server started on http://localhost:${port}/`);
+        });
+    }
+    else {
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        console.error('[wire-mcp] MCP server started on stdio');
+    }
+    // Graceful shutdown
+    const cleanup = () => {
+        if (worker)
+            worker.stop();
+        releaseLock();
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+}
+//# sourceMappingURL=mcp-server.js.map