@j0hanz/cortex-mcp 1.3.0 → 1.5.0

package/dist/prompts/index.js

@@ -1,52 +1,29 @@
 import { z } from 'zod';
 import { completable } from '@modelcontextprotocol/sdk/server/completable.js';
 import { sessionStore } from '../engine/reasoner.js';
-import { loadInstructions } from '../lib/instructions.js';
+import { getPromptContracts, } from '../lib/prompt-contracts.js';
+import { withIconMeta } from '../lib/tool-response.js';
+import { REASONING_LEVELS } from '../lib/types.js';
+import { collectPrefixMatches } from '../lib/validators.js';
+import { buildServerInstructions } from '../resources/instructions.js';
+import { getTemplate } from './templates.js';
 const COMPLETION_LIMIT = 20;
-const LEVEL_VALUES = ['basic', 'normal', 'high'];
-const LEVEL_ENUM_SCHEMA = z.enum(LEVEL_VALUES);
-const LEVEL_TITLES = {
-    basic: 'Basic',
-    normal: 'Normal',
-    high: 'High',
-};
+const LEVEL_ENUM_SCHEMA = z.enum(REASONING_LEVELS);
 const REASONING_TOOL_NAME = 'reasoning_think';
-const THOUGHT_PARAMETER_GUIDANCE = 'Provide your full reasoning in the "thought" parameter for each step.';
-function levelTitle(level) {
-    return LEVEL_TITLES[level];
-}
-function formatTargetThoughts(targetThoughts) {
-    if (targetThoughts === undefined) {
-        return '';
-    }
-    return `, targetThoughts=${String(targetThoughts)}`;
-}
+const THOUGHT_PARAMETER_GUIDANCE = 'Provide full reasoning in "thought" for every step.';
 function completeSessionId(value) {
-    const results = [];
-    for (const sessionId of sessionStore.listSessionIds()) {
-        if (!sessionId.startsWith(value)) {
-            continue;
-        }
-        results.push(sessionId);
-        if (results.length >= COMPLETION_LIMIT) {
-            break;
-        }
-    }
-    return results;
+    return collectPrefixMatches(sessionStore.listSessionIds(), value, COMPLETION_LIMIT);
 }
 function completeLevel(value) {
     const normalized = value.toLowerCase();
     const results = [];
-    for (const level of LEVEL_VALUES) {
+    for (const level of REASONING_LEVELS) {
         if (level.startsWith(normalized)) {
             results.push(level);
         }
     }
     return results;
 }
-function withIconMeta(iconMeta) {
-    return iconMeta ? { icons: [iconMeta] } : undefined;
-}
 function createTextPrompt(text) {
     return {
         messages: [
@@ -60,38 +37,149 @@ function createTextPrompt(text) {
         ],
     };
 }
-function registerLevelPrompt(server, level, iconMeta) {
-    server.registerPrompt(`reasoning.${level}`, {
-        title: `Reasoning ${levelTitle(level)}`,
-        description: `Prepare a ${level}-depth reasoning request.`,
-        ...(withIconMeta(iconMeta) ?? {}),
-        argsSchema: {
-            query: z
-                .string()
-                .min(1)
-                .max(10000)
-                .describe('The question or problem to reason about'),
-            targetThoughts: z
-                .number()
-                .int()
-                .min(1)
-                .max(25)
-                .optional()
-                .describe('Optional exact step count within the selected level range (max 25)'),
-        },
-    }, ({ query, targetThoughts }) => {
-        // Create user message
-        const text = `Initiate a ${level}-depth reasoning session for the query: ${JSON.stringify(query)}. Use the "${REASONING_TOOL_NAME}" tool${formatTargetThoughts(targetThoughts)}. ${THOUGHT_PARAMETER_GUIDANCE} This is stored verbatim in the session trace. Repeat calls with the returned sessionId until totalThoughts is reached.`;
-        return createTextPrompt(text);
+function buildPromptText(args) {
+    const { context, task, constraints, output } = args;
+    return [
+        '# Context',
+        ...context,
+        '',
+        '# Task',
+        ...task,
+        '',
+        '# Constraints',
+        ...constraints.map((line) => `- ${line}`),
+        '',
+        '# Output',
+        ...output,
+    ].join('\n');
+}
+function buildStartReasoningPrompt(args) {
+    const { level, query, targetThoughts } = args;
+    const base = buildPromptText({
+        context: [
+            `Query: ${JSON.stringify(query)}`,
+            `Requested level: ${level}`,
+            `Target thoughts: ${targetThoughts === undefined
+                ? 'use level default'
+                : String(targetThoughts)}`,
+        ],
+        task: [
+            `Start a new reasoning session using "${REASONING_TOOL_NAME}".`,
+            'Create the first step with a complete, concrete reasoning thought.',
+        ],
+        constraints: [
+            THOUGHT_PARAMETER_GUIDANCE,
+            'Preserve sessionId from the response for continuation calls.',
+            'Continue until status is completed or remainingThoughts is 0.',
+        ],
+        output: [
+            'Return the first tool call payload only.',
+            'Fields: query, level, thought, and optional targetThoughts.',
+        ],
+    });
+    return `${base}\n\n---\n\n${getTemplate(level)}`;
+}
+function buildRetryReasoningPrompt(args) {
+    const { query, level, targetThoughts } = args;
+    const base = buildPromptText({
+        context: [
+            `Retry query: ${JSON.stringify(query)}`,
+            `Retry level: ${level}`,
+            `Target thoughts: ${targetThoughts === undefined
+                ? 'unchanged / default'
+                : String(targetThoughts)}`,
+        ],
+        task: [
+            `Retry by calling "${REASONING_TOOL_NAME}" with an improved first thought.`,
+        ],
+        constraints: [
+            THOUGHT_PARAMETER_GUIDANCE,
+            'Use a direct and specific thought with no filler language.',
+        ],
+        output: [
+            'Return one tool call payload only.',
+            'Fields: query, level, thought, and optional targetThoughts.',
+        ],
+    });
+    return `${base}\n\n---\n\n${getTemplate(level)}`;
+}
+function buildContinueReasoningPrompt(args) {
+    const { sessionId, query, level, targetThoughts } = args;
+    return buildPromptText({
+        context: [
+            `Session: ${JSON.stringify(sessionId)}`,
+            query === undefined
+                ? 'Follow-up query: none provided'
+                : `Follow-up query: ${JSON.stringify(query)}`,
+            level === undefined
+                ? 'Level: keep session level'
+                : `Level override: ${level}`,
+            `Target thoughts: ${targetThoughts === undefined
+                ? 'unchanged / default'
+                : String(targetThoughts)}`,
+        ],
+        task: [
+            `Continue the existing session using "${REASONING_TOOL_NAME}".`,
+            'Generate the next reasoning step only.',
+        ],
+        constraints: [
+            THOUGHT_PARAMETER_GUIDANCE,
+            'Keep the same sessionId in the call payload.',
+            'Prefer concise, concrete reasoning over meta commentary.',
+        ],
+        output: [
+            'Return one continuation tool call payload only.',
+            'Fields: sessionId, thought, and optional query/level/targetThoughts.',
+        ],
     });
 }
 export function registerAllPrompts(server, iconMeta) {
-    registerLevelPrompt(server, 'basic', iconMeta);
-    registerLevelPrompt(server, 'normal', iconMeta);
-    registerLevelPrompt(server, 'high', iconMeta);
-    server.registerPrompt('reasoning.retry', {
-        title: 'Retry Reasoning',
-        description: 'Retry a failed reasoning task with modified parameters.',
+    const contracts = getPromptContracts();
+    const instructions = buildServerInstructions();
+    const contractByName = new Map(contracts.map((contract) => [contract.name, contract]));
+    const getRequiredContract = (name) => {
+        const contract = contractByName.get(name);
+        if (!contract) {
+            throw new Error(`Missing mandatory prompt contract for '${name}'. Check src/lib/prompt-contracts.ts.`);
+        }
+        return contract;
+    };
+    // Register Level Prompts (reasoning.basic, .normal, .high)
+    for (const level of REASONING_LEVELS) {
+        const name = `reasoning.${level}`;
+        const contract = getRequiredContract(name);
+        server.registerPrompt(name, {
+            title: contract.title,
+            description: contract.description,
+            ...(withIconMeta(iconMeta) ?? {}),
+            argsSchema: {
+                query: z
+                    .string()
+                    .min(1)
+                    .max(10000)
+                    .describe('The question or problem to reason about'),
+                targetThoughts: z
+                    .number()
+                    .int()
+                    .min(1)
+                    .max(25)
+                    .optional()
+                    .describe('Optional exact step count within the selected level range (max 25)'),
+            },
+        }, ({ query, targetThoughts }) => {
+            const text = buildStartReasoningPrompt({
+                level,
+                query,
+                ...(targetThoughts !== undefined ? { targetThoughts } : {}),
+            });
+            return createTextPrompt(text);
+        });
+    }
+    // Register reasoning.retry
+    const retryContract = getRequiredContract('reasoning.retry');
+    server.registerPrompt(retryContract.name, {
+        title: retryContract.title,
+        description: retryContract.description,
         ...(withIconMeta(iconMeta) ?? {}),
         argsSchema: {
             query: z
@@ -109,18 +197,25 @@ export function registerAllPrompts(server, iconMeta) {
                 .describe('Optional exact step count'),
         },
     }, ({ query, level, targetThoughts }) => {
-        const text = `Retry the reasoning session for query: ${JSON.stringify(query)}. Use the "${REASONING_TOOL_NAME}" tool with level="${level}"${formatTargetThoughts(targetThoughts)}. ${THOUGHT_PARAMETER_GUIDANCE}`;
+        const text = buildRetryReasoningPrompt({
+            query,
+            level,
+            ...(targetThoughts !== undefined ? { targetThoughts } : {}),
+        });
         return createTextPrompt(text);
     });
-    const instructions = loadInstructions();
-    server.registerPrompt('get-help', {
-        title: 'Get Help',
-        description: 'Return the server usage instructions.',
+    // Register get-help
+    const helpContract = getRequiredContract('get-help');
+    server.registerPrompt(helpContract.name, {
+        title: helpContract.title,
+        description: helpContract.description,
         ...(withIconMeta(iconMeta) ?? {}),
     }, () => createTextPrompt(instructions));
-    server.registerPrompt('reasoning.continue', {
-        title: 'Continue Reasoning',
-        description: 'Continue an existing reasoning session with a follow-up query.',
+    // Register reasoning.continue
+    const continueContract = getRequiredContract('reasoning.continue');
+    server.registerPrompt(continueContract.name, {
+        title: continueContract.title,
+        description: continueContract.description,
         ...(withIconMeta(iconMeta) ?? {}),
         argsSchema: {
             sessionId: completable(z
@@ -144,10 +239,12 @@ export function registerAllPrompts(server, iconMeta) {
                 .describe('Optional exact step count within the selected level range (max 25)'),
         },
     }, ({ sessionId, query, level, targetThoughts }) => {
-        const followUpText = query === undefined ? '' : ` with follow-up: ${JSON.stringify(query)}`;
-        const levelText = level === undefined ? '' : ` with level="${level}"`;
-        const text = `Continue reasoning session ${JSON.stringify(sessionId)}${followUpText}. Use "${REASONING_TOOL_NAME}"${levelText}${formatTargetThoughts(targetThoughts)}. ${THOUGHT_PARAMETER_GUIDANCE}`;
+        const text = buildContinueReasoningPrompt({
+            sessionId,
+            ...(query !== undefined ? { query } : {}),
+            ...(level !== undefined ? { level } : {}),
+            ...(targetThoughts !== undefined ? { targetThoughts } : {}),
+        });
         return createTextPrompt(text);
     });
 }
-//# sourceMappingURL=index.js.map

package/dist/prompts/templates.d.ts

@@ -0,0 +1,2 @@
+import type { ReasoningLevel } from '../lib/types.js';
+export declare function getTemplate(level: ReasoningLevel): string;

package/dist/prompts/templates.js

@@ -0,0 +1,106 @@
+// ---------------------------------------------------------------------------
+// Guided few-shot examples for each reasoning level.
+// Each template shows correct `thought` depth and step count so the LLM
+// calibrates its output to the selected level requirements.
+// ---------------------------------------------------------------------------
+const BASIC_TEMPLATE = `## Guided Example (basic — 3 thoughts)
+
+**Query:** "Is Set or Array better for deduplicating a list of strings in JavaScript?"
+
+**Thought 1 of 3:**
+> A \`Set\` enforces uniqueness automatically; \`[...new Set(arr)]\` is a single-step O(n) operation. An Array-based approach (\`filter\` + \`indexOf\`) is O(n²) and adds unnecessary complexity.
+
+**Thought 2 of 3:**
+> Edge cases: both preserve insertion order in modern JS engines, so ordering is not a differentiator. \`Set\` converts all values to a common reference internally, which handles string equality correctly.
+
+**Thought 3 of 3 — conclusion:**
+> Use \`Set\`. It is faster (O(n) vs O(n²)), shorter to write, and immediately communicates the intent of deduplication. \`[...new Set(list)]\` is the idiomatic solution.
+
+---
+**System Directive:** Follow the pattern above. Each \`thought\` must contain self-contained, concrete analysis — no filler language or meta-commentary. Use 3 to 5 thoughts total.`;
+const NORMAL_TEMPLATE = `## Guided Example (normal — 7 thoughts)
+
+**Query:** "How do I safely handle concurrent writes to a shared in-memory counter in a Node.js service?"
+
+**Thought 1 of 7:**
+> Node.js is single-threaded: synchronous code is never interrupted mid-execution, so a plain \`counter++\` within one event-loop tick is effectively atomic from JavaScript's perspective.
+
+**Thought 2 of 7:**
+> The risk arises in *async* code. A read-modify-write spanning an \`await\` boundary is NOT atomic. Two concurrent callers can both read the same value before either writes, causing a lost update.
+
+**Thought 3 of 7:**
+> Example race: \`const v = await db.get('c'); await db.set('c', v + 1);\` — if two requests interleave at the \`await\` points, both read \`v=5\` and both write \`6\`, losing one increment.
+
+**Thought 4 of 7:**
+> Solution A — atomic DB operation: \`UPDATE counter SET n = n + 1 RETURNING n\` (SQL) or Redis \`INCR\`. The DB engine serialises the read-modify-write internally with no async gap.
+
+**Thought 5 of 7:**
+> Solution B — async mutex: use a library-level lock (e.g. \`async-mutex\`) to serialise access. Works for in-process state but does not scale across multiple processes or restarts.
+
+**Thought 6 of 7:**
+> Solution C — synchronous in-memory only: keep the counter as a plain variable, increment with \`counter++\` (no \`await\` in the read-modify-write path). Valid only for single-process, ephemeral state.
+
+**Thought 7 of 7 — conclusion:**
+> Prefer Solution A (atomic DB op) for correctness across restarts and multi-process deployments. Use Solution C only for in-process, non-persisted counters where an \`await\` never touches the variable. Avoid async read-modify-write without a mutex.
+
+---
+**System Directive:** Follow the pattern above. Each \`thought\` must be concrete and progress the analysis. Use 6 to 10 thoughts total; avoid restating earlier thoughts.`;
+const HIGH_TEMPLATE = `## Guided Example (high — 15 thoughts)
+
+**Query:** "Our Node.js API latency jumped from p50=20ms to p50=800ms after a dependency upgrade. How do I diagnose and fix this?"
+
+**Thought 1 of 15:**
+> Establish the change boundary: run \`git log --oneline\` to find the upgrade commit. Use \`git bisect\` between the last known-good tag and HEAD to confirm the exact commit that caused the regression.
+
+**Thought 2 of 15:**
+> Collect baseline metrics before touching anything: event-loop lag (\`perf_hooks.monitorEventLoopDelay\`), GC pause times (\`--expose-gc\` + \`PerformanceObserver\`), and per-route timings. This separates compute regressions from I/O regressions.
+
+**Thought 3 of 15:**
+> If event-loop lag is high (>50ms per tick), the cause is synchronous blocking inserted into the hot path — JSON serialisation of large objects, synchronous file I/O, regex backtracking, or CPU-heavy validation.
+
+**Thought 4 of 15:**
+> If event-loop lag is low but p50 is high, the bottleneck is I/O wait: slow DB queries, connection-pool exhaustion, DNS resolution delays, or increased network RTT to the upgraded service.
+
+**Thought 5 of 15:**
+> Read the dependency's changelog between the old and new version. Look for: new middleware injected at startup, serialisation format changes, default timeout changes, or connection-pool default reductions.
+
+**Thought 6 of 15:**
+> Profile with \`clinic.js flame\` (or \`node --prof\` + \`node --prof-process\`) under representative load. The flame graph will pinpoint whether wall-clock time is in JS compute vs. idle I/O await.
+
+**Thought 7 of 15:**
+> Write a minimal reproduction that calls *only* the upgraded package's API with representative input. Benchmark it against the pinned old version in isolation to confirm the package itself is the source.
+
+**Thought 8 of 15:**
+> Common 40× regression patterns: (a) added synchronous schema validation on every request, (b) HTTP/1.1 → HTTP/2 frame parsing overhead, (c) new middleware that buffers the full request body before routing.
+
+**Thought 9 of 15:**
+> Check connection-pool configuration: if the upgrade changed default pool size or idle timeout, requests may queue waiting for connections. Inspect \`pool.min\`, \`pool.max\`, and \`acquireTimeoutMillis\` in the new version's defaults.
+
+**Thought 10 of 15:**
+> Check middleware registration order: some packages inject global middleware at \`require\`-time. A slow middleware (e.g., large-payload body parser) before fast routes affects all endpoints even if the route itself is unchanged.
+
+**Thought 11 of 15:**
+> Immediate mitigation: pin the dependency to the last known-good version (\`npm install dep@x.y.z\`) and deploy to restore SLA while the full investigation continues. Add a TODO linking to the issue tracker.
+
+**Thought 12 of 15:**
+> If the regression is a bug in the dependency, open an issue with the minimal reproduction from Thought 7. Check if a patch release or a configuration flag exists to disable the slow behaviour.
+
+**Thought 13 of 15:**
+> If the slow path is unavoidable, mitigation options: (a) cache the expensive result at the request or process level, (b) offload CPU work to a \`worker_threads\` worker, (c) evaluate an alternative package.
+
+**Thought 14 of 15:**
+> After applying the fix, run the same load test that revealed the regression. Confirm p50 and p99 return to baseline and do not diverge under sustained load. Check that GC pressure did not increase.
+
+**Thought 15 of 15 — conclusion:**
+> Diagnosis path: git bisect → event-loop lag check → clinic.js flame graph → isolated package benchmark → changelog review → pool/middleware audit. Mitigation: pin version immediately. Fix: configure, cache, or replace. Prevention: add a latency benchmark target to CI.
+
+---
+**System Directive:** Follow the pattern above. Each \`thought\` must be specific, advancing the investigation — no summaries of prior steps, no filler. Use 15 to 25 thoughts total; scale depth to complexity.`;
+const TEMPLATES = {
+    basic: BASIC_TEMPLATE,
+    normal: NORMAL_TEMPLATE,
+    high: HIGH_TEMPLATE,
+};
+export function getTemplate(level) {
+    return TEMPLATES[level];
+}

package/dist/resources/index.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 registerAllResources(server: McpServer, iconMeta?: IconMeta): void;
-//# sourceMappingURL=index.d.ts.map

package/dist/resources/index.js

@@ -2,7 +2,11 @@ import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { McpError } from '@modelcontextprotocol/sdk/types.js';
 import { sessionStore } from '../engine/reasoner.js';
 import { formatThoughtsToMarkdown } from '../lib/formatting.js';
-import { loadInstructions } from '../lib/instructions.js';
+import { withIconMeta } from '../lib/tool-response.js';
+import { collectPrefixMatches } from '../lib/validators.js';
+import { buildServerInstructions } from './instructions.js';
+import { buildToolCatalog } from './tool-catalog.js';
+import { buildWorkflowGuide } from './workflows.js';
 const SESSIONS_RESOURCE_URI = 'reasoning://sessions';
 const SESSION_RESOURCE_PREFIX = `${SESSIONS_RESOURCE_URI}/`;
 const TRACE_RESOURCE_PREFIX = 'file:///cortex/sessions/';
@@ -22,7 +26,7 @@ function resolveSession(sessionId, uri) {
     }
     return session;
 }
-function buildSessionSummaryFromSummary(session) {
+function buildSessionSummary(session) {
     const ttlMs = sessionStore.getTtlMs();
     const expiresAt = sessionStore.getExpiresAt(session.id) ?? session.updatedAt + ttlMs;
     return {
@@ -31,7 +35,6 @@ function buildSessionSummaryFromSummary(session) {
         status: session.status,
         generatedThoughts: session.generatedThoughts,
         remainingThoughts: Math.max(0, session.totalThoughts - session.generatedThoughts),
-        plannedThoughts: session.totalThoughts,
         totalThoughts: session.totalThoughts,
         tokenBudget: session.tokenBudget,
         tokensUsed: session.tokensUsed,
@@ -40,13 +43,6 @@ function buildSessionSummaryFromSummary(session) {
         expiresAt,
     };
 }
-function buildSessionSummary(sessionId) {
-    const session = sessionStore.getSummary(sessionId);
-    if (!session) {
-        throw new McpError(-32002, `Resource not found: ${SESSION_RESOURCE_PREFIX}${sessionId}`);
-    }
-    return buildSessionSummaryFromSummary(session);
-}
 const THOUGHT_NAME_PATTERN = /^Thought-(\d+)(?:-Revised)?$/;
 function parseThoughtName(thoughtName, session) {
     const match = THOUGHT_NAME_PATTERN.exec(thoughtName);
@@ -64,61 +60,18 @@ function parseThoughtName(thoughtName, session) {
     };
 }
 function serializeJson(data) {
-    return JSON.stringify(data, null, 2);
-}
-function withIconMeta(iconMeta) {
-    return iconMeta ? { icons: [iconMeta] } : undefined;
+    return JSON.stringify(data);
 }
 function shortSessionId(sessionId) {
     return sessionId.slice(0, 8);
 }
-const COMPLETION_CACHE_TTL_MS = 1000;
-const COMPLETION_CACHE_MAX_ENTRIES = 512;
 const MAX_COMPLETION_RESULTS = 20;
-const completionCache = new Map();
-let lastCompletionCachePruneAt = 0;
+function completeSessionIds(value) {
+    return collectPrefixMatches(sessionStore.listSessionIds(), value, MAX_COMPLETION_RESULTS);
+}
 function toIsoTimestamp(unixMs) {
     return new Date(unixMs).toISOString();
 }
-function pruneCompletionCacheIfNeeded(now) {
-    if (now - lastCompletionCachePruneAt < COMPLETION_CACHE_TTL_MS) {
-        return;
-    }
-    lastCompletionCachePruneAt = now;
-    for (const [cacheKey, entry] of completionCache.entries()) {
-        if (now - entry.timestamp >= COMPLETION_CACHE_TTL_MS) {
-            completionCache.delete(cacheKey);
-        }
-    }
-    while (completionCache.size > COMPLETION_CACHE_MAX_ENTRIES) {
-        const oldestKey = completionCache.keys().next().value;
-        if (typeof oldestKey !== 'string') {
-            break;
-        }
-        completionCache.delete(oldestKey);
-    }
-}
-function completeSessionIds(value) {
-    const now = Date.now();
-    pruneCompletionCacheIfNeeded(now);
-    const cacheKey = `sessionId:${value}`;
-    const cached = completionCache.get(cacheKey);
-    if (cached && now - cached.timestamp < COMPLETION_CACHE_TTL_MS) {
-        return cached.results;
-    }
-    const results = [];
-    for (const sessionId of sessionStore.listSessionIds()) {
-        if (!sessionId.startsWith(value)) {
-            continue;
-        }
-        results.push(sessionId);
-        if (results.length >= MAX_COMPLETION_RESULTS) {
-            break;
-        }
-    }
-    completionCache.set(cacheKey, { results, timestamp: now });
-    return results;
-}
 function completeThoughtNames(value, sessionId) {
     const session = sessionStore.get(sessionId);
     if (!session) {
@@ -143,7 +96,9 @@ function completeThoughtNames(value, sessionId) {
     return results;
 }
 export function registerAllResources(server, iconMeta) {
-    const instructions = loadInstructions();
+    const instructions = buildServerInstructions();
+    const toolCatalog = buildToolCatalog();
+    const workflows = buildWorkflowGuide();
     server.registerResource('server-instructions', 'internal://instructions', {
         title: 'Server Instructions',
         description: 'Usage instructions for the MCP server.',
@@ -155,6 +110,26 @@ export function registerAllResources(server, iconMeta) {
             { uri: uri.href, mimeType: 'text/markdown', text: instructions },
         ],
     }));
+    server.registerResource('tool-catalog', 'internal://tool-catalog', {
+        title: 'Tool Catalog',
+        description: 'Tool reference: models, params, outputs, data flow.',
+        mimeType: 'text/markdown',
+        annotations: { audience: ['assistant'], priority: 0.7 },
+        ...(withIconMeta(iconMeta) ?? {}),
+    }, (uri) => ({
+        contents: [
+            { uri: uri.href, mimeType: 'text/markdown', text: toolCatalog },
+        ],
+    }));
+    server.registerResource('workflows', 'internal://workflows', {
+        title: 'Workflows',
+        description: 'Recommended workflows and tool sequences.',
+        mimeType: 'text/markdown',
+        annotations: { audience: ['assistant'], priority: 0.7 },
+        ...(withIconMeta(iconMeta) ?? {}),
+    }, (uri) => ({
+        contents: [{ uri: uri.href, mimeType: 'text/markdown', text: workflows }],
+    }));
     server.registerResource('reasoning.sessions', SESSIONS_RESOURCE_URI, {
         title: 'Reasoning Sessions',
         description: 'List of active reasoning sessions with summaries. Updated in real-time as sessions progress.',
@@ -166,9 +141,7 @@ export function registerAllResources(server, iconMeta) {
         ...(withIconMeta(iconMeta) ?? {}),
     }, () => {
         const ttlMs = sessionStore.getTtlMs();
-        const sessions = sessionStore
-            .listSummaries()
-            .map((session) => buildSessionSummaryFromSummary(session));
+        const sessions = sessionStore.listSummaries().map(buildSessionSummary);
         return {
             contents: [
                 {
@@ -287,11 +260,13 @@ export function registerAllResources(server, iconMeta) {
         title: 'Reasoning Session Detail',
         description: 'Detailed view of a single reasoning session, including all thoughts and metadata.',
         mimeType: 'application/json',
+        annotations: { audience: ['assistant', 'user'], priority: 0.8 },
         ...(withIconMeta(iconMeta) ?? {}),
     }, (uri, variables) => {
         const sessionId = extractStringVariable(variables, 'sessionId', uri);
         const session = resolveSession(sessionId, uri);
-        const summary = buildSessionSummary(sessionId);
+        const generatedThoughts = session.thoughts.length;
+        const summary = buildSessionSummary({ ...session, generatedThoughts });
         return {
             contents: [
                 {
@@ -303,6 +278,9 @@ export function registerAllResources(server, iconMeta) {
                             index: thought.index,
                             content: thought.content,
                             revision: thought.revision,
+                            ...(thought.stepSummary !== undefined
+                                ? { stepSummary: thought.stepSummary }
+                                : {}),
                         })),
                     }),
                 },
@@ -310,4 +288,3 @@ export function registerAllResources(server, iconMeta) {
         };
     });
 }
-//# sourceMappingURL=index.js.map

package/dist/resources/instructions.d.ts

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