@j0hanz/thinkseq-mcp 1.2.7 → 2.0.0

package/README.md

@@ -133,6 +133,7 @@ Record a concise thinking step. Be brief: capture only the essential insight, ca
 | Field            | Type   | Required | Description                                                        |
 | :--------------- | :----- | :------: | :----------------------------------------------------------------- |
 | `thought`        | string |   yes    | Current thinking step (1-8000 chars).                              |
+| `sessionId`      | string |    no    | Optional session identifier to isolate thought histories.          |
 | `totalThoughts`  | number |    no    | Estimated total thoughts (1-25, default: 3).                       |
 | `revisesThought` | number |    no    | Revise a previous thought by number. Original preserved for audit. |
 

package/dist/app.d.ts

@@ -1,4 +1,5 @@
-import { type ProcessLike, type RunDependencies } from './appConfig.js';
+import type { RunDependencies } from './appConfig/runDependencies.js';
+import type { ProcessLike } from './appConfig/types.js';
 interface ProcessErrorHandlerDeps {
     processLike?: ProcessLike;
     logError?: (message: string) => void;

package/dist/app.js

@@ -1,4 +1,5 @@
-import { buildShutdownDependencies, resolvePackageIdentity, resolveRunDependencies, } from './appConfig.js';
+import { resolvePackageIdentity, resolveRunDependencies, } from './appConfig/runDependencies.js';
+import { buildShutdownDependencies } from './appConfig/shutdown.js';
 import { installConsoleBridge, installMcpLogging } from './lib/mcpLogging.js';
 const toError = (value) => value instanceof Error ? value : new Error(String(value));
 const createExit = (proc, exit) => exit ?? ((code) => proc.exit(code));
@@ -21,7 +22,8 @@ export async function run(deps = {}) {
     const { name, version } = resolvePackageIdentity(pkg);
     const server = resolved.createServer(name, version);
     installMcpLogging(server);
-    installConsoleBridge(server);
+    const { flush: flushConsole, restore: restoreConsole } = installConsoleBridge(server);
+    process.on('exit', restoreConsole);
     resolved.publishLifecycleEvent({
         type: 'lifecycle.started',
         ts: resolved.now(),
@@ -29,5 +31,6 @@ export async function run(deps = {}) {
     const engine = resolved.engineFactory();
     resolved.registerTool(server, engine);
     const transport = await resolved.connectServer(server);
+    flushConsole();
     resolved.installShutdownHandlers(buildShutdownDependencies(resolved, { server, engine, transport }));
 }

package/dist/appConfig/runDependencies.js

@@ -23,7 +23,17 @@ function loadServerInstructions() {
     return trimmed.length > 0 ? trimmed : INSTRUCTIONS_FALLBACK;
 }
 function registerInstructionsResource(server) {
-    server.registerResource('instructions', new ResourceTemplate('internal://instructions', { list: undefined }), { title: 'Instructions', mimeType: 'text/markdown' }, (uri) => ({
+    server.registerResource('instructions', new ResourceTemplate('internal://instructions', {
+        list: () => ({
+            resources: [
+                {
+                    uri: 'internal://instructions',
+                    name: 'Instructions',
+                    mimeType: 'text/markdown',
+                },
+            ],
+        }),
+    }), { title: 'Instructions', mimeType: 'text/markdown' }, (uri) => ({
         contents: [
             {
                 uri: uri.href,
@@ -40,7 +50,7 @@ function buildServerConfig() {
         instructions: SERVER_INSTRUCTIONS,
         capabilities: {
             logging: {},
-            tools: { listChanged: true },
+            tools: { listChanged: false },
             resources: { subscribe: false, listChanged: false },
             prompts: { listChanged: false },
         },

package/dist/engine/revision.d.ts

@@ -1,8 +1,10 @@
 import type { ProcessResult, StoredThought, ThoughtData } from '../lib/types.js';
-export declare function resolveRevisionTarget(input: ThoughtData, getThoughtByNumber: (thoughtNumber: number) => StoredThought | undefined): {
+export type RevisionTargetResolution = {
     ok: true;
     targetNumber: number;
+    target: StoredThought;
 } | {
     ok: false;
-    error: ProcessResult;
+    result: ProcessResult;
 };
+export declare function resolveRevisionTarget(input: ThoughtData, getThoughtByNumber: (thoughtNumber: number) => StoredThought | undefined): RevisionTargetResolution;

package/dist/engine/revision.js

@@ -1,26 +1,31 @@
+function missingRevisionError() {
+    return {
+        ok: false,
+        result: buildRevisionError('E_REVISION_MISSING', 'revisesThought is required for revision'),
+    };
+}
+function targetNotFoundError(targetNumber) {
+    return {
+        ok: false,
+        result: buildRevisionError('E_REVISION_TARGET_NOT_FOUND', `Thought ${targetNumber} not found`),
+    };
+}
+function targetSupersededError(targetNumber) {
+    return {
+        ok: false,
+        result: buildRevisionError('E_REVISION_TARGET_SUPERSEDED', `Thought ${targetNumber} was already superseded`),
+    };
+}
 export function resolveRevisionTarget(input, getThoughtByNumber) {
     const targetNumber = input.revisesThought;
-    if (targetNumber === undefined) {
-        return {
-            ok: false,
-            error: buildRevisionError('E_REVISION_MISSING', 'revisesThought is required for revision'),
-        };
-    }
-    const validationError = validateRevisionTarget(getThoughtByNumber, targetNumber);
-    if (validationError) {
-        return { ok: false, error: validationError };
-    }
-    return { ok: true, targetNumber };
-}
-function validateRevisionTarget(getThoughtByNumber, targetNumber) {
+    if (targetNumber === undefined)
+        return missingRevisionError();
     const target = getThoughtByNumber(targetNumber);
-    if (!target) {
-        return buildRevisionError('E_REVISION_TARGET_NOT_FOUND', `Thought ${targetNumber} not found`);
-    }
-    if (!target.isActive) {
-        return buildRevisionError('E_REVISION_TARGET_SUPERSEDED', `Thought ${targetNumber} was already superseded`);
-    }
-    return undefined;
+    if (!target)
+        return targetNotFoundError(targetNumber);
+    if (!target.isActive)
+        return targetSupersededError(targetNumber);
+    return { ok: true, targetNumber, target };
 }
 function buildRevisionError(code, message) {
     return {

package/dist/engine/thoughtQueries.js

@@ -1,31 +1,39 @@
+const MAX_PREVIEW_CHARS = 100;
+const MAX_RECENT_THOUGHTS = 5;
+const RECENT_TAIL_COUNT = 4;
 function selectRecentThoughts(activeThoughts) {
-    if (activeThoughts.length <= 5) {
-        const recent = activeThoughts.slice();
-        const stepIndexes = recent.map((_, index) => index + 1);
-        return { recent, stepIndexes };
+    const len = activeThoughts.length;
+    const recent = [];
+    const stepIndexes = [];
+    if (len > MAX_RECENT_THOUGHTS) {
+        const anchor = activeThoughts[0];
+        if (!anchor)
+            throw new Error('Invariant violation: anchor thought missing');
+        recent.push(anchor);
+        stepIndexes.push(1);
+    }
+    const start = len <= MAX_RECENT_THOUGHTS ? 0 : Math.max(0, len - RECENT_TAIL_COUNT);
+    for (let i = start; i < len; i += 1) {
+        const thought = activeThoughts[i];
+        if (thought) {
+            recent.push(thought);
+            stepIndexes.push(i + 1);
+        }
     }
-    const anchor = activeThoughts[0];
-    if (!anchor)
-        throw new Error('Invariant violation: anchor thought missing');
-    const tail = activeThoughts.slice(-4);
-    const recent = [anchor, ...tail];
-    const stepIndexes = [
-        1,
-        ...tail.map((_, index) => activeThoughts.length - 4 + index + 1),
-    ];
     return { recent, stepIndexes };
 }
-function formatThoughtPreview(thought) {
-    if (thought.length <= 100)
-        return thought;
-    return `${thought.slice(0, 100)}...`;
+function truncatePreview(input, maxChars) {
+    const codepoints = Array.from(input);
+    if (codepoints.length <= maxChars)
+        return input;
+    return `${codepoints.slice(0, maxChars).join('')}...`;
 }
 export function buildContextSummary(activeThoughts, revisionInfo) {
     const { recent, stepIndexes } = selectRecentThoughts(activeThoughts);
     const recentThoughts = recent.map((thought, index) => ({
         stepIndex: stepIndexes[index] ?? index + 1,
         number: thought.thoughtNumber,
-        preview: formatThoughtPreview(thought.thought),
+        preview: truncatePreview(thought.thought, MAX_PREVIEW_CHARS),
     }));
     if (revisionInfo !== undefined) {
         return { recentThoughts, revisionInfo };

package/dist/engine/thoughtStore.d.ts

@@ -4,6 +4,12 @@ export interface ThoughtStoreOptions {
     maxMemoryBytes: number;
     estimatedThoughtOverheadBytes: number;
 }
+export interface PruneStats {
+    truncatedActive: boolean;
+    droppedActiveCount: number;
+    removedThoughtsCount: number;
+    oldestAvailableThoughtNumber: number | null;
+}
 export declare class ThoughtStore {
     #private;
     constructor(options: ThoughtStoreOptions);
@@ -11,6 +17,7 @@ export declare class ThoughtStore {
         thoughtNumber: number;
         totalThoughts: number;
     };
+    getLastPruneStats(): PruneStats | null;
     storeThought(stored: StoredThought): void;
     supersedeFrom(targetNumber: number, supersededBy: number, maxSupersedes?: number): {
         supersedes: number[];

package/dist/engine/thoughtStore.js

@@ -8,6 +8,7 @@ export class ThoughtStore {
     #headIndex = 0;
     #nextThoughtNumber = 1;
     #estimatedBytes = 0;
+    #lastPruneStats = null;
     #maxThoughts;
     #maxMemoryBytes;
     #estimatedThoughtOverheadBytes;
@@ -19,11 +20,11 @@ export class ThoughtStore {
     nextThoughtNumbers(totalThoughts) {
         const thoughtNumber = this.#nextThoughtNumber;
         this.#nextThoughtNumber += 1;
-        const effectiveTotalThoughts = Math.max(totalThoughts, thoughtNumber, this.#activeMaxTotalThoughts);
-        return {
-            thoughtNumber,
-            totalThoughts: effectiveTotalThoughts,
-        };
+        const effectiveTotalThoughts = Math.max(totalThoughts, this.#activeMaxTotalThoughts);
+        return { thoughtNumber, totalThoughts: effectiveTotalThoughts };
+    }
+    getLastPruneStats() {
+        return this.#lastPruneStats;
     }
     storeThought(stored) {
         this.#thoughts.push(stored);
@@ -42,29 +43,39 @@ export class ThoughtStore {
         }
         this.#activeMaxTotalThoughts = maxTotal;
     }
-    #findActiveThoughtIndex(thoughtNumber) {
+    #findActiveLowerBound(thoughtNumber) {
         const activeThoughtNumbers = this.#activeThoughtNumbers;
         let low = 0;
         let high = activeThoughtNumbers.length;
         while (low < high) {
             const mid = (low + high) >>> 1;
             const midValue = activeThoughtNumbers[mid];
-            if (midValue === undefined) {
+            if (midValue === undefined)
                 return -1;
-            }
-            if (midValue < thoughtNumber) {
+            if (midValue < thoughtNumber)
                 low = mid + 1;
-            }
-            else {
+            else
                 high = mid;
-            }
-        }
-        if (low < activeThoughtNumbers.length &&
-            activeThoughtNumbers[low] === thoughtNumber) {
-            return low;
         }
+        return low;
+    }
+    #findActiveThoughtIndex(thoughtNumber) {
+        const index = this.#findActiveLowerBound(thoughtNumber);
+        if (index < 0)
+            return -1;
+        if (index < this.#activeThoughtNumbers.length &&
+            this.#activeThoughtNumbers[index] === thoughtNumber)
+            return index;
         return -1;
     }
+    #findFirstActiveIndexAfter(thoughtNumber) {
+        const index = this.#findActiveLowerBound(thoughtNumber);
+        if (index < 0)
+            return 0;
+        if (this.#activeThoughtNumbers[index] === thoughtNumber)
+            return index + 1;
+        return index;
+    }
     supersedeFrom(targetNumber, supersededBy, maxSupersedes) {
         const startIndex = this.#findActiveThoughtIndex(targetNumber);
         if (startIndex < 0)
@@ -110,6 +121,18 @@ export class ThoughtStore {
         return this.#thoughts.length - this.#headIndex;
     }
     pruneHistoryIfNeeded() {
+        const beforeTotal = this.getTotalLength();
+        const beforeActive = this.#activeThoughts.length;
+        this.#lastPruneStats = {
+            truncatedActive: false,
+            droppedActiveCount: 0,
+            removedThoughtsCount: 0,
+            oldestAvailableThoughtNumber: this.#thoughts[this.#headIndex]?.thoughtNumber ?? null,
+        };
+        this.#performPruning();
+        this.#updatePruneStats(beforeTotal, beforeActive);
+    }
+    #performPruning() {
         const excess = this.getTotalLength() - this.#maxThoughts;
         if (excess > 0) {
             const batch = Math.max(excess, Math.ceil(this.#maxThoughts * 0.1));
@@ -121,19 +144,24 @@ export class ThoughtStore {
             this.#removeOldest(toRemove, { forceCompact: true });
         }
     }
+    #updatePruneStats(beforeTotal, beforeActive) {
+        if (!this.#lastPruneStats)
+            return;
+        const afterActive = this.#activeThoughts.length;
+        const stats = this.#lastPruneStats;
+        stats.removedThoughtsCount = Math.max(0, beforeTotal - this.getTotalLength());
+        stats.droppedActiveCount = Math.max(0, beforeActive - afterActive);
+        stats.truncatedActive = stats.droppedActiveCount > 0;
+        stats.oldestAvailableThoughtNumber =
+            this.#thoughts[this.#headIndex]?.thoughtNumber ?? null;
+    }
     #estimateThoughtBytes(thought) {
-        return thought.thought.length * 2 + this.#estimatedThoughtOverheadBytes;
+        return thought.byteLength + this.#estimatedThoughtOverheadBytes;
     }
     #dropActiveThoughtsUpTo(thoughtNumber) {
         if (this.#activeThoughts.length === 0)
             return;
-        let startIndex = 0;
-        while (startIndex < this.#activeThoughts.length) {
-            const thought = this.#activeThoughts[startIndex];
-            if (!thought || thought.thoughtNumber > thoughtNumber)
-                break;
-            startIndex += 1;
-        }
+        const startIndex = this.#findFirstActiveIndexAfter(thoughtNumber);
         if (startIndex === 0)
             return;
         this.#activeThoughts = this.#activeThoughts.slice(startIndex);
@@ -198,5 +226,6 @@ export class ThoughtStore {
         this.#headIndex = 0;
         this.#nextThoughtNumber = 1;
         this.#estimatedBytes = 0;
+        this.#lastPruneStats = null;
     }
 }

package/dist/engine.d.ts

@@ -3,10 +3,12 @@ export interface ThinkingEngineOptions {
     maxThoughts?: number;
     maxMemoryBytes?: number;
     estimatedThoughtOverheadBytes?: number;
+    maxSessions?: number;
 }
 export declare class ThinkingEngine {
     #private;
     static readonly DEFAULT_TOTAL_THOUGHTS = 3;
     constructor(options?: ThinkingEngineOptions);
     processThought(input: ThoughtData): ProcessResult;
+    processThoughtWithSession(sessionId: string, input: ThoughtData): ProcessResult;
 }

package/dist/engine.js

@@ -4,42 +4,88 @@ import { buildContextSummary } from './engine/thoughtQueries.js';
 import { ThoughtStore } from './engine/thoughtStore.js';
 import { DEFAULT_MAX_THOUGHTS, ESTIMATED_THOUGHT_OVERHEAD_BYTES, MAX_MEMORY_BYTES, MAX_REVISABLE_THOUGHTS, MAX_SUPERSEDES, MAX_THOUGHTS_CAP, normalizeInt, } from './engineConfig.js';
 export class ThinkingEngine {
-    #store;
-    #hasRevisions = false;
     static DEFAULT_TOTAL_THOUGHTS = 3;
+    #maxThoughts;
+    #maxMemoryBytes;
+    #estimatedThoughtOverheadBytes;
+    #maxSessions;
+    #sessions = new Map();
     constructor(options = {}) {
-        const maxThoughts = normalizeInt(options.maxThoughts, DEFAULT_MAX_THOUGHTS, { min: 1, max: MAX_THOUGHTS_CAP });
-        const maxMemoryBytes = normalizeInt(options.maxMemoryBytes, MAX_MEMORY_BYTES, { min: 1, max: Number.MAX_SAFE_INTEGER });
-        const estimatedThoughtOverheadBytes = normalizeInt(options.estimatedThoughtOverheadBytes, ESTIMATED_THOUGHT_OVERHEAD_BYTES, { min: 1, max: Number.MAX_SAFE_INTEGER });
-        this.#store = new ThoughtStore({
-            maxThoughts,
-            maxMemoryBytes,
-            estimatedThoughtOverheadBytes,
+        this.#maxThoughts = normalizeInt(options.maxThoughts, DEFAULT_MAX_THOUGHTS, { min: 1, max: MAX_THOUGHTS_CAP });
+        this.#maxMemoryBytes = normalizeInt(options.maxMemoryBytes, MAX_MEMORY_BYTES, { min: 1, max: Number.MAX_SAFE_INTEGER });
+        this.#estimatedThoughtOverheadBytes = normalizeInt(options.estimatedThoughtOverheadBytes, ESTIMATED_THOUGHT_OVERHEAD_BYTES, { min: 1, max: Number.MAX_SAFE_INTEGER });
+        this.#maxSessions = normalizeInt(options.maxSessions, 50, {
+            min: 1,
+            max: 10_000,
         });
+        this.#getSession('default');
     }
     processThought(input) {
+        return this.processThoughtWithSession('default', input);
+    }
+    processThoughtWithSession(sessionId, input) {
+        const session = this.#getSession(sessionId);
         if (input.revisesThought !== undefined) {
-            return this.#processRevision(input);
+            return this.#processRevision(session, input);
+        }
+        return this.#processNewThought(session, input);
+    }
+    #getSession(sessionId) {
+        const key = sessionId.trim() || 'default';
+        const existing = this.#sessions.get(key);
+        if (existing) {
+            // bump to most-recent for LRU eviction
+            this.#sessions.delete(key);
+            this.#sessions.set(key, existing);
+            return existing;
+        }
+        const state = {
+            store: new ThoughtStore({
+                maxThoughts: this.#maxThoughts,
+                maxMemoryBytes: this.#maxMemoryBytes,
+                estimatedThoughtOverheadBytes: this.#estimatedThoughtOverheadBytes,
+            }),
+            hasRevisions: false,
+        };
+        this.#sessions.set(key, state);
+        this.#evictSessionsIfNeeded();
+        return state;
+    }
+    #evictSessionsIfNeeded() {
+        while (this.#sessions.size > this.#maxSessions) {
+            const oldestKey = this.#sessions.keys().next().value;
+            if (!oldestKey)
+                return;
+            if (oldestKey === 'default') {
+                const def = this.#sessions.get('default');
+                if (!def)
+                    return;
+                this.#sessions.delete('default');
+                this.#sessions.set('default', def);
+                continue;
+            }
+            this.#sessions.delete(oldestKey);
         }
-        return this.#processNewThought(input);
     }
-    #processNewThought(input) {
-        const { stored } = this.#createStoredThought(input);
-        this.#commitThought(stored);
-        return this.#buildProcessResult(stored);
+    #processNewThought(session, input) {
+        const { stored } = this.#createStoredThought(session.store, input);
+        this.#commitThought(session.store, stored);
+        return this.#buildProcessResult(session, stored);
     }
-    #processRevision(input) {
-        const resolved = resolveRevisionTarget(input, (thoughtNumber) => this.#store.getThoughtByNumber(thoughtNumber));
+    #processRevision(session, input) {
+        const { store } = session;
+        const resolved = resolveRevisionTarget(input, (thoughtNumber) => store.getThoughtByNumber(thoughtNumber));
         if (!resolved.ok)
-            return resolved.error;
+            return resolved.result;
         const { targetNumber } = resolved;
-        const { numbers, stored } = this.#createStoredThought(input, {
+        const { numbers, stored } = this.#createStoredThought(store, input, {
             revisionOf: targetNumber,
+            fallbackTotalThoughts: resolved.target.totalThoughts,
         });
-        const { supersedes, supersedesTotal } = this.#store.supersedeFrom(targetNumber, numbers.thoughtNumber, MAX_SUPERSEDES);
-        this.#hasRevisions = true;
-        this.#commitThought(stored);
-        return this.#buildProcessResult(stored, {
+        const { supersedes, supersedesTotal } = store.supersedeFrom(targetNumber, numbers.thoughtNumber, MAX_SUPERSEDES);
+        session.hasRevisions = true;
+        this.#commitThought(store, stored);
+        return this.#buildProcessResult(session, stored, {
             revises: targetNumber,
             supersedes,
             supersedesTotal,
@@ -58,53 +104,60 @@ export class ThinkingEngine {
             ...(details.revisionOf !== undefined && {
                 revisionOf: details.revisionOf,
             }),
+            byteLength: Buffer.byteLength(input.thought),
         };
     }
-    #createStoredThought(input, extras = {}) {
-        const effectiveTotalThoughts = this.#resolveEffectiveTotalThoughts(input);
-        const numbers = this.#store.nextThoughtNumbers(effectiveTotalThoughts);
+    #createStoredThought(store, input, extras = {}) {
+        const effectiveTotalThoughts = this.#resolveEffectiveTotalThoughts(store, input, extras.fallbackTotalThoughts);
+        const numbers = store.nextThoughtNumbers(effectiveTotalThoughts);
         const stored = this.#buildStoredThought(input, {
             ...numbers,
-            ...extras,
+            ...(extras.revisionOf !== undefined && { revisionOf: extras.revisionOf }),
         });
         return { stored, numbers };
     }
-    #commitThought(stored) {
-        this.#store.storeThought(stored);
-        this.#store.pruneHistoryIfNeeded();
+    #commitThought(store, stored) {
+        store.storeThought(stored);
+        store.pruneHistoryIfNeeded();
     }
-    #resolveEffectiveTotalThoughts(input) {
+    #resolveEffectiveTotalThoughts(store, input, fallback) {
         if (input.totalThoughts !== undefined) {
             return normalizeInt(input.totalThoughts, _a.DEFAULT_TOTAL_THOUGHTS, { min: 1, max: MAX_THOUGHTS_CAP });
         }
-        const activeThoughts = this.#store.getActiveThoughts();
+        if (fallback !== undefined)
+            return fallback;
+        const activeThoughts = store.getActiveThoughts();
         const lastActive = activeThoughts[activeThoughts.length - 1];
         if (lastActive !== undefined) {
             return lastActive.totalThoughts;
         }
         return _a.DEFAULT_TOTAL_THOUGHTS;
     }
-    #buildProcessResult(stored, revisionInfo) {
-        const activeThoughts = this.#store.getActiveThoughts();
-        const context = buildContextSummary(activeThoughts, revisionInfo);
-        const isComplete = stored.thoughtNumber >= stored.totalThoughts;
-        const revisableThoughtsTotal = activeThoughts.length;
-        const revisableThoughts = this.#store.getActiveThoughtNumbers(MAX_REVISABLE_THOUGHTS);
+    #buildProcessResult(session, stored, revisionInfo) {
+        const activeThoughts = session.store.getActiveThoughts();
+        const activePathLength = activeThoughts.length;
+        const { progress, isComplete } = this.#calculateMetrics(activePathLength, stored.totalThoughts);
         return {
             ok: true,
             result: {
                 thoughtNumber: stored.thoughtNumber,
                 totalThoughts: stored.totalThoughts,
-                progress: Math.min(1, stored.thoughtNumber / stored.totalThoughts),
+                progress,
                 isComplete,
-                thoughtHistoryLength: this.#store.getTotalLength(),
-                hasRevisions: this.#hasRevisions,
-                activePathLength: activeThoughts.length,
-                revisableThoughts,
-                revisableThoughtsTotal,
-                context,
+                thoughtHistoryLength: session.store.getTotalLength(),
+                hasRevisions: session.hasRevisions,
+                activePathLength,
+                revisableThoughts: session.store.getActiveThoughtNumbers(MAX_REVISABLE_THOUGHTS),
+                revisableThoughtsTotal: activePathLength,
+                context: buildContextSummary(activeThoughts, revisionInfo),
             },
         };
     }
+    #calculateMetrics(active, total) {
+        return {
+            progress: total > 0 ? Math.min(1, active / total) : 1,
+            isComplete: active >= total,
+        };
+    }
 }
 _a = ThinkingEngine;

package/dist/instructions.md

@@ -1,11 +1,16 @@
 # ThinkSeq Instructions
 
-> **Guidance for the Agent:** These instructions are available as a resource (`internal://instructions`). Load them when you are confused about tool usage.
+<!-- Path: [src/instructions.md](src/instructions.md) -->
+
+> Guidance for the Agent: These instructions are available as a resource (`internal://instructions`) or prompt (`get-help`). Load them when you are unsure about tool usage.
 
 ## 1. Core Capability
 
-- **Domain:** In-memory, sequential thinking with revision (destructive rewind).
+- **Domain:** In-memory, sequential thinking with revision (destructive rewind) per session.
 - **Primary Resources:** `Thoughts`, `RevisionChain`, `ProgressContext`.
+- **Tools:**
+  - **Read:** none.
+  - **Write:** `thinkseq` (records and revises thoughts).
 
 ## 2. The "Golden Path" Workflows (Critical)
 
@@ -13,30 +18,31 @@ _Follow this order; do not guess indices._
 
 ### Workflow A: Capture a reasoning chain
 
-1. Call `thinkseq` with `thought` (and optionally `totalThoughts`).
+1. Call `thinkseq` with `thought` (optionally `totalThoughts`, `sessionId`).
 2. Continue calling `thinkseq` for each step.
-3. Read `progress` and `isComplete` from the response to know when to stop.
-   > **Constraint:** Keep each step atomic; one decision per call.
+3. Read `progress` and `isComplete` to know when to stop.
+   > Constraint: Keep each step atomic; one decision per call.
 
 ### Workflow B: Revise a prior step
 
 1. Call `thinkseq` to get the latest `revisableThoughts` list.
 2. Call `thinkseq` again with `revisesThought` set to a valid entry.
 3. Continue from the revised step.
-   > **Constraint:** Never guess `revisesThought`; always pick from `revisableThoughts`.
+   > Constraint: Never guess `revisesThought`; always pick from `revisableThoughts`.
 
-## 3. Tool Nuances & "Gotchas"
+## 3. Tool Nuances & Gotchas
 
-_Do NOT repeat the JSON Schema. Focus on behavior._
+_Do NOT repeat the JSON Schema. Focus on behavior and pitfalls._
 
-- **`thinkseq`**:
-  - **Side Effects:** Mutates in-memory thought history (write operation).
-  - **Limits:** `thought` max 8000 chars; `totalThoughts` max 25.
-  - **Revisions:** Revising a thought supersedes that step and all later active steps.
-  - **Compatibility:** Set `THINKSEQ_INCLUDE_TEXT_CONTENT=0|false|no|off` to omit the JSON string in `content`.
+- **`thinkseq`**
+  - **Purpose:** Append or revise a thought in the current session.
+  - **Inputs:** `thought` (1–8000 chars), `totalThoughts` (1–25), `sessionId` (1–200), `revisesThought` (int ≥ 1).
+  - **Side effects:** Mutates in-memory thought history; revisions supersede the target and later active thoughts.
+  - **Defaults:** If `totalThoughts` is omitted, the engine uses 3 or the last active total.
+  - **Compatibility:** Set `THINKSEQ_INCLUDE_TEXT_CONTENT=0|false|no|off` to omit JSON string content.
 
 ## 4. Error Handling Strategy
 
-- If `E_REVISION_TARGET_NOT_FOUND`, fetch a fresh `revisableThoughts` list and retry.
-- If `E_REVISION_TARGET_SUPERSEDED`, revise the latest active thought instead.
-- If `E_THINK`, verify inputs and retry once.
+- On `E_REVISION_MISSING` or `E_REVISION_TARGET_NOT_FOUND`, fetch `revisableThoughts` and retry.
+- On `E_REVISION_TARGET_SUPERSEDED`, revise the latest active thought instead.
+- On `E_THINK`, verify inputs and retry once.

package/dist/lib/mcpLogging.d.ts

@@ -3,4 +3,7 @@ export interface LoggingTarget {
     sendLoggingMessage: (params: LoggingMessageNotificationParams, sessionId?: string) => Promise<void>;
 }
 export declare function installMcpLogging(target: LoggingTarget): () => void;
-export declare function installConsoleBridge(target: LoggingTarget): void;
+export declare function installConsoleBridge(target: LoggingTarget): {
+    flush: () => void;
+    restore: () => void;
+};