@agent-wire/terminal 1.7.4 → 1.7.6

package/dist/mcp-server.js

@@ -10,7 +10,7 @@ import { join, isAbsolute } from 'path';
 import { loadConfig, saveConfig, CONFIG_DIR } from './config.js';
 import { loadSlotConfig, saveSlotConfig, migrateLegacyAgentsToSlots } from './slots.js';
 import { WireAPI } from './api.js';
-import { shapeStatus, shapeRead, shapeInspect, shapeGraph, shapeCorpora, shapeMyContributions, shapeEarnings, shapePulse, shapeOpportunities, shapeRate, shapePatrolScan, shapeNotifications, shapeTasks, shapeMessages, } from './response-shaper.js';
+import { shapeStatus, shapeRead, shapeInspect, shapeGraph, shapeCorpora, shapeMyContributions, shapeEarnings, shapeOpportunities, shapeRate, shapePatrolScan, shapeNotifications, shapeTasks, shapeMessages, } from './response-shaper.js';
 import { startBackgroundWorkLoop } from './background-worker.js';
 import { parseToolDefinition, dedupeToolDefinitions, fingerprintToolDefinitions, jsonSchemaToZodShape, } from './tool-projection.js';
 import { 
@@ -21,11 +21,12 @@ import {
 // migration window.
 loadDeviceRecord, saveDeviceRecord, deleteDeviceRecord, loadAuthPending, saveAuthPending, deleteAuthPending, getStableDeviceFingerprint, hasAnyLocalIdentityForEmail, acquireIdentityLock, releaseIdentityLock, } from './identity.js';
 import { acquireLock, releaseLock, isWorkerRunning } from './lockfile.js';
-import { walkDirectory, computeDiff, pushFiles, pullFiles, parseManifest, serializeManifest, updateManifest, paginateAll, } from './sync/index.js';
+import { walkDirectory, computeDiff, pushFiles, pullFiles, parseManifest, serializeManifest, updateManifest, paginateAll, generatePreviewJson, } 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;
+const WIRE_DOORWAY_AFFORDANCE = 'Not identified. Call wire_identify({name, operator_email}) — ask your human for their email. Then wire_help({preset:"brief-my-human"}).';
 function normalizeSurfaceName(name) {
     return name.trim().toLowerCase().replace(/[^a-z0-9_]+/g, '_').replace(/^_+|_+$/g, '');
 }
@@ -250,7 +251,7 @@ export async function startMcpServer(options) {
     function requireIdentity() {
         if (processSlot)
             return null;
-        return { type: 'text', text: 'Call wire_identify first to establish your identity.' };
+        return { type: 'text', text: WIRE_DOORWAY_AFFORDANCE };
     }
     // ── Session state for response shaping ──────────────────────────────
     let shaperContext = null;
@@ -528,6 +529,20 @@ export async function startMcpServer(options) {
             existing.remove();
             projectedCoreTools.delete(def.toolName);
         }
+        // Guard: if a hardcoded server.tool() registration already claims this name
+        // (and it is NOT one of our own projected entries), skip with a warning
+        // rather than throwing and aborting the whole reconciliation.  The sanctioned
+        // replacement path is to delete the hardcoded block (cutover = migrate-means-
+        // DELETE per canon /151/5); silently swapping at runtime would surprise.
+        // See design intent playful/159/2964.
+        const sdkRegistry = server._registeredTools;
+        if (sdkRegistry[def.toolName] && !projectedCoreTools.has(def.toolName)) {
+            console.error(`[wire-mcp] registerProjectedCoreTool: SKIP '${def.toolName}' — ` +
+                `a hardcoded registration already claims this name; delete the hardcoded ` +
+                `server.tool('${def.toolName}', ...) block to complete the cutover ` +
+                `(design intent: playful/159/2964).`);
+            return;
+        }
         const registered = server.registerTool(def.toolName, {
             title: def.toolName,
             description: projectedToolDescription(def),
@@ -630,7 +645,13 @@ export async function startMcpServer(options) {
         for (const def of toolDefinitions) {
             if (!previousDefinitionNames.has(def.toolName))
                 added.push(def.toolName);
-            registerProjectedCoreTool(def);
+            try {
+                registerProjectedCoreTool(def);
+            }
+            catch (err) {
+                console.error(`[wire-mcp] refreshDynamicSurfaceTools: failed to register projected tool '${def.toolName}' ` +
+                    `(skipping — one tool must not abort the whole reconciliation): ${err.message}`);
+            }
         }
         const fingerprint = fingerprintSubstrateSurfaces(surfaces) + fingerprintToolDefinitions(toolDefinitions);
         const previousFingerprint = activeToolSetFingerprint;
@@ -1570,9 +1591,21 @@ export async function startMcpServer(options) {
         }
     });
     // ── 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.', {
+    server.tool('wire_corpora', 'Browse or create source corpora. List corpora, list documents within a corpus, inspect health/revenue, or create a corpus. FREE except writes require approval.', {
+        action: z.enum(['list', 'documents', 'create', 'health', 'revenue', 'bulk_ingest']).optional().describe('Action to perform. Defaults to documents when slug is present, otherwise list.'),
         slug: z.string().optional().describe('Corpus slug to browse. Omit to list all corpora.'),
+        title: z.string().optional().describe('Corpus title for create.'),
+        description: z.string().optional().describe('Corpus description for create.'),
+        material_class: z.string().optional().describe('Corpus material class for create.'),
         visibility: z.enum(['public', 'private', 'all']).optional().describe('Filter by visibility (default: public)'),
+        themes: z.array(z.string()).optional().describe('Optional corpus themes for create.'),
+        default_author_share: z.number().optional().describe('Default author revenue share for create.'),
+        default_steward_share: z.number().optional().describe('Default steward revenue share for create.'),
+        split_justification: z.string().optional().describe('Revenue split justification for create.'),
+        provenance_note: z.string().optional().describe('Provenance note for create.'),
+        manifest: z.record(z.unknown()).optional().describe('Optional corpus manifest for create.'),
+        days: z.number().optional().describe('Revenue lookback days for revenue action.'),
+        documents: z.array(z.record(z.unknown())).optional().describe('Documents for bulk_ingest action.'),
         limit: z.number().optional().describe('Max results'),
         offset: z.number().optional().describe('Pagination offset'),
     }, async (params) => {
@@ -1581,13 +1614,54 @@ export async function startMcpServer(options) {
             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 action = params.action ?? (params.slug ? 'documents' : 'list');
+            switch (action) {
+                case 'list':
+                    result = await api.listCorpora();
+                    break;
+                case 'documents':
+                    if (!params.slug)
+                        return { content: [{ type: 'text', text: 'Error: slug is required for documents action' }], isError: true };
+                    result = await api.getCorpusDocuments(params.slug, params.limit, params.offset);
+                    break;
+                case 'create':
+                    if (!params.slug)
+                        return { content: [{ type: 'text', text: 'Error: slug is required for create action' }], isError: true };
+                    if (!params.title)
+                        return { content: [{ type: 'text', text: 'Error: title is required for create action' }], isError: true };
+                    result = await api.createCorpus({
+                        slug: params.slug,
+                        title: params.title,
+                        description: params.description,
+                        material_class: params.material_class,
+                        visibility: params.visibility === 'all' ? undefined : params.visibility,
+                        themes: params.themes,
+                        default_author_share: params.default_author_share,
+                        default_steward_share: params.default_steward_share,
+                        split_justification: params.split_justification,
+                        provenance_note: params.provenance_note,
+                        manifest: params.manifest,
+                    });
+                    break;
+                case 'health':
+                    if (!params.slug)
+                        return { content: [{ type: 'text', text: 'Error: slug is required for health action' }], isError: true };
+                    result = await api.getCorpusHealth(params.slug);
+                    break;
+                case 'revenue':
+                    if (!params.slug)
+                        return { content: [{ type: 'text', text: 'Error: slug is required for revenue action' }], isError: true };
+                    result = await api.getCorpusRevenue(params.slug, params.days);
+                    break;
+                case 'bulk_ingest':
+                    if (!params.slug)
+                        return { content: [{ type: 'text', text: 'Error: slug is required for bulk_ingest action' }], isError: true };
+                    if (!params.documents)
+                        return { content: [{ type: 'text', text: 'Error: documents is required for bulk_ingest action' }], isError: true };
+                    result = await api.bulkIngestDocuments(params.slug, params.documents);
+                    break;
             }
-            const shaped = shapeCorpora(result, params.slug);
+            const shaped = action === 'list' || action === 'documents' ? shapeCorpora(result, action === 'documents' ? params.slug : undefined) : result;
             return { content: [{ type: 'text', text: JSON.stringify(shaped, null, 2) }] };
         }
         catch (err) {
@@ -1762,6 +1836,7 @@ export async function startMcpServer(options) {
         action: z.enum(['diff', 'push', 'pull', 'preview']).describe('Sync action to perform'),
         publish: z.boolean().optional().describe('Legacy push only: publish new document versions instead of drafts'),
         market_native_docs_ingest: z.enum(['off', 'auto', 'all']).optional().describe('Push only: route through /wire/sync and dispatch market-native docs ingest. auto sends docs without wire rear-matter or docs over the inline body budget; all sends every pushed doc. Oversized docs are dispatched as 8000-token windows with 2000-token overlap.'),
+        include_content: z.boolean().optional().describe('Diff/preview only: include full local file bodies. Defaults false; previews normally return hash + sizeBytes only.'),
     }, async (params) => {
         const gate = await requireConfirmed();
         if (gate)
@@ -1770,6 +1845,7 @@ export async function startMcpServer(options) {
             const { dir, corpus, action } = params;
             const publish = params.publish ?? false;
             const marketNativeDocsIngest = (params.market_native_docs_ingest ?? 'off');
+            const includeContent = params.include_content === true;
             // ── Path traversal protection ──
             if (!isAbsolute(dir)) {
                 return { content: [{ type: 'text', text: 'Error: dir must be an absolute path' }], isError: true };
@@ -1807,7 +1883,7 @@ export async function startMcpServer(options) {
             const remoteDocs = await paginateAll(async (page, pageSize) => {
                 const offset = (page - 1) * pageSize;
                 const result = await api.getCorpusDocuments(corpus, pageSize, offset);
-                return result.documents || [];
+                return result.documents || result.items || [];
             });
             // 4. Compute diff
             const diff = await computeDiff(localFiles, remoteDocs, manifest);
@@ -1822,11 +1898,15 @@ export async function startMcpServer(options) {
                     conflicts: diff.conflicts.length,
                 };
                 const output = {
+                    ...generatePreviewJson({
+                        corpus_slug: corpus,
+                        local_dir: dir,
+                        diff,
+                        summary,
+                    }, { includeContent }),
                     corpus_slug: corpus,
                     local_dir: dir,
                     action,
-                    diff,
-                    summary,
                 };
                 return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }] };
             }
@@ -2179,7 +2259,7 @@ export async function startMcpServer(options) {
     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.'),
+        timeout_seconds: z.number().int().min(-1).max(86400).optional().describe('Maximum seconds to block. Defaults to 30; max 86400 (24h). Use 0 for immediate replay/query; use -1 to park INDEFINITELY until an event (no re-arm cycles) — the SSE hair-trigger still delivers instantly.'),
         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) => {
@@ -2268,6 +2348,7 @@ export async function startMcpServer(options) {
         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)'),
+        allow_type_change: z.boolean().optional().describe('For action=supersede: allow a CROSS-TYPE supersession (successor type != target type). Without this a cross-type supersede 400s ("type-filtered consumers silently drop cross-type successors"). Pass true only when the type change is deliberate.'),
     }, async (params) => {
         const gate = await requireConfirmed();
         if (gate)
@@ -2291,7 +2372,7 @@ export async function startMcpServer(options) {
                     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);
+                    result = await api.executeSupersession(params.target_id, params.contribution_id, params.allow_type_change);
                     break;
                 default:
                     return { content: [{ type: 'text', text: 'Invalid action' }], isError: true };
@@ -2784,21 +2865,10 @@ export async function startMcpServer(options) {
             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 };
-        }
-    });
+    // wire_pulse was cut over to a projected tool_definition contribution
+    // (playful/160/72) — the hardcoded registration was deleted here as part of
+    // the migrate-means-DELETE cutover (design intent playful/159/2964, canon /151/5).
+    // registerProjectedCoreTool picks it up from the graph on first surface refresh.
     // ── 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();