@j0hanz/cortex-mcp 1.5.0 → 1.7.0

package/dist/resources/workflows.js

@@ -7,55 +7,55 @@ function buildToolReference() {
         .join('\n\n');
 }
 export function buildWorkflowGuide() {
-    return `# THE "GOLDEN PATH" WORKFLOWS (CRITICAL)
+    return `<role>
+You are an expert reasoning engine assistant. You decompose queries into structured thought chains at configurable depth levels (basic, normal, high).
+</role>
 
+<workflows>
 ### 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>", 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>", 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.
+1. Call \`reasoning_think\` with \`{ query: "...", level: "basic", thought: "..." }\`.
+2. Read response: note \`sessionId\` and \`remainingThoughts\`.
+3. **MUST continue**: Call again with \`{ sessionId: "<id>", thought: "..." }\`.
+4. Repeat until \`status: "completed"\` or \`remainingThoughts: 0\`.
+   NOTE: \`summary\` field contains the exact next call.
+
+### WORKFLOW B: Multi-Turn Reasoning
+1. Call \`reasoning_think\` with \`{ query: "...", level: "normal", thought: "..." }\`.
+2. Call \`reasoning_think\` with \`{ sessionId: "<id>", thought: "..." }\` (optional: add \`query\` for follow-up).
+3. Repeat until completed. Read \`reasoning://sessions/{sessionId}\` for full chain.
+   NOTE: \`level\` is optional when continuing; session level is used if omitted.
+
+### WORKFLOW C: Controlled Depth
+1. Call \`reasoning_think\` with \`{ query: "...", level: "normal", targetThoughts: 8, thought: "..." }\`.
+2. Repeat with \`sessionId\` and \`thought\` until \`totalThoughts\` reached.
+   NOTE: \`targetThoughts\` must fit level range (basic: 3-5, normal: 6-10, high: 15-25).
+
+### WORKFLOW D: Async Task
+1. Call \`reasoning_think\` as task (send \`task\` field) for long \`high\`-level reasoning.
+2. Poll \`tasks/get\` until \`completed\`/\`failed\`.
+3. Retrieve via \`tasks/result\`.
+4. Abort via \`tasks/cancel\`.
 
 ### 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
+1. Start session with \`targetThoughts\` and \`runMode: "run_to_completion"\`.
+2. Provide \`thought\` as string array (e.g., \`["step1", "step2"]\`).
+3. Server consumes inputs until completion, token exhaustion, or cancellation.
+
+### WORKFLOW F: Structured Reasoning
+1. Call \`reasoning_think\` with \`{ query: "...", level: "normal", observation: "...", hypothesis: "...", evaluation: "..." }\`.
+2. Server formats into structured thought in trace.
+3. Continue with \`sessionId\` using \`thought\` or structured fields.
+4. Use \`is_conclusion: true\` to end early, or \`rollback_to_step\` to discard/redo.
+</workflows>
+
+<constraints>
 ${getSharedConstraints()
         .map((c) => `- ${c}`)
         .join('\n')}
+</constraints>
 
-## Tool Reference
+<tool_reference>
 ${buildToolReference()}
+</tool_reference>
 `;
 }

package/dist/schemas/inputs.d.ts

@@ -13,7 +13,6 @@ export declare const ReasoningThinkInputSchema: z.ZodObject<{
         run_to_completion: "run_to_completion";
     }>>;
     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>;

package/dist/schemas/inputs.js

@@ -17,63 +17,49 @@ function addCustomIssue(ctx, path, message) {
 }
 export const ReasoningThinkInputSchema = z
     .strictObject({
-    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()}.`),
+    query: QUERY_TEXT_SCHEMA.optional().describe('Question or problem to reason about.'),
+    level: LEVEL_SCHEMA.optional().describe(`Reasoning depth level (required for new sessions). ${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.'),
+        .describe('Explicit thought count. Must fit level range.'),
     sessionId: z
         .string()
         .min(1)
         .max(128)
         .optional()
-        .describe('Session ID to continue. The session level is used when continuing; provided level is optional.'),
+        .describe('Session ID to continue.'),
     runMode: z
         .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.'),
+        .describe('Execution mode. "step" (default) or "run_to_completion".'),
     thought: z
         .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(THOUGHT_TEXT_SCHEMA)
-        .max(25)
-        .optional()
-        .describe('(Deprecated) Optional additional thought inputs. Use "thought" as an array instead.'),
+        .describe('Full reasoning content for this step. Stored verbatim. String or string array.'),
     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.'),
+        .describe('End session early if final answer reached.'),
     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.'),
+        .describe('0-based thought index to rollback to. Discards subsequent thoughts.'),
     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?'),
+        .describe('1-sentence summary of the conclusion reached.'),
+    observation: z.string().optional().describe('Facts 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?'),
+        .describe('Proposed idea or next logical leap.'),
+    evaluation: z.string().optional().describe('Critique of the hypothesis.'),
 })
     .superRefine((data, ctx) => {
     const runMode = data.runMode ?? DEFAULT_RUN_MODE;
@@ -91,9 +77,6 @@ export const ReasoningThinkInputSchema = z
     if (runMode === 'step' && Array.isArray(data.thought)) {
         addCustomIssue(ctx, ['thought'], 'thought must be a string when runMode is "step"');
     }
-    if (runMode === 'step' && data.thoughts !== undefined) {
-        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 &&

package/dist/schemas/outputs.d.ts

@@ -3,6 +3,7 @@ declare const ReasoningThinkSuccessSchema: z.ZodObject<{
     ok: z.ZodLiteral<true>;
     result: z.ZodObject<{
         sessionId: z.ZodString;
+        query: z.ZodOptional<z.ZodString>;
         level: z.ZodEnum<{
             basic: "basic";
             normal: "normal";
@@ -40,6 +41,7 @@ export declare const ReasoningThinkToolOutputSchema: z.ZodObject<{
     ok: z.ZodBoolean;
     result: z.ZodOptional<z.ZodObject<{
         sessionId: z.ZodString;
+        query: z.ZodOptional<z.ZodString>;
         level: z.ZodEnum<{
             basic: "basic";
             normal: "normal";
@@ -90,6 +92,7 @@ export declare const ReasoningThinkResultSchema: z.ZodUnion<readonly [z.ZodObjec
     ok: z.ZodLiteral<true>;
     result: z.ZodObject<{
         sessionId: z.ZodString;
+        query: z.ZodOptional<z.ZodString>;
         level: z.ZodEnum<{
             basic: "basic";
             normal: "normal";

package/dist/schemas/outputs.js

@@ -13,34 +13,34 @@ const ThoughtSchema = z.strictObject({
     stepSummary: z
         .string()
         .optional()
-        .describe('A 1-sentence summary of the conclusion reached in this step, if provided.'),
+        .describe('1-sentence summary of the conclusion reached.'),
 });
 const ReasoningThinkSuccessSchema = z.strictObject({
     ok: z.literal(true),
     result: z.strictObject({
         sessionId: z.string(),
+        query: z
+            .string()
+            .optional()
+            .describe('Original query text for this session.'),
         level: z.enum(REASONING_LEVELS),
         status: z.enum(SESSION_STATUSES),
         thoughts: z.array(ThoughtSchema),
         generatedThoughts: z.number(),
         requestedThoughts: z.number(),
         totalThoughts: z.number(),
-        tokenBudget: z
-            .number()
-            .describe('Approximate token budget (UTF-8 bytes ÷ 4, not true tokenization)'),
-        tokensUsed: z
-            .number()
-            .describe('Approximate tokens used (UTF-8 bytes ÷ 4, not true tokenization)'),
+        tokenBudget: z.number().describe('Approximate token budget.'),
+        tokensUsed: z.number().describe('Approximate tokens used.'),
         ttlMs: z.number(),
         expiresAt: z.number(),
         createdAt: z.number(),
         updatedAt: z.number(),
         remainingThoughts: z
             .number()
-            .describe('Number of thoughts remaining before the session reaches totalThoughts'),
+            .describe('Thoughts remaining before reaching totalThoughts.'),
         summary: z
             .string()
-            .describe('Actionable next-step instruction when active, or completion status when done'),
+            .describe('Actionable next-step instruction or completion status.'),
     }),
 });
 const ReasoningThinkErrorSchema = z.strictObject({

package/dist/server.js

@@ -3,6 +3,7 @@ import { findPackageJSON } from 'node:module';
 import { InMemoryTaskStore } from '@modelcontextprotocol/sdk/experimental/tasks';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { engineEvents } from './engine/events.js';
+import { sessionStore } from './engine/reasoner.js';
 import { getErrorMessage } from './lib/errors.js';
 import { registerAllTools } from './tools/index.js';
 import { registerAllPrompts } from './prompts/index.js';
@@ -20,6 +21,7 @@ const ICON_URL_CANDIDATES = [
 ];
 let cachedLocalIconData;
 let cachedVersion;
+let activeServerCount = 0;
 function getLocalIconData() {
     if (cachedLocalIconData !== undefined) {
         return cachedLocalIconData ?? undefined;
@@ -119,9 +121,22 @@ function attachEngineEventHandlers(server) {
             process.stderr.write(`[cortex-mcp.server] Failed to log budget_exhausted: ${getErrorMessage(err)}\n`);
         });
     };
+    const onSessionLifecycle = (data) => {
+        void server.server.sendResourceListChanged().catch((err) => {
+            logNotificationFailure(RESOURCE_LIST_CHANGED_METHOD, err, {
+                sessionId: data.sessionId,
+            });
+        });
+    };
     engineEvents.on('resources:changed', onResourcesChanged);
     engineEvents.on('resource:updated', onResourceUpdated);
     engineEvents.on('thought:budget-exhausted', onBudgetExhausted);
+    engineEvents.on('session:created', onSessionLifecycle);
+    engineEvents.on('session:completed', onSessionLifecycle);
+    engineEvents.on('session:cancelled', onSessionLifecycle);
+    engineEvents.on('session:expired', onSessionLifecycle);
+    engineEvents.on('session:evicted', onSessionLifecycle);
+    engineEvents.on('session:deleted', onSessionLifecycle);
     let detached = false;
     return () => {
         if (detached) {
@@ -131,6 +146,12 @@ function attachEngineEventHandlers(server) {
         engineEvents.off('resources:changed', onResourcesChanged);
         engineEvents.off('resource:updated', onResourceUpdated);
         engineEvents.off('thought:budget-exhausted', onBudgetExhausted);
+        engineEvents.off('session:created', onSessionLifecycle);
+        engineEvents.off('session:completed', onSessionLifecycle);
+        engineEvents.off('session:cancelled', onSessionLifecycle);
+        engineEvents.off('session:expired', onSessionLifecycle);
+        engineEvents.off('session:evicted', onSessionLifecycle);
+        engineEvents.off('session:deleted', onSessionLifecycle);
     };
 }
 function installCloseCleanup(server, cleanup) {
@@ -142,10 +163,18 @@ function installCloseCleanup(server, cleanup) {
         }
         closed = true;
         cleanup();
+        activeServerCount = Math.max(0, activeServerCount - 1);
+        if (activeServerCount === 0) {
+            sessionStore.dispose();
+        }
         await originalClose();
     };
 }
 export function createServer() {
+    if (activeServerCount === 0) {
+        sessionStore.ensureCleanupTimer();
+    }
+    activeServerCount += 1;
     const version = loadVersion();
     const taskStore = new InMemoryTaskStore();
     const localIcon = getLocalIconData();

package/dist/tools/reasoning-think.js

@@ -6,13 +6,30 @@ import { createTaskLimiter } from '../lib/concurrency.js';
 import { createErrorResponse, getErrorMessage, InsufficientThoughtsError, InvalidRunModeArgsError, isObjectRecord, ReasoningAbortedError, ReasoningError, ServerBusyError, SessionNotFoundError, } from '../lib/errors.js';
 import { formatProgressMessage, formatThoughtsToMarkdown, } from '../lib/formatting.js';
 import { createToolResponse, withIconMeta } from '../lib/tool-response.js';
-import { parsePositiveIntEnv } from '../lib/validators.js';
+import { parseBooleanEnv, parsePositiveIntEnv } from '../lib/validators.js';
 const DEFAULT_MAX_ACTIVE_REASONING_TASKS = 32;
+const REDACTED_THOUGHT_CONTENT = '[REDACTED]';
+function shouldRedactTraceContent() {
+    return parseBooleanEnv('CORTEX_REDACT_TRACE_CONTENT', false);
+}
 function buildTraceResource(session) {
+    const sessionView = shouldRedactTraceContent()
+        ? {
+            ...session,
+            thoughts: session.thoughts.map((thought) => ({
+                index: thought.index,
+                content: REDACTED_THOUGHT_CONTENT,
+                revision: thought.revision,
+                ...(thought.stepSummary !== undefined
+                    ? { stepSummary: REDACTED_THOUGHT_CONTENT }
+                    : {}),
+            })),
+        }
+        : session;
     return {
-        uri: `file:///cortex/sessions/${session.id}/trace.md`,
+        uri: `reasoning://sessions/${session.id}/trace.md`,
         mimeType: 'text/markdown',
-        text: formatThoughtsToMarkdown(session),
+        text: formatThoughtsToMarkdown(sessionView),
     };
 }
 const reasoningTaskLimiter = createTaskLimiter(parsePositiveIntEnv('CORTEX_MAX_ACTIVE_REASONING_TASKS', DEFAULT_MAX_ACTIVE_REASONING_TASKS));
@@ -69,7 +86,7 @@ function isReasoningTaskExtra(value) {
     }
     return true;
 }
-function parseReasoningTaskExtra(rawExtra) {
+function assertReasoningTaskExtra(rawExtra) {
     if (!isReasoningTaskExtra(rawExtra)) {
         throw new Error('Invalid task context in request handler.');
     }
@@ -144,7 +161,7 @@ function buildThoughtInputs(params) {
         : params.thought
             ? [params.thought]
             : [];
-    return [...primary, ...(params.thoughts ?? [])];
+    return primary;
 }
 function getStartingThoughtCount(sessionId) {
     if (sessionId === undefined) {
@@ -224,6 +241,7 @@ function buildStructuredResult(session, generatedThoughts, targetThoughts) {
         ok: true,
         result: {
             sessionId: session.id,
+            ...(session.query !== undefined ? { query: session.query } : {}),
             level: session.level,
             status: session.status,
             thoughts: [...session.thoughts],
@@ -243,7 +261,7 @@ function buildStructuredResult(session, generatedThoughts, targetThoughts) {
 }
 function buildSummary(session, remainingThoughts) {
     if (session.status === 'completed') {
-        return `Reasoning complete — ${String(session.thoughts.length)} thoughts at [${session.level}] level. Session ${session.id}.`;
+        return `Reasoning complete — ${String(session.thoughts.length)} thought${session.thoughts.length === 1 ? '' : 's'} at [${session.level}] level. Session ${session.id}.`;
     }
     if (session.status === 'cancelled') {
         return `Reasoning cancelled at thought ${String(session.thoughts.length)}/${String(session.totalThoughts)}. Session ${session.id}.`;
@@ -283,16 +301,22 @@ function createCancellationController(signal) {
     const controller = new AbortController();
     if (signal.aborted) {
         controller.abort();
-        return controller;
+        return {
+            controller,
+            cleanup: () => {
+                // No listener to clean up when already aborted.
+            },
+        };
     }
     const onAbort = () => {
         controller.abort();
     };
-    signal.addEventListener('abort', onAbort, { once: true });
-    controller.signal.addEventListener('abort', () => {
+    const cleanup = () => {
         signal.removeEventListener('abort', onAbort);
-    }, { once: true });
-    return controller;
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    controller.signal.addEventListener('abort', cleanup, { once: true });
+    return { controller, cleanup };
 }
 async function isTaskCancelled(taskStore, taskId) {
     try {
@@ -311,7 +335,7 @@ async function ensureTaskIsActive(taskStore, taskId, controller) {
 }
 function createProgressHandler(args) {
     const { server, taskStore, taskId, level, progressToken, controller, startingCount, batchTotal, } = args;
-    return async (progress) => {
+    return async (progress, _total, summary) => {
         await ensureTaskIsActive(taskStore, taskId, controller);
         if (progressToken === undefined) {
             return;
@@ -322,14 +346,16 @@ function createProgressHandler(args) {
         const isTerminal = displayProgress >= batchTotal;
         // We must emit if it's the terminal update for this batch,
         // otherwise we respect the session-level skipping rules.
+        // If a summary is provided, we force an emit to show the meaningful update.
         if (!isTerminal &&
+            !summary &&
             !shouldEmitProgress(displayProgress, batchTotal, level)) {
             return;
         }
         const message = formatProgressMessage({
-            toolName: TOOL_NAME,
+            toolName: `꩜ ${TOOL_NAME}`,
             context: 'Thought',
-            metadata: `[${String(displayProgress)}/${String(batchTotal)}]`,
+            ...(summary ? { metadata: summary } : {}),
             ...(isTerminal ? { outcome: 'complete' } : {}),
         });
         await notifyProgress({
@@ -457,9 +483,9 @@ async function runReasoningTask(args) {
         const normalizedBatchTotal = Math.max(1, batchTotal);
         if (progressToken !== undefined) {
             const message = formatProgressMessage({
-                toolName: TOOL_NAME,
-                context: 'reasoning',
-                metadata: level ? `starting [${level}]` : 'continuing session',
+                toolName: `꩜ ${TOOL_NAME}`,
+                context: level ? 'starting' : 'continuing',
+                metadata: level ? `[${level}]` : 'session',
             });
             await notifyProgress({
                 server,
@@ -544,7 +570,7 @@ async function runReasoningTask(args) {
 }
 function getTaskId(extra) {
     if (typeof extra.taskId !== 'string' || extra.taskId.length === 0) {
-        throw new Error('Task ID missing in request context.');
+        throw new InvalidRunModeArgsError('Task ID missing in request context.');
     }
     return extra.taskId;
 }
@@ -565,7 +591,8 @@ Use step_summary for a 1-sentence conclusion per step — these accumulate in th
 
 Levels: ${getLevelDescriptionString()}.
 Alternatives: runMode="run_to_completion" (batch), or observation/hypothesis/evaluation fields (structured).
-Errors: E_SESSION_NOT_FOUND (expired — start new), E_INVALID_THOUGHT_COUNT (check level ranges).`,
+Errors: E_SESSION_NOT_FOUND (expired — start new), E_INVALID_THOUGHT_COUNT (check level ranges).
+Protocol validation: malformed task metadata/arguments fail at request level before task start; runtime reasoning failures return tool isError=true payloads.`,
         inputSchema: ReasoningThinkInputSchema,
         outputSchema: ReasoningThinkToolOutputSchema,
         annotations: {
@@ -586,7 +613,7 @@ Errors: E_SESSION_NOT_FOUND (expired — start new), E_INVALID_THOUGHT_COUNT (ch
                 throw new Error(`Invalid reasoning_think params: ${parseResult.error.message}`);
             }
             const params = parseResult.data;
-            const extra = parseReasoningTaskExtra(rawExtra);
+            const extra = assertReasoningTaskExtra(rawExtra);
             const progressToken = extra._meta?.progressToken;
             if (!reasoningTaskLimiter.tryAcquire()) {
                 throw new ServerBusyError();
@@ -602,13 +629,13 @@ Errors: E_SESSION_NOT_FOUND (expired — start new), E_INVALID_THOUGHT_COUNT (ch
                 reasoningTaskLimiter.release();
                 throw error;
             }
-            const controller = createCancellationController(extra.signal);
+            const cancellation = createCancellationController(extra.signal);
             const runReasoningArgs = {
                 server,
                 taskStore: extra.taskStore,
                 taskId: task.taskId,
                 params,
-                controller,
+                controller: cancellation.controller,
             };
             if (progressToken !== undefined) {
                 runReasoningArgs.progressToken = progressToken;
@@ -617,16 +644,17 @@ Errors: E_SESSION_NOT_FOUND (expired — start new), E_INVALID_THOUGHT_COUNT (ch
                 runReasoningArgs.sessionId = extra.sessionId;
             }
             void runReasoningTask(runReasoningArgs).finally(() => {
+                cancellation.cleanup();
                 reasoningTaskLimiter.release();
             });
             return { task };
         },
         getTask(_params, rawExtra) {
-            const extra = parseReasoningTaskExtra(rawExtra);
+            const extra = assertReasoningTaskExtra(rawExtra);
             return extra.taskStore.getTask(getTaskId(extra));
         },
         async getTaskResult(_params, rawExtra) {
-            const extra = parseReasoningTaskExtra(rawExtra);
+            const extra = assertReasoningTaskExtra(rawExtra);
             const result = await extra.taskStore.getTaskResult(getTaskId(extra));
             assertCallToolResult(result);
             return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/cortex-mcp",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "mcpName": "io.github.j0hanz/cortex-mcp",
   "author": "Johanz",
   "license": "MIT",