@j0hanz/cortex-mcp 1.2.1 → 1.4.0

package/dist/resources/tool-catalog.js

@@ -0,0 +1,20 @@
+import { buildCoreContextPack } from './tool-info.js';
+const CATALOG_GUIDE = `# Tool Catalog Details
+## Optional Parameters
+- \`observation\`: What facts are known at this step? Use with \`hypothesis\` and \`evaluation\` as an alternative to \`thought\`.
+- \`hypothesis\`: What is the proposed idea or next logical leap?
+- \`evaluation\`: Critique the hypothesis. Are there flaws?
+- \`step_summary\`: A 1-sentence summary of the conclusion reached in this step. Accumulates in the \`summary\` field for contextual guidance.
+- \`is_conclusion\`: Set to true to end the session early with a final answer.
+- \`rollback_to_step\`: Roll back to a thought index (0-based). All thoughts after this index are discarded.
+
+## Cross-Tool Data Flow
+\`\`\`
+reasoning_think -> result.sessionId -> reasoning_think.sessionId
+reasoning_think -> result.sessionId -> reasoning://sessions/{sessionId}
+reasoning_think -> result.sessionId -> file:///cortex/sessions/{sessionId}/trace.md
+\`\`\`
+`;
+export function buildToolCatalog() {
+    return `${buildCoreContextPack()}\n\n${CATALOG_GUIDE}`;
+}

package/dist/resources/tool-info.d.ts

@@ -0,0 +1,2 @@
+export declare function buildCoreContextPack(): string;
+export declare function getSharedConstraints(): string[];

package/dist/resources/tool-info.js

@@ -0,0 +1,35 @@
+import { getToolContracts } from '../lib/tool-contracts.js';
+function toEntry(contract) {
+    return {
+        name: contract.name,
+        model: contract.model,
+        timeout: contract.timeoutMs > 0
+            ? `${Math.round(contract.timeoutMs / 1_000)}s`
+            : 'N/A',
+        maxOutputTokens: contract.maxOutputTokens > 0 ? String(contract.maxOutputTokens) : 'N/A',
+        purpose: contract.purpose,
+    };
+}
+const ENTRIES = Object.fromEntries(getToolContracts().map((contract) => [contract.name, toEntry(contract)]));
+export function buildCoreContextPack() {
+    const names = Object.keys(ENTRIES).sort((a, b) => a.localeCompare(b));
+    const rows = names.map((name) => {
+        const e = ENTRIES[name];
+        return e
+            ? `| \`${e.name}\` | ${e.model} | ${e.timeout} | ${e.maxOutputTokens} | ${e.purpose} |`
+            : '';
+    });
+    return `# Core Context Pack\n\n| Tool | Model | Timeout | Max Output Tokens | Purpose |\n|------|-------|---------|-------------------|---------|\n${rows.join('\n')}`;
+}
+export function getSharedConstraints() {
+    return [
+        'Sessions are in-memory — all data is lost on process restart.',
+        'Session TTL: 30 minutes from last update. Expired sessions cannot be recovered.',
+        'Maximum query length: 10,000 characters.',
+        'Token budget enforcement is approximate (character-based proxy, not true tokenization).',
+        'stdio transport only — no HTTP endpoint available.',
+        'Every thought in the trace contains LLM-authored reasoning content provided via the `thought` parameter.',
+        "targetThoughts must be an integer within the level's min/max range.",
+        'Session store limits are configurable via CORTEX_SESSION_TTL_MS, CORTEX_MAX_SESSIONS, and CORTEX_MAX_TOTAL_TOKENS.',
+    ];
+}

package/dist/resources/workflows.d.ts

@@ -0,0 +1 @@
+export declare function buildWorkflowGuide(): string;

package/dist/resources/workflows.js

@@ -0,0 +1,60 @@
+import { getToolContracts } from '../lib/tool-contracts.js';
+import { getSharedConstraints } from './tool-info.js';
+function buildToolReference() {
+    return getToolContracts()
+        .map((c) => `### \`${c.name}\`\n- Purpose: ${c.purpose}\n- Output: \`${c.outputShape}\``)
+        .join('\n\n');
+}
+export function buildWorkflowGuide() {
+    return `# THE "GOLDEN PATH" WORKFLOWS (CRITICAL)
+
+### WORKFLOW A: Sequential Reasoning (Most Common)
+
+1. Call \`reasoning_think\` with \`{ query: "...", level: "basic", thought: "Your detailed reasoning for step 1..." }\`.
+2. Read the response — note the \`sessionId\` and \`remainingThoughts\` fields.
+3. **You MUST continue**: Call again with \`{ sessionId: "<from response>", level: "<same level>", thought: "Your next reasoning step..." }\`.
+4. Repeat step 3 until the response shows \`status: "completed"\` or \`remainingThoughts: 0\`.
+   NOTE: The \`summary\` field contains the exact continuation call you should make next.
+
+### WORKFLOW B: Multi-Turn Reasoning (Session Continuation)
+
+1. Call \`reasoning_think\` with \`{ query: "initial question", level: "normal", thought: "Your first reasoning step..." }\` — note the returned \`sessionId\`.
+2. Call \`reasoning_think\` with \`{ sessionId: "<id>", level: "normal", thought: "Your next reasoning step..." }\` (optional: add \`query\` for follow-up context).
+3. Repeat until \`status: "completed"\` or \`remainingThoughts: 0\`, then read \`reasoning://sessions/{sessionId}\` for the full chain.
+   NOTE: The \`level\` parameter is optional when continuing; if provided and mismatched, the session level is used.
+
+### WORKFLOW C: Controlled Depth Reasoning
+
+1. Call \`reasoning_think\` with \`{ query: "...", level: "normal", targetThoughts: 8, thought: "Your reasoning..." }\` to set the session's planned step count.
+2. Repeat calls with the returned \`sessionId\` and your next \`thought\` until \`result.totalThoughts\` is reached.
+   NOTE: \`targetThoughts\` must fall within the level range (basic: 3–5, normal: 6–10, high: 15–25). Out-of-range values return \`E_INVALID_THOUGHT_COUNT\`.
+
+### WORKFLOW D: Async Task Execution
+
+1. Call \`reasoning_think\` as a task (send \`tools/call\` with \`task\` field) for long-running \`high\`-level reasoning.
+2. Poll \`tasks/get\` until status is \`completed\` or \`failed\`.
+3. Retrieve the result via \`tasks/result\`.
+4. Use \`tasks/cancel\` to abort if needed.
+
+### WORKFLOW E: Batched Run-To-Completion
+
+1. Start a new session with explicit \`targetThoughts\` and \`runMode: "run_to_completion"\`.
+2. Provide one \`thought\` plus additional \`thoughts[]\` entries to cover the planned step count.
+3. The server consumes thought inputs in order until completion, token budget exhaustion, or cancellation.
+
+### WORKFLOW F: Structured Reasoning (Observation/Hypothesis/Evaluation)
+
+1. Call \`reasoning_think\` with \`{ query: "...", level: "normal", observation: "facts...", hypothesis: "idea...", evaluation: "critique..." }\`.
+2. The server formats these into a structured thought and stores it in the session trace.
+3. Continue with \`sessionId\` using either \`thought\` or structured fields for subsequent steps.
+4. Use \`is_conclusion: true\` to end early, or \`rollback_to_step\` to discard and redo from a specific step.
+
+## Shared Constraints
+${getSharedConstraints()
+        .map((c) => `- ${c}`)
+        .join('\n')}
+
+## Tool Reference
+${buildToolReference()}
+`;
+}

package/dist/schemas/inputs.d.ts

@@ -12,8 +12,13 @@ export declare const ReasoningThinkInputSchema: z.ZodObject<{
         step: "step";
         run_to_completion: "run_to_completion";
     }>>;
-    thought: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    thought: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     thoughts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    is_conclusion: z.ZodOptional<z.ZodBoolean>;
+    rollback_to_step: z.ZodOptional<z.ZodNumber>;
+    step_summary: z.ZodOptional<z.ZodString>;
+    observation: z.ZodOptional<z.ZodString>;
+    hypothesis: z.ZodOptional<z.ZodString>;
+    evaluation: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type ReasoningThinkInput = z.infer<typeof ReasoningThinkInputSchema>;
-//# sourceMappingURL=inputs.d.ts.map

package/dist/schemas/inputs.js

@@ -1,21 +1,29 @@
 import { z } from 'zod';
+import { getLevelDescriptionString } from '../engine/config.js';
 import { getTargetThoughtsError } from '../lib/validators.js';
+const RUN_MODE_VALUES = ['step', 'run_to_completion'];
+const DEFAULT_RUN_MODE = 'step';
+const LEVEL_VALUES = ['basic', 'normal', 'high'];
+const QUERY_TEXT_SCHEMA = z.string().min(1).max(10000);
+const LEVEL_SCHEMA = z.enum(LEVEL_VALUES);
+const THOUGHT_TEXT_SCHEMA = z.string().min(1).max(100000);
+const THOUGHT_BATCH_SCHEMA = z.array(THOUGHT_TEXT_SCHEMA).min(1).max(25);
+function addCustomIssue(ctx, path, message) {
+    ctx.addIssue({
+        code: 'custom',
+        message,
+        path,
+    });
+}
 export const ReasoningThinkInputSchema = z
     .strictObject({
-    query: z
-        .string()
-        .min(1)
-        .max(10000)
-        .optional()
-        .describe('The question or problem to reason about'),
-    level: z
-        .enum(['basic', 'normal', 'high'])
-        .optional()
-        .describe('Reasoning depth level (required for new sessions, optional for continuing)'),
+    query: QUERY_TEXT_SCHEMA.optional().describe('The question or problem to reason about'),
+    level: LEVEL_SCHEMA.optional().describe(`Reasoning depth level (required for new sessions, optional for continuing). ${getLevelDescriptionString()}.`),
     targetThoughts: z
         .number()
         .int()
         .min(1)
+        .max(25)
         .optional()
         .describe('Optional explicit thought count. Must fit the level range: basic 3–5, normal 6–10, high 15–25.'),
     sessionId: z
@@ -25,73 +33,79 @@ export const ReasoningThinkInputSchema = z
         .optional()
         .describe('Session ID to continue. The session level is used when continuing; provided level is optional.'),
     runMode: z
-        .enum(['step', 'run_to_completion'])
+        .enum(RUN_MODE_VALUES)
         .optional()
         .describe('Execution mode (default: "step"). "step" appends a single thought per call. "run_to_completion" consumes all supplied thought inputs in one request.'),
     thought: z
-        .union([
-        z.string().min(1).max(100000),
-        z.array(z.string().min(1).max(100000)).min(1).max(25),
-    ])
+        .union([THOUGHT_TEXT_SCHEMA, THOUGHT_BATCH_SCHEMA])
+        .optional()
         .describe('Your full reasoning content for this step. ' +
         'The server stores this text verbatim as the thought in the session trace. ' +
         'Write your complete analysis, observations, and conclusions here — this is what appears in trace.md. ' +
         'Can be a single string or an array of strings (for batch execution).'),
     thoughts: z
-        .array(z.string().min(1).max(100000))
+        .array(THOUGHT_TEXT_SCHEMA)
         .max(25)
         .optional()
         .describe('(Deprecated) Optional additional thought inputs. Use "thought" as an array instead.'),
+    is_conclusion: z
+        .boolean()
+        .optional()
+        .describe('Set to true if you have arrived at the final answer and wish to end the reasoning session early.'),
+    rollback_to_step: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe('Set to a thought index (0-based) to rollback to. All thoughts after this index will be discarded.'),
+    step_summary: z
+        .string()
+        .optional()
+        .describe('A 1-sentence summary of the conclusion reached in this specific step.'),
+    observation: z
+        .string()
+        .optional()
+        .describe('What facts are known at this step?'),
+    hypothesis: z
+        .string()
+        .optional()
+        .describe('What is the proposed idea or next logical leap?'),
+    evaluation: z
+        .string()
+        .optional()
+        .describe('Critique the hypothesis. Are there flaws?'),
 })
     .superRefine((data, ctx) => {
-    const runMode = data.runMode ?? 'step';
+    const runMode = data.runMode ?? DEFAULT_RUN_MODE;
     if (data.sessionId === undefined && data.query === undefined) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'query is required when sessionId is not provided',
-            path: ['query'],
-        });
+        addCustomIssue(ctx, ['query'], 'query is required when sessionId is not provided');
     }
     if (data.sessionId === undefined && data.level === undefined) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'level is required when sessionId is not provided',
-            path: ['level'],
-        });
+        addCustomIssue(ctx, ['level'], 'level is required when sessionId is not provided');
     }
     if (runMode === 'run_to_completion' &&
         data.sessionId === undefined &&
         data.targetThoughts === undefined) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'targetThoughts is required for run_to_completion when sessionId is not provided',
-            path: ['targetThoughts'],
-        });
+        addCustomIssue(ctx, ['targetThoughts'], 'targetThoughts is required for run_to_completion when sessionId is not provided');
     }
     if (runMode === 'step' && Array.isArray(data.thought)) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'thought must be a string when runMode is "step"',
-            path: ['thought'],
-        });
+        addCustomIssue(ctx, ['thought'], 'thought must be a string when runMode is "step"');
     }
     if (runMode === 'step' && data.thoughts !== undefined) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'thoughts is only allowed when runMode is "run_to_completion"',
-            path: ['thoughts'],
-        });
+        addCustomIssue(ctx, ['thoughts'], 'thoughts is only allowed when runMode is "run_to_completion"');
+    }
+    const hasThought = data.thought !== undefined;
+    const hasStructured = data.observation !== undefined &&
+        data.hypothesis !== undefined &&
+        data.evaluation !== undefined;
+    if (!hasThought && !hasStructured && data.rollback_to_step === undefined) {
+        addCustomIssue(ctx, ['thought'], 'Either "thought" or structured fields ("observation", "hypothesis", "evaluation") are required, unless rolling back.');
     }
     if (data.targetThoughts === undefined || data.level === undefined) {
         return;
     }
     const error = getTargetThoughtsError(data.level, data.targetThoughts);
     if (error) {
-        ctx.addIssue({
-            code: 'custom',
-            message: error,
-            path: ['targetThoughts'],
-        });
+        addCustomIssue(ctx, ['targetThoughts'], error);
     }
 });
-//# sourceMappingURL=inputs.js.map

package/dist/schemas/outputs.d.ts

@@ -25,6 +25,7 @@ declare const ReasoningThinkSuccessSchema: z.ZodObject<{
             index: z.ZodNumber;
             content: z.ZodString;
             revision: z.ZodNumber;
+            stepSummary: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         generatedThoughts: z.ZodNumber;
         requestedThoughts: z.ZodNumber;
@@ -57,6 +58,7 @@ export declare const ReasoningThinkResultSchema: z.ZodDiscriminatedUnion<[z.ZodO
             index: z.ZodNumber;
             content: z.ZodString;
             revision: z.ZodNumber;
+            stepSummary: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         generatedThoughts: z.ZodNumber;
         requestedThoughts: z.ZodNumber;
@@ -99,6 +101,7 @@ export declare const ReasoningThinkToolOutputSchema: z.ZodObject<{
             index: z.ZodNumber;
             content: z.ZodString;
             revision: z.ZodNumber;
+            stepSummary: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         generatedThoughts: z.ZodNumber;
         requestedThoughts: z.ZodNumber;
@@ -119,4 +122,3 @@ export declare const ReasoningThinkToolOutputSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type ReasoningThinkSuccess = z.infer<typeof ReasoningThinkSuccessSchema>;
 export {};
-//# sourceMappingURL=outputs.d.ts.map

package/dist/schemas/outputs.js

@@ -1,25 +1,33 @@
 import { z } from 'zod';
+const ErrorInfoSchema = z.strictObject({
+    code: z.string(),
+    message: z.string(),
+});
+const MISSING_RESULT_PATH = ['result'];
+const MISSING_ERROR_PATH = ['error'];
+const LEVEL_VALUES = ['basic', 'normal', 'high'];
+const STATUS_VALUES = ['active', 'completed', 'cancelled'];
+const ThoughtSchema = z.strictObject({
+    index: z.number(),
+    content: z.string(),
+    revision: z.number(),
+    stepSummary: z
+        .string()
+        .optional()
+        .describe('A 1-sentence summary of the conclusion reached in this step, if provided.'),
+});
 export const DefaultOutputSchema = z.strictObject({
     ok: z.boolean(),
     result: z.unknown().optional(),
-    error: z
-        .strictObject({
-        code: z.string(),
-        message: z.string(),
-    })
-        .optional(),
+    error: ErrorInfoSchema.optional(),
 });
 const ReasoningThinkSuccessSchema = z.strictObject({
     ok: z.literal(true),
     result: z.strictObject({
         sessionId: z.string(),
-        level: z.enum(['basic', 'normal', 'high']),
-        status: z.enum(['active', 'completed', 'cancelled']),
-        thoughts: z.array(z.strictObject({
-            index: z.number(),
-            content: z.string(),
-            revision: z.number(),
-        })),
+        level: z.enum(LEVEL_VALUES),
+        status: z.enum(STATUS_VALUES),
+        thoughts: z.array(ThoughtSchema),
         generatedThoughts: z.number(),
         requestedThoughts: z.number(),
         totalThoughts: z.number(),
@@ -43,27 +51,44 @@ const ReasoningThinkSuccessSchema = z.strictObject({
 });
 const ReasoningThinkErrorSchema = z.strictObject({
     ok: z.literal(false),
-    error: z.strictObject({
-        code: z.string(),
-        message: z.string(),
-    }),
+    error: ErrorInfoSchema,
 });
 export const ReasoningThinkResultSchema = z.discriminatedUnion('ok', [
     ReasoningThinkSuccessSchema,
     ReasoningThinkErrorSchema,
 ]);
+function getMissingFieldIssue(data) {
+    if (data.ok && data.result === undefined) {
+        return {
+            message: 'result is required when ok is true',
+            path: MISSING_RESULT_PATH,
+        };
+    }
+    if (!data.ok && data.error === undefined) {
+        return {
+            message: 'error is required when ok is false',
+            path: MISSING_ERROR_PATH,
+        };
+    }
+    return undefined;
+}
 /**
  * Tool-facing output schema kept as a strict object so SDK tooling
  * can advertise outputSchema via tools/list.
  */
-export const ReasoningThinkToolOutputSchema = z.strictObject({
+export const ReasoningThinkToolOutputSchema = z
+    .strictObject({
     ok: z.boolean(),
     result: ReasoningThinkSuccessSchema.shape.result.optional(),
-    error: z
-        .strictObject({
-        code: z.string(),
-        message: z.string(),
-    })
-        .optional(),
+    error: ErrorInfoSchema.optional(),
+})
+    .superRefine((data, ctx) => {
+    const missingFieldIssue = getMissingFieldIssue(data);
+    if (missingFieldIssue) {
+        ctx.addIssue({
+            code: 'custom',
+            message: missingFieldIssue.message,
+            path: missingFieldIssue.path,
+        });
+    }
 });
-//# sourceMappingURL=outputs.js.map

package/dist/server.d.ts

@@ -1,3 +1,2 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare function createServer(): McpServer;
-//# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -4,34 +4,41 @@ import { InMemoryTaskStore } from '@modelcontextprotocol/sdk/experimental/tasks'
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { engineEvents } from './engine/events.js';
 import { getErrorMessage } from './lib/errors.js';
-import { loadInstructions } from './lib/instructions.js';
 import { registerAllTools } from './tools/index.js';
 import { registerAllPrompts } from './prompts/index.js';
 import { registerAllResources } from './resources/index.js';
+import { buildServerInstructions } from './resources/instructions.js';
 const ICON_MIME = 'image/svg+xml';
+const SERVER_NAME = 'cortex-mcp';
+const SERVER_TITLE = 'Cortex MCP';
+const SERVER_WEBSITE_URL = 'https://github.com/j0hanz/cortex-mcp';
+const RESOURCE_LIST_CHANGED_METHOD = 'resources/list_changed';
+const RESOURCE_UPDATED_METHOD = 'resources/updated';
+const SERVER_DESCRIPTION = 'Multi-level reasoning MCP server with configurable depth levels.';
+const ICON_URL_CANDIDATES = [
+    new URL('../assets/logo.svg', import.meta.url),
+    new URL('./assets/logo.svg', import.meta.url),
+];
+let cachedLocalIconData;
+let cachedVersion;
 function getLocalIconData() {
-    const candidates = [
-        new URL('../assets/logo.svg', import.meta.url),
-        new URL('./assets/logo.svg', import.meta.url),
-    ];
-    for (const candidate of candidates) {
+    if (cachedLocalIconData !== undefined) {
+        return cachedLocalIconData ?? undefined;
+    }
+    for (const candidate of ICON_URL_CANDIDATES) {
         try {
             const data = readFileSync(candidate);
-            return `data:${ICON_MIME};base64,${data.toString('base64')}`;
+            cachedLocalIconData = `data:${ICON_MIME};base64,${data.toString('base64')}`;
+            return cachedLocalIconData;
         }
         catch {
             continue;
         }
     }
+    cachedLocalIconData = null;
     return undefined;
 }
-function loadVersion() {
-    const packageJsonPath = findPackageJSON(import.meta.url);
-    if (!packageJsonPath) {
-        throw new Error('Unable to locate package.json for cortex-mcp.');
-    }
-    const packageJson = readFileSync(packageJsonPath, 'utf8');
-    const parsed = JSON.parse(packageJson);
+function getPackageVersion(parsed) {
     if (typeof parsed !== 'object' ||
         parsed === null ||
         !('version' in parsed) ||
@@ -40,41 +47,57 @@ function loadVersion() {
     }
     return parsed.version;
 }
+function loadVersion() {
+    if (cachedVersion) {
+        return cachedVersion;
+    }
+    const packageJsonPath = findPackageJSON(import.meta.url);
+    if (!packageJsonPath) {
+        throw new Error('Unable to locate package.json for cortex-mcp.');
+    }
+    const packageJson = readFileSync(packageJsonPath, 'utf8');
+    cachedVersion = getPackageVersion(JSON.parse(packageJson));
+    return cachedVersion;
+}
+function getServerIcons(iconMeta) {
+    if (!iconMeta) {
+        return undefined;
+    }
+    return [
+        {
+            src: iconMeta.src,
+            mimeType: iconMeta.mimeType,
+        },
+    ];
+}
 function attachEngineEventHandlers(server) {
+    const logNotificationFailure = (method, error, data) => {
+        void server
+            .sendLoggingMessage({
+            level: 'debug',
+            logger: 'cortex-mcp.server',
+            data: {
+                event: 'notification_failed',
+                method,
+                ...(data ?? {}),
+                error: getErrorMessage(error),
+            },
+        })
+            .catch(() => {
+            // Never fail on logging errors.
+        });
+    };
     const onResourcesChanged = () => {
         void server.server.sendResourceListChanged().catch((err) => {
-            void server
-                .sendLoggingMessage({
-                level: 'debug',
-                logger: 'cortex-mcp.server',
-                data: {
-                    event: 'notification_failed',
-                    method: 'resources/list_changed',
-                    error: getErrorMessage(err),
-                },
-            })
-                .catch(() => {
-                // Never fail on logging errors.
-            });
+            logNotificationFailure(RESOURCE_LIST_CHANGED_METHOD, err);
         });
     };
     const onResourceUpdated = (data) => {
         void server.server
             .sendResourceUpdated({ uri: data.uri })
             .catch((err) => {
-            void server
-                .sendLoggingMessage({
-                level: 'debug',
-                logger: 'cortex-mcp.server',
-                data: {
-                    event: 'notification_failed',
-                    method: 'resources/updated',
-                    uri: data.uri,
-                    error: getErrorMessage(err),
-                },
-            })
-                .catch(() => {
-                // Never fail on logging errors.
+            logNotificationFailure(RESOURCE_UPDATED_METHOD, err, {
+                uri: data.uri,
             });
         });
     };
@@ -124,34 +147,27 @@ function installCloseCleanup(server, cleanup) {
     };
 }
 export function createServer() {
-    const instructions = loadInstructions();
+    const instructions = buildServerInstructions();
     const version = loadVersion();
     const taskStore = new InMemoryTaskStore();
     const localIcon = getLocalIconData();
     const iconMeta = localIcon
         ? { src: localIcon, mimeType: ICON_MIME }
         : undefined;
+    const icons = getServerIcons(iconMeta);
     const server = new McpServer({
-        name: 'cortex-mcp',
-        title: 'Cortex MCP',
-        description: 'Multi-level reasoning MCP server with configurable depth levels.',
-        websiteUrl: 'https://github.com/j0hanz/cortex-mcp',
+        name: SERVER_NAME,
+        title: SERVER_TITLE,
+        description: SERVER_DESCRIPTION,
+        websiteUrl: SERVER_WEBSITE_URL,
         version,
-        ...(iconMeta
-            ? {
-                icons: [
-                    {
-                        src: iconMeta.src,
-                        mimeType: iconMeta.mimeType,
-                    },
-                ],
-            }
-            : {}),
+        ...(icons ? { icons } : {}),
     }, {
         capabilities: {
             tools: {},
             logging: {},
             prompts: {},
+            completions: {},
             resources: { subscribe: true, listChanged: true },
             tasks: {
                 list: {},
@@ -173,4 +189,3 @@ export function createServer() {
     installCloseCleanup(server, detachEngineHandlers);
     return server;
 }
-//# sourceMappingURL=server.js.map

package/dist/tools/index.d.ts

@@ -1,7 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { IconMeta } from '../lib/types.js';
-/**
- * Registers all tools with the MCP server.
- */
 export declare function registerAllTools(server: McpServer, iconMeta?: IconMeta): void;
-//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -1,8 +1,7 @@
 import { registerReasoningThinkTool } from './reasoning-think.js';
-/**
- * Registers all tools with the MCP server.
- */
+const TOOL_REGISTRARS = [registerReasoningThinkTool];
 export function registerAllTools(server, iconMeta) {
-    registerReasoningThinkTool(server, iconMeta);
+    for (const registerTool of TOOL_REGISTRARS) {
+        registerTool(server, iconMeta);
+    }
 }
-//# sourceMappingURL=index.js.map

package/dist/tools/reasoning-think.d.ts

@@ -1,4 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { IconMeta } from '../lib/types.js';
 export declare function registerReasoningThinkTool(server: McpServer, iconMeta?: IconMeta): void;
-//# sourceMappingURL=reasoning-think.d.ts.map