@j0hanz/cortex-mcp 1.3.0 → 1.5.0

package/dist/engine/config.d.ts

@@ -1,21 +1,21 @@
-import type { LevelConfig, ReasoningLevel } from '../lib/types.js';
+import { type LevelConfig, type ReasoningLevel } from '../lib/types.js';
 export declare const LEVEL_CONFIGS: {
     readonly basic: {
+        readonly tokenBudget: 2048;
         readonly minThoughts: 3;
         readonly maxThoughts: 5;
-        readonly tokenBudget: 2048;
     };
     readonly normal: {
+        readonly tokenBudget: 8192;
         readonly minThoughts: 6;
         readonly maxThoughts: 10;
-        readonly tokenBudget: 8192;
     };
     readonly high: {
+        readonly tokenBudget: 32768;
         readonly minThoughts: 15;
         readonly maxThoughts: 25;
-        readonly tokenBudget: 32768;
     };
 };
 export declare function getLevelConfig(level: ReasoningLevel): LevelConfig;
 export declare function assertTargetThoughtsInRange(level: ReasoningLevel, targetThoughts: number): void;
-//# sourceMappingURL=config.d.ts.map
+export declare function getLevelDescriptionString(): string;

package/dist/engine/config.js

@@ -1,8 +1,10 @@
+import { InvalidThoughtCountError } from '../lib/errors.js';
+import { LEVEL_BOUNDS, } from '../lib/types.js';
 import { getTargetThoughtsError } from '../lib/validators.js';
 export const LEVEL_CONFIGS = {
-    basic: { minThoughts: 3, maxThoughts: 5, tokenBudget: 2048 },
-    normal: { minThoughts: 6, maxThoughts: 10, tokenBudget: 8192 },
-    high: { minThoughts: 15, maxThoughts: 25, tokenBudget: 32768 },
+    basic: { ...LEVEL_BOUNDS.basic, tokenBudget: 2048 },
+    normal: { ...LEVEL_BOUNDS.normal, tokenBudget: 8192 },
+    high: { ...LEVEL_BOUNDS.high, tokenBudget: 32768 },
 };
 export function getLevelConfig(level) {
     return LEVEL_CONFIGS[level];
@@ -12,6 +14,13 @@ export function assertTargetThoughtsInRange(level, targetThoughts) {
     if (!errorMessage) {
         return;
     }
-    throw new Error(errorMessage);
+    throw new InvalidThoughtCountError(errorMessage);
+}
+export function getLevelDescriptionString() {
+    return Object.entries(LEVEL_CONFIGS)
+        .map(([level, config]) => {
+        const budgetK = Math.round(config.tokenBudget / 1024);
+        return `${level} (${config.minThoughts}–${config.maxThoughts} steps, ${budgetK}K budget)`;
+    })
+        .join(', ');
 }
-//# sourceMappingURL=config.js.map

package/dist/engine/context.d.ts

@@ -3,5 +3,3 @@ export interface EngineContext {
     readonly abortSignal?: AbortSignal;
 }
 export declare function runWithContext<T>(ctx: EngineContext, fn: () => T): T;
-export declare function getContext(): EngineContext | undefined;
-//# sourceMappingURL=context.d.ts.map

package/dist/engine/context.js

@@ -3,7 +3,3 @@ const storage = new AsyncLocalStorage();
 export function runWithContext(ctx, fn) {
     return storage.run(ctx, fn);
 }
-export function getContext() {
-    return storage.getStore();
-}
-//# sourceMappingURL=context.js.map

package/dist/engine/events.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
 import type { ReasoningLevel } from '../lib/types.js';
-interface ThoughtBudgetExhaustedPayload {
+export interface ThoughtBudgetExhaustedPayload {
     sessionId: string;
     tokensUsed: number;
     tokenBudget: number;
@@ -51,4 +51,3 @@ interface TypedEmitter<T> extends Omit<EventEmitter, 'on' | 'off' | 'emit'> {
 }
 export declare const engineEvents: TypedEmitter<EngineEvents>;
 export {};
-//# sourceMappingURL=events.d.ts.map

package/dist/engine/events.js

@@ -1,12 +1,10 @@
 import { EventEmitter } from 'node:events';
 import { getErrorMessage } from '../lib/errors.js';
-const ENGINE_ERROR_LOG_PREFIX = '[engine]';
-const ENGINE_ERROR_PREFIX_WITH_SPACE = `${ENGINE_ERROR_LOG_PREFIX} `;
+const ENGINE_ERROR_PREFIX = '[engine] ';
 export const engineEvents = new EventEmitter({
     captureRejections: true,
 });
 function logEngineError(err) {
-    process.stderr.write(`${ENGINE_ERROR_PREFIX_WITH_SPACE}${getErrorMessage(err)}\n`);
+    process.stderr.write(`${ENGINE_ERROR_PREFIX}${getErrorMessage(err)}\n`);
 }
 engineEvents.on('error', logEngineError);
-//# sourceMappingURL=events.js.map

package/dist/engine/heuristics.d.ts

@@ -0,0 +1,4 @@
+import type { LevelConfig, ReasoningLevel } from '../lib/types.js';
+export declare function countSentences(queryText: string): number;
+export declare function getStructureDensityScore(queryText: string): number;
+export declare function resolveThoughtCount(level: ReasoningLevel, query: string, config: Pick<LevelConfig, 'minThoughts' | 'maxThoughts'>, targetThoughts?: number): number;

package/dist/engine/heuristics.js

@@ -0,0 +1,65 @@
+import { Buffer } from 'node:buffer';
+import { createSegmenter } from '../lib/text.js';
+import { assertTargetThoughtsInRange } from './config.js';
+const NON_WHITESPACE = /\S/u;
+const COMPLEXITY_KEYWORDS = /\b(compare|analy[sz]e|trade[- ]?off|design|plan|critique|evaluate|review|architecture)\b/i;
+let _sentenceSegmenter;
+let _sentenceSegmenterInitialized = false;
+function getSentenceSegmenter() {
+    if (!_sentenceSegmenterInitialized) {
+        _sentenceSegmenter = createSegmenter('sentence');
+        _sentenceSegmenterInitialized = true;
+    }
+    return _sentenceSegmenter;
+}
+export function countSentences(queryText) {
+    const segmenter = getSentenceSegmenter();
+    if (!segmenter) {
+        return 0;
+    }
+    let count = 0;
+    for (const sentence of segmenter.segment(queryText)) {
+        if (NON_WHITESPACE.test(sentence.segment)) {
+            count++;
+        }
+    }
+    return count;
+}
+export function getStructureDensityScore(queryText) {
+    const sentenceCount = countSentences(queryText);
+    if (sentenceCount > 1) {
+        return (sentenceCount - 1) * 0.08;
+    }
+    let markerMatches = 0;
+    for (let index = 0; index < queryText.length; index++) {
+        switch (queryText.charCodeAt(index)) {
+            case 63: // ?
+            case 58: // :
+            case 59: // ;
+            case 44: // ,
+            case 10: // \n
+                markerMatches += 1;
+                break;
+            default:
+                break;
+        }
+    }
+    return markerMatches * 0.05;
+}
+export function resolveThoughtCount(level, query, config, targetThoughts) {
+    if (targetThoughts !== undefined) {
+        assertTargetThoughtsInRange(level, targetThoughts);
+        return targetThoughts;
+    }
+    if (config.minThoughts === config.maxThoughts) {
+        return config.minThoughts;
+    }
+    const queryText = query.trim();
+    const span = config.maxThoughts - config.minThoughts;
+    const queryByteLength = Buffer.byteLength(queryText, 'utf8');
+    const lengthScore = Math.min(1, queryByteLength / 400);
+    const structureScore = Math.min(0.4, getStructureDensityScore(queryText));
+    const keywordScore = COMPLEXITY_KEYWORDS.test(queryText) ? 0.25 : 0;
+    const score = Math.min(1, lengthScore + structureScore + keywordScore);
+    return config.minThoughts + Math.round(span * score);
+}

package/dist/engine/reasoner.d.ts

@@ -5,9 +5,14 @@ export { sessionStore };
 interface ReasonOptions {
     sessionId?: string;
     targetThoughts?: number;
-    thought: string;
+    thought?: string;
+    observation?: string;
+    hypothesis?: string;
+    evaluation?: string;
+    stepSummary?: string;
+    isConclusion?: boolean;
+    rollbackToStep?: number;
     abortSignal?: AbortSignal;
     onProgress?: (progress: number, total: number) => void | Promise<void>;
 }
 export declare function reason(query: string, level: ReasoningLevel | undefined, options?: ReasonOptions): Promise<Readonly<Session>>;
-//# sourceMappingURL=reasoner.d.ts.map

package/dist/engine/reasoner.js

@@ -1,40 +1,39 @@
-import { Buffer } from 'node:buffer';
-import { createSegmenter } from '../lib/text.js';
-import { assertTargetThoughtsInRange, getLevelConfig } from './config.js';
+import { InvalidRunModeArgsError, ReasoningAbortedError, SessionNotFoundError, } from '../lib/errors.js';
+import { parsePositiveIntEnv } from '../lib/validators.js';
+import { getLevelConfig } from './config.js';
 import { runWithContext } from './context.js';
 import { engineEvents } from './events.js';
-import { SessionStore } from './session-store.js';
-const DEFAULT_SESSION_TTL_MS = 30 * 60 * 1000;
-const DEFAULT_MAX_SESSIONS = 100;
-const DEFAULT_MAX_TOTAL_TOKENS = 500_000;
-const NON_WHITESPACE = /\S/u;
-const COMPLEXITY_KEYWORDS = /\b(compare|analy[sz]e|trade[- ]?off|design|plan|critique|evaluate|review|architecture)\b/i;
-function parsePositiveIntEnv(name, fallback, minimum = 1) {
-    const raw = process.env[name];
-    if (raw === undefined) {
-        return fallback;
-    }
-    const parsed = Number.parseInt(raw, 10);
-    if (!Number.isInteger(parsed) || parsed < minimum) {
-        return fallback;
-    }
-    return parsed;
-}
+import { resolveThoughtCount } from './heuristics.js';
+import { DEFAULT_MAX_SESSIONS, DEFAULT_MAX_TOTAL_TOKENS, DEFAULT_SESSION_TTL_MS, SessionStore, } from './session-store.js';
 const sessionStore = new SessionStore(parsePositiveIntEnv('CORTEX_SESSION_TTL_MS', DEFAULT_SESSION_TTL_MS), parsePositiveIntEnv('CORTEX_MAX_SESSIONS', DEFAULT_MAX_SESSIONS), parsePositiveIntEnv('CORTEX_MAX_TOTAL_TOKENS', DEFAULT_MAX_TOTAL_TOKENS));
-const sentenceSegmenter = createSegmenter('sentence');
 const sessionLocks = new Map();
 export { sessionStore };
 export async function reason(query, level, options) {
-    if (!options?.thought) {
-        throw new Error('thought is required: provide your reasoning content');
+    const { sessionId, targetThoughts, thought, observation, hypothesis, evaluation, stepSummary, isConclusion, rollbackToStep, abortSignal, onProgress, } = options ?? {};
+    const hasContent = thought !== undefined ||
+        (observation !== undefined &&
+            hypothesis !== undefined &&
+            evaluation !== undefined);
+    if (!hasContent && rollbackToStep === undefined) {
+        throw new InvalidRunModeArgsError('Either thought (or observation/hypothesis/evaluation) or rollback_to_step is required');
     }
-    const { sessionId, targetThoughts, thought, abortSignal, onProgress } = options;
     const session = resolveSession(level, sessionId, query, targetThoughts);
     const config = getLevelConfig(session.level);
     const { totalThoughts } = session;
     return runWithContext({ sessionId: session.id, ...(abortSignal ? { abortSignal } : {}) }, () => withSessionLock(session.id, async () => {
         throwIfReasoningAborted(abortSignal);
+        if (rollbackToStep !== undefined) {
+            sessionStore.rollback(session.id, rollbackToStep);
+        }
         const current = getSessionOrThrow(session.id);
+        let content = thought;
+        if (!content && observation) {
+            content = `**Observation:** ${observation}\n\n**Hypothesis:** ${hypothesis ?? ''}\n\n**Evaluation:** ${evaluation ?? ''}`;
+        }
+        if (!content) {
+            // Only rollback occurred
+            return current;
+        }
         if (emitBudgetExhaustedIfNeeded({
             session: current,
             tokenBudget: config.tokenBudget,
@@ -44,23 +43,23 @@ export async function reason(query, level, options) {
             return current;
         }
         const nextIndex = current.thoughts.length;
-        if (nextIndex >= totalThoughts) {
+        if (nextIndex >= totalThoughts && !isConclusion) {
             return current;
         }
-        const addedThought = sessionStore.addThought(session.id, thought);
+        const addedThought = sessionStore.addThought(session.id, content, stepSummary);
         engineEvents.emit('thought:added', {
             sessionId: session.id,
             index: addedThought.index,
             content: addedThought.content,
         });
         const updated = getSessionOrThrow(session.id);
-        emitBudgetExhaustedIfNeeded({
+        void emitBudgetExhaustedIfNeeded({
             session: updated,
             tokenBudget: config.tokenBudget,
             generatedThoughts: addedThought.index + 1,
             requestedThoughts: totalThoughts,
         });
-        if (updated.thoughts.length >= totalThoughts) {
+        if (isConclusion || updated.thoughts.length >= totalThoughts) {
             sessionStore.markCompleted(session.id);
         }
         if (onProgress) {
@@ -83,7 +82,7 @@ async function withSessionLock(sessionId, fn) {
         return await fn();
     }
     finally {
-        release?.();
+        release();
         if (sessionLocks.get(sessionId) === currentTail) {
             sessionLocks.delete(sessionId);
         }
@@ -92,51 +91,41 @@ async function withSessionLock(sessionId, fn) {
 function getSessionOrThrow(sessionId) {
     const session = sessionStore.get(sessionId);
     if (!session) {
-        throw new Error(`Session not found: ${sessionId}`);
+        throw new SessionNotFoundError(sessionId);
     }
     return session;
 }
-function emitBudgetExhausted(data) {
-    engineEvents.emit('thought:budget-exhausted', data);
-}
-function createBudgetExhaustedPayload(args) {
+function emitBudgetExhaustedIfNeeded(args) {
     const { session, tokenBudget, generatedThoughts, requestedThoughts } = args;
-    return {
+    if (session.tokensUsed < tokenBudget) {
+        return false;
+    }
+    engineEvents.emit('thought:budget-exhausted', {
         sessionId: session.id,
         tokensUsed: session.tokensUsed,
         tokenBudget,
         generatedThoughts,
         requestedThoughts,
-    };
-}
-function emitBudgetExhaustedIfNeeded(args) {
-    const { session, tokenBudget } = args;
-    if (session.tokensUsed < tokenBudget) {
-        return false;
-    }
-    emitBudgetExhausted(createBudgetExhaustedPayload(args));
+    });
     return true;
 }
-function assertExistingSessionConstraints(existing, level, targetThoughts) {
-    if (level !== undefined && existing.level !== level) {
-        // Warning: ignoring provided level in favor of session level
-    }
+function assertExistingSessionConstraints(existing, targetThoughts) {
     if (targetThoughts !== undefined &&
         targetThoughts !== existing.totalThoughts) {
-        throw new Error(`Cannot change targetThoughts on an existing session (current: ${String(existing.totalThoughts)}). Omit targetThoughts or pass ${String(existing.totalThoughts)}.`);
+        throw new InvalidRunModeArgsError(`Cannot change targetThoughts on an existing session (current: ${String(existing.totalThoughts)}). Omit targetThoughts or pass ${String(existing.totalThoughts)}.`);
     }
 }
 function resolveSession(level, sessionId, query, targetThoughts) {
     if (sessionId) {
         const existing = sessionStore.get(sessionId);
         if (!existing) {
-            throw new Error(`Session not found: ${sessionId}`);
+            throw new SessionNotFoundError(sessionId);
         }
-        assertExistingSessionConstraints(existing, level, targetThoughts);
+        assertExistingSessionConstraints(existing, targetThoughts);
         return existing;
     }
     if (level === undefined) {
-        throw new Error('level is required for new sessions');
+        throw new InvalidRunModeArgsError('level is required for new sessions');
     }
     const config = getLevelConfig(level);
     const totalThoughts = resolveThoughtCount(level, query, config, targetThoughts);
@@ -147,56 +136,6 @@ function resolveSession(level, sessionId, query, targetThoughts) {
     });
     return session;
 }
-function resolveThoughtCount(level, query, config, targetThoughts) {
-    if (targetThoughts !== undefined) {
-        assertTargetThoughtsInRange(level, targetThoughts);
-        return targetThoughts;
-    }
-    if (config.minThoughts === config.maxThoughts) {
-        return config.minThoughts;
-    }
-    const queryText = query.trim();
-    const span = config.maxThoughts - config.minThoughts;
-    const queryByteLength = Buffer.byteLength(queryText, 'utf8');
-    const lengthScore = Math.min(1, queryByteLength / 400);
-    const structureScore = Math.min(0.4, getStructureDensityScore(queryText));
-    const keywordScore = COMPLEXITY_KEYWORDS.test(queryText) ? 0.25 : 0;
-    const score = Math.min(1, lengthScore + structureScore + keywordScore);
-    return config.minThoughts + Math.round(span * score);
-}
-function countSentences(queryText) {
-    if (!sentenceSegmenter) {
-        return 0;
-    }
-    let count = 0;
-    for (const sentence of sentenceSegmenter.segment(queryText)) {
-        if (NON_WHITESPACE.test(sentence.segment)) {
-            count++;
-        }
-    }
-    return count;
-}
-function getStructureDensityScore(queryText) {
-    const sentenceCount = countSentences(queryText);
-    if (sentenceCount > 1) {
-        return (sentenceCount - 1) * 0.08;
-    }
-    let markerMatches = 0;
-    for (let index = 0; index < queryText.length; index++) {
-        switch (queryText.charCodeAt(index)) {
-            case 63: // ?
-            case 58: // :
-            case 59: // ;
-            case 44: // ,
-            case 10: // \n
-                markerMatches += 1;
-                break;
-            default:
-                break;
-        }
-    }
-    return markerMatches * 0.05;
-}
 function throwIfReasoningAborted(signal) {
     if (!signal) {
         return;
@@ -205,7 +144,6 @@ function throwIfReasoningAborted(signal) {
         signal.throwIfAborted();
     }
     catch {
-        throw new Error('Reasoning aborted');
+        throw new ReasoningAbortedError();
     }
 }
-//# sourceMappingURL=reasoner.js.map

package/dist/engine/session-store.d.ts

@@ -1,4 +1,7 @@
 import type { ReasoningLevel, Session, SessionSummary, Thought } from '../lib/types.js';
+export declare const DEFAULT_SESSION_TTL_MS: number;
+export declare const DEFAULT_MAX_SESSIONS = 100;
+export declare const DEFAULT_MAX_TOTAL_TOKENS = 500000;
 export declare class SessionStore {
     private readonly sessions;
     private readonly sessionOrder;
@@ -21,7 +24,8 @@ export declare class SessionStore {
     getExpiresAt(sessionId: string): number | undefined;
     getTotalTokensUsed(): number;
     delete(id: string): boolean;
-    addThought(sessionId: string, content: string): Thought;
+    addThought(sessionId: string, content: string, stepSummary?: string): Thought;
+    rollback(sessionId: string, toIndex: number): void;
     reviseThought(sessionId: string, thoughtIndex: number, content: string): Thought;
     markCompleted(sessionId: string): void;
     markCancelled(sessionId: string): void;
@@ -39,6 +43,7 @@ export declare class SessionStore {
     private deleteSessionInternal;
     private markSessionTouched;
     private getSessionIdsForIteration;
+    private collectSessions;
     private snapshotThought;
     private snapshotSession;
     private snapshotSessionSummary;
@@ -48,4 +53,3 @@ export declare class SessionStore {
     private emitSessionEvicted;
     private emitSessionResourcesUpdated;
 }
-//# sourceMappingURL=session-store.d.ts.map

package/dist/engine/session-store.js

@@ -2,9 +2,9 @@ import { Buffer } from 'node:buffer';
 import { randomUUID } from 'node:crypto';
 import { getLevelConfig } from './config.js';
 import { engineEvents } from './events.js';
-const DEFAULT_TTL_MS = 30 * 60 * 1000; // 30 minutes
-const DEFAULT_MAX_SESSIONS = 100;
-const DEFAULT_MAX_TOTAL_TOKENS = 500_000;
+export const DEFAULT_SESSION_TTL_MS = 30 * 60 * 1000; // 30 minutes
+export const DEFAULT_MAX_SESSIONS = 100;
+export const DEFAULT_MAX_TOTAL_TOKENS = 500_000;
 const TOKEN_ESTIMATE_DIVISOR = 4;
 const MIN_SWEEP_INTERVAL_MS = 10;
 const MAX_SWEEP_INTERVAL_MS = 60_000;
@@ -12,6 +12,9 @@ function estimateTokens(text) {
     const byteLength = Buffer.byteLength(text, 'utf8');
     return Math.max(1, Math.ceil(byteLength / TOKEN_ESTIMATE_DIVISOR));
 }
+function getThoughtTokenCount(thought) {
+    return thought.tokenCount ?? estimateTokens(thought.content);
+}
 function resolveSweepInterval(ttlMs) {
     return Math.max(MIN_SWEEP_INTERVAL_MS, Math.min(MAX_SWEEP_INTERVAL_MS, ttlMs));
 }
@@ -26,7 +29,7 @@ export class SessionStore {
     maxSessions;
     maxTotalTokens;
     totalTokens = 0;
-    constructor(ttlMs = DEFAULT_TTL_MS, maxSessions = DEFAULT_MAX_SESSIONS, maxTotalTokens = DEFAULT_MAX_TOTAL_TOKENS) {
+    constructor(ttlMs = DEFAULT_SESSION_TTL_MS, maxSessions = DEFAULT_MAX_SESSIONS, maxTotalTokens = DEFAULT_MAX_TOTAL_TOKENS) {
         this.ttlMs = ttlMs;
         this.maxSessions = maxSessions;
         this.maxTotalTokens = maxTotalTokens;
@@ -67,28 +70,14 @@ export class SessionStore {
         return session ? this.snapshotSessionSummary(session) : undefined;
     }
     list() {
-        const sessions = [];
-        for (const sessionId of this.getSessionIdsForIteration()) {
-            const session = this.sessions.get(sessionId);
-            if (session) {
-                sessions.push(this.snapshotSession(session));
-            }
-        }
-        return sessions;
+        return this.collectSessions(this.snapshotSession.bind(this));
     }
     listSessionIds() {
         this.sortedSessionIdsCache ??= this.buildSortedSessionIdsCache();
         return [...this.sortedSessionIdsCache];
     }
     listSummaries() {
-        const summaries = [];
-        for (const sessionId of this.getSessionIdsForIteration()) {
-            const session = this.sessions.get(sessionId);
-            if (session) {
-                summaries.push(this.snapshotSessionSummary(session));
-            }
-        }
-        return summaries;
+        return this.collectSessions(this.snapshotSessionSummary.bind(this));
     }
     getTtlMs() {
         return this.ttlMs;
@@ -112,7 +101,7 @@ export class SessionStore {
         this.emitSessionsCollectionUpdated();
         return true;
     }
-    addThought(sessionId, content) {
+    addThought(sessionId, content, stepSummary) {
         const session = this.sessions.get(sessionId);
         if (!session) {
             throw new Error(`Session not found: ${sessionId}`);
@@ -123,6 +112,8 @@ export class SessionStore {
             index: session.thoughts.length,
             content,
             revision: 0,
+            tokenCount: tokens,
+            ...(stepSummary !== undefined ? { stepSummary } : {}),
         };
         session.thoughts.push(thought);
         session.tokensUsed += tokens;
@@ -130,6 +121,26 @@ export class SessionStore {
         this.markSessionTouched(session);
         return this.snapshotThought(thought);
     }
+    rollback(sessionId, toIndex) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        // If toIndex is out of bounds or implies no change, return.
+        // We keep thoughts up to and including toIndex.
+        if (toIndex < 0 || toIndex >= session.thoughts.length - 1) {
+            return;
+        }
+        const removedThoughts = session.thoughts.slice(toIndex + 1);
+        session.thoughts = session.thoughts.slice(0, toIndex + 1);
+        let removedTokens = 0;
+        for (const t of removedThoughts) {
+            removedTokens += getThoughtTokenCount(t);
+        }
+        session.tokensUsed -= removedTokens;
+        this.totalTokens -= removedTokens;
+        this.markSessionTouched(session);
+    }
     reviseThought(sessionId, thoughtIndex, content) {
         const session = this.sessions.get(sessionId);
         if (!session) {
@@ -139,7 +150,7 @@ export class SessionStore {
         if (!existing) {
             throw new Error(`Thought index ${String(thoughtIndex)} not found in session ${sessionId}`);
         }
-        const oldTokens = estimateTokens(existing.content);
+        const oldTokens = getThoughtTokenCount(existing);
         const newTokens = estimateTokens(content);
         const delta = newTokens - oldTokens;
         if (delta > 0) {
@@ -149,12 +160,23 @@ export class SessionStore {
             index: thoughtIndex,
             content,
             revision: existing.revision + 1,
+            tokenCount: newTokens,
+            ...(existing.stepSummary !== undefined
+                ? { stepSummary: existing.stepSummary }
+                : {}),
         };
         session.thoughts[thoughtIndex] = revised;
         session.tokensUsed = session.tokensUsed - oldTokens + newTokens;
         this.totalTokens += delta;
         this.markSessionTouched(session);
-        return this.snapshotThought(revised);
+        const snapshotted = this.snapshotThought(revised);
+        engineEvents.emit('thought:revised', {
+            sessionId,
+            index: snapshotted.index,
+            content: snapshotted.content,
+            revision: snapshotted.revision,
+        });
+        return snapshotted;
     }
     markCompleted(sessionId) {
         this.updateSessionStatus(sessionId, 'completed');
@@ -323,6 +345,8 @@ export class SessionStore {
     }
     markSessionTouched(session) {
         session.updatedAt = Date.now();
+        session._cachedSnapshot = undefined;
+        session._cachedSummary = undefined;
         this.touchOrder(session.id);
         this.sortedSessionIdsCache = null;
         this.emitSessionResourcesUpdated(session.id);
@@ -331,16 +355,34 @@ export class SessionStore {
         this.sortedSessionIdsCache ??= this.buildSortedSessionIdsCache();
         return this.sortedSessionIdsCache;
     }
+    collectSessions(mapSession) {
+        const collected = [];
+        for (const sessionId of this.getSessionIdsForIteration()) {
+            const session = this.sessions.get(sessionId);
+            if (session) {
+                collected.push(mapSession(session));
+            }
+        }
+        return collected;
+    }
     snapshotThought(thought) {
-        return {
+        const t = {
             index: thought.index,
             content: thought.content,
             revision: thought.revision,
+            ...(thought.stepSummary !== undefined
+                ? { stepSummary: thought.stepSummary }
+                : {}),
         };
+        Object.freeze(t);
+        return t;
     }
     snapshotSession(session) {
+        if (session._cachedSnapshot) {
+            return session._cachedSnapshot;
+        }
         const thoughts = session.thoughts.map((thought) => this.snapshotThought(thought));
-        return {
+        const snapshot = {
             id: session.id,
             level: session.level,
             status: session.status,
@@ -351,9 +393,16 @@ export class SessionStore {
             createdAt: session.createdAt,
             updatedAt: session.updatedAt,
         };
+        Object.freeze(snapshot);
+        Object.freeze(snapshot.thoughts);
+        session._cachedSnapshot = snapshot;
+        return snapshot;
     }
     snapshotSessionSummary(session) {
-        return {
+        if (session._cachedSummary) {
+            return session._cachedSummary;
+        }
+        const summary = {
             id: session.id,
             level: session.level,
             status: session.status,
@@ -364,6 +413,9 @@ export class SessionStore {
             createdAt: session.createdAt,
             updatedAt: session.updatedAt,
         };
+        Object.freeze(summary);
+        session._cachedSummary = summary;
+        return summary;
     }
     emitSessionsListChanged() {
         engineEvents.emit('resources:changed', { uri: 'reasoning://sessions' });
@@ -389,4 +441,3 @@ export class SessionStore {
         this.emitSessionsResourceUpdated();
     }
 }
-//# sourceMappingURL=session-store.js.map

package/dist/index.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=index.d.ts.map