@j0hanz/thinkseq-mcp 2.0.0 → 2.1.0

package/dist/engine/revision.js

@@ -1,35 +1,23 @@
-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 missingRevisionError();
+    if (targetNumber === undefined) {
+        return error('E_REVISION_MISSING', 'revisesThought is required for revision');
+    }
     const target = getThoughtByNumber(targetNumber);
-    if (!target)
-        return targetNotFoundError(targetNumber);
-    if (!target.isActive)
-        return targetSupersededError(targetNumber);
+    if (!target) {
+        return error('E_REVISION_TARGET_NOT_FOUND', `Thought ${targetNumber} not found`);
+    }
+    if (!target.isActive) {
+        return error('E_REVISION_TARGET_SUPERSEDED', `Thought ${targetNumber} was already superseded`);
+    }
     return { ok: true, targetNumber, target };
 }
-function buildRevisionError(code, message) {
+function error(code, message) {
     return {
         ok: false,
-        error: { code, message },
+        result: {
+            ok: false,
+            error: { code, message },
+        },
     };
 }

package/dist/engine/thoughtQueries.js

@@ -5,6 +5,7 @@ function selectRecentThoughts(activeThoughts) {
     const len = activeThoughts.length;
     const recent = [];
     const stepIndexes = [];
+    // If we have lots of thoughts, keep the first as an anchor.
     if (len > MAX_RECENT_THOUGHTS) {
         const anchor = activeThoughts[0];
         if (!anchor)
@@ -12,21 +13,30 @@ function selectRecentThoughts(activeThoughts) {
         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 startIndex = len <= MAX_RECENT_THOUGHTS ? 0 : Math.max(0, len - RECENT_TAIL_COUNT);
+    for (let i = startIndex; i < len; i += 1) {
         const thought = activeThoughts[i];
-        if (thought) {
-            recent.push(thought);
-            stepIndexes.push(i + 1);
-        }
+        if (!thought)
+            continue;
+        recent.push(thought);
+        stepIndexes.push(i + 1);
     }
     return { recent, stepIndexes };
 }
 function truncatePreview(input, maxChars) {
-    const codepoints = Array.from(input);
-    if (codepoints.length <= maxChars)
+    // Preserve codepoint boundaries (emoji-safe) without depending on Intl.Segmenter.
+    const iterator = input[Symbol.iterator]();
+    const preview = [];
+    for (let i = 0; i < maxChars; i += 1) {
+        const next = iterator.next();
+        if (next.done)
+            return input;
+        preview.push(next.value);
+    }
+    const extra = iterator.next();
+    if (extra.done)
         return input;
-    return `${codepoints.slice(0, maxChars).join('')}...`;
+    return `${preview.join('')}...`;
 }
 export function buildContextSummary(activeThoughts, revisionInfo) {
     const { recent, stepIndexes } = selectRecentThoughts(activeThoughts);
@@ -35,8 +45,5 @@ export function buildContextSummary(activeThoughts, revisionInfo) {
         number: thought.thoughtNumber,
         preview: truncatePreview(thought.thought, MAX_PREVIEW_CHARS),
     }));
-    if (revisionInfo !== undefined) {
-        return { recentThoughts, revisionInfo };
-    }
-    return { recentThoughts };
+    return revisionInfo ? { recentThoughts, revisionInfo } : { recentThoughts };
 }

package/dist/engine/thoughtStore.js

@@ -1,13 +1,13 @@
 import { COMPACT_RATIO, COMPACT_THRESHOLD } from '../engineConfig.js';
 export class ThoughtStore {
-    #thoughts = [];
-    #thoughtIndex = new Map();
+    #allThoughts = [];
+    #byNumber = new Map();
     #activeThoughts = [];
-    #activeThoughtNumbers = [];
+    #activeNumbers = [];
     #activeMaxTotalThoughts = 0;
-    #headIndex = 0;
+    #startIndex = 0;
     #nextThoughtNumber = 1;
-    #estimatedBytes = 0;
+    #approxBytes = 0;
     #lastPruneStats = null;
     #maxThoughts;
     #maxMemoryBytes;
@@ -27,57 +27,15 @@ export class ThoughtStore {
         return this.#lastPruneStats;
     }
     storeThought(stored) {
-        this.#thoughts.push(stored);
-        this.#thoughtIndex.set(stored.thoughtNumber, stored);
+        this.#allThoughts.push(stored);
+        this.#byNumber.set(stored.thoughtNumber, stored);
         if (stored.isActive) {
-            this.#activeThoughts.push(stored);
-            this.#activeThoughtNumbers.push(stored.thoughtNumber);
-            this.#activeMaxTotalThoughts = Math.max(this.#activeMaxTotalThoughts, stored.totalThoughts);
+            this.#appendActive(stored);
         }
-        this.#estimatedBytes += this.#estimateThoughtBytes(stored);
-    }
-    #recomputeActiveMaxTotalThoughts() {
-        let maxTotal = 0;
-        for (const thought of this.#activeThoughts) {
-            maxTotal = Math.max(maxTotal, thought.totalThoughts);
-        }
-        this.#activeMaxTotalThoughts = maxTotal;
-    }
-    #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)
-                return -1;
-            if (midValue < thoughtNumber)
-                low = mid + 1;
-            else
-                high = mid;
-        }
-        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;
+        this.#approxBytes += this.#estimateThoughtBytes(stored);
     }
     supersedeFrom(targetNumber, supersededBy, maxSupersedes) {
-        const startIndex = this.#findActiveThoughtIndex(targetNumber);
+        const startIndex = this.#findActiveIndex(targetNumber);
         if (startIndex < 0)
             return { supersedes: [], supersedesTotal: 0 };
         const supersedes = [];
@@ -86,17 +44,15 @@ export class ThoughtStore {
             const thought = this.#activeThoughts[i];
             if (!thought)
                 continue;
-            if (thought.isActive) {
-                thought.isActive = false;
-                thought.supersededBy = supersededBy;
-            }
+            this.#markSuperseded(thought, supersededBy);
             supersedesTotal += 1;
             if (maxSupersedes === undefined || supersedes.length < maxSupersedes) {
                 supersedes.push(thought.thoughtNumber);
             }
         }
+        // Drop superseded suffix from active arrays.
         this.#activeThoughts.length = startIndex;
-        this.#activeThoughtNumbers.length = startIndex;
+        this.#activeNumbers.length = startIndex;
         this.#recomputeActiveMaxTotalThoughts();
         return { supersedes, supersedesTotal };
     }
@@ -104,21 +60,19 @@ export class ThoughtStore {
         return this.#activeThoughts;
     }
     getActiveThoughtNumbers(max) {
-        if (max === undefined) {
-            return this.#activeThoughtNumbers.slice();
-        }
+        if (max === undefined)
+            return this.#activeNumbers.slice();
         if (max <= 0)
             return [];
-        if (this.#activeThoughtNumbers.length <= max) {
-            return this.#activeThoughtNumbers.slice();
-        }
-        return this.#activeThoughtNumbers.slice(-max);
+        if (this.#activeNumbers.length <= max)
+            return this.#activeNumbers.slice();
+        return this.#activeNumbers.slice(-max);
     }
     getThoughtByNumber(thoughtNumber) {
-        return this.#thoughtIndex.get(thoughtNumber);
+        return this.#byNumber.get(thoughtNumber);
     }
     getTotalLength() {
-        return this.#thoughts.length - this.#headIndex;
+        return this.#allThoughts.length - this.#startIndex;
     }
     pruneHistoryIfNeeded() {
         const beforeTotal = this.getTotalLength();
@@ -127,62 +81,114 @@ export class ThoughtStore {
             truncatedActive: false,
             droppedActiveCount: 0,
             removedThoughtsCount: 0,
-            oldestAvailableThoughtNumber: this.#thoughts[this.#headIndex]?.thoughtNumber ?? null,
+            oldestAvailableThoughtNumber: this.#allThoughts[this.#startIndex]?.thoughtNumber ?? null,
         };
         this.#performPruning();
         this.#updatePruneStats(beforeTotal, beforeActive);
     }
+    // -------------------------
+    // Active-path bookkeeping
+    // -------------------------
+    #appendActive(stored) {
+        this.#activeThoughts.push(stored);
+        this.#activeNumbers.push(stored.thoughtNumber);
+        this.#activeMaxTotalThoughts = Math.max(this.#activeMaxTotalThoughts, stored.totalThoughts);
+    }
+    #markSuperseded(thought, supersededBy) {
+        if (!thought.isActive)
+            return;
+        thought.isActive = false;
+        thought.supersededBy = supersededBy;
+    }
+    #recomputeActiveMaxTotalThoughts() {
+        let maxTotal = 0;
+        for (const thought of this.#activeThoughts) {
+            maxTotal = Math.max(maxTotal, thought.totalThoughts);
+        }
+        this.#activeMaxTotalThoughts = maxTotal;
+    }
+    // Binary search lower bound for activeNumbers
+    #lowerBoundActive(thoughtNumber) {
+        let low = 0;
+        let high = this.#activeNumbers.length;
+        while (low < high) {
+            const mid = (low + high) >>> 1;
+            const midValue = this.#activeNumbers[mid];
+            if (midValue === undefined)
+                return -1;
+            if (midValue < thoughtNumber)
+                low = mid + 1;
+            else
+                high = mid;
+        }
+        return low;
+    }
+    #findActiveIndex(thoughtNumber) {
+        const index = this.#lowerBoundActive(thoughtNumber);
+        if (index < 0)
+            return -1;
+        return this.#activeNumbers[index] === thoughtNumber ? index : -1;
+    }
+    #firstActiveIndexAfter(thoughtNumber) {
+        const index = this.#lowerBoundActive(thoughtNumber);
+        if (index < 0)
+            return 0;
+        return this.#activeNumbers[index] === thoughtNumber ? index + 1 : index;
+    }
+    #dropActiveUpTo(thoughtNumber) {
+        if (this.#activeThoughts.length === 0)
+            return;
+        const startIndex = this.#firstActiveIndexAfter(thoughtNumber);
+        if (startIndex === 0)
+            return;
+        this.#activeThoughts = this.#activeThoughts.slice(startIndex);
+        this.#activeNumbers = this.#activeNumbers.slice(startIndex);
+        this.#recomputeActiveMaxTotalThoughts();
+    }
+    // -------------------------
+    // Pruning / compaction
+    // -------------------------
     #performPruning() {
         const excess = this.getTotalLength() - this.#maxThoughts;
         if (excess > 0) {
             const batch = Math.max(excess, Math.ceil(this.#maxThoughts * 0.1));
             this.#removeOldest(batch);
         }
-        if (this.#estimatedBytes > this.#maxMemoryBytes &&
+        if (this.#approxBytes > this.#maxMemoryBytes &&
             this.getTotalLength() > 10) {
             const toRemove = Math.ceil(this.getTotalLength() * 0.2);
             this.#removeOldest(toRemove, { forceCompact: true });
         }
     }
     #updatePruneStats(beforeTotal, beforeActive) {
-        if (!this.#lastPruneStats)
+        const stats = this.#lastPruneStats;
+        if (!stats)
             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;
+            this.#allThoughts[this.#startIndex]?.thoughtNumber ?? null;
     }
     #estimateThoughtBytes(thought) {
         return thought.byteLength + this.#estimatedThoughtOverheadBytes;
     }
-    #dropActiveThoughtsUpTo(thoughtNumber) {
-        if (this.#activeThoughts.length === 0)
-            return;
-        const startIndex = this.#findFirstActiveIndexAfter(thoughtNumber);
-        if (startIndex === 0)
-            return;
-        this.#activeThoughts = this.#activeThoughts.slice(startIndex);
-        this.#activeThoughtNumbers = this.#activeThoughtNumbers.slice(startIndex);
-        this.#recomputeActiveMaxTotalThoughts();
-    }
     #removeOldest(count, options = {}) {
         const totalLength = this.getTotalLength();
         if (count <= 0 || totalLength === 0)
             return;
         const actual = Math.min(count, totalLength);
-        const start = this.#headIndex;
+        const start = this.#startIndex;
         const end = start + actual;
         const removedMaxThoughtNumber = this.#evictRange(start, end);
-        this.#headIndex = end;
+        this.#startIndex = end;
         if (this.getTotalLength() === 0) {
-            this.#resetThoughts();
+            this.#reset();
             return;
         }
         if (removedMaxThoughtNumber >= 0) {
-            this.#dropActiveThoughtsUpTo(removedMaxThoughtNumber);
+            this.#dropActiveUpTo(removedMaxThoughtNumber);
         }
         this.#compactIfNeeded(options.forceCompact);
     }
@@ -190,42 +196,41 @@ export class ThoughtStore {
         let removedBytes = 0;
         let maxThoughtNumber = -1;
         for (let index = start; index < end; index += 1) {
-            const thought = this.#thoughts[index];
+            const thought = this.#allThoughts[index];
             if (!thought)
                 continue;
             removedBytes += this.#estimateThoughtBytes(thought);
-            this.#thoughtIndex.delete(thought.thoughtNumber);
+            this.#byNumber.delete(thought.thoughtNumber);
             maxThoughtNumber = thought.thoughtNumber;
         }
-        this.#estimatedBytes -= removedBytes;
+        this.#approxBytes -= removedBytes;
         return maxThoughtNumber;
     }
     #compactIfNeeded(force = false) {
-        if (this.#headIndex === 0)
+        if (this.#startIndex === 0)
             return;
         if (this.getTotalLength() === 0) {
-            this.#resetThoughts();
+            this.#reset();
             return;
         }
-        if (!force && !this.#shouldCompact()) {
+        if (!force && !this.#shouldCompact())
             return;
-        }
-        this.#thoughts = this.#thoughts.slice(this.#headIndex);
-        this.#headIndex = 0;
+        this.#allThoughts = this.#allThoughts.slice(this.#startIndex);
+        this.#startIndex = 0;
     }
     #shouldCompact() {
-        return (this.#headIndex >= COMPACT_THRESHOLD ||
-            this.#headIndex >= this.#thoughts.length * COMPACT_RATIO);
+        return (this.#startIndex >= COMPACT_THRESHOLD ||
+            this.#startIndex >= this.#allThoughts.length * COMPACT_RATIO);
     }
-    #resetThoughts() {
-        this.#thoughts = [];
-        this.#thoughtIndex.clear();
+    #reset() {
+        this.#allThoughts = [];
+        this.#byNumber.clear();
         this.#activeThoughts = [];
-        this.#activeThoughtNumbers = [];
+        this.#activeNumbers = [];
         this.#activeMaxTotalThoughts = 0;
-        this.#headIndex = 0;
+        this.#startIndex = 0;
         this.#nextThoughtNumber = 1;
-        this.#estimatedBytes = 0;
+        this.#approxBytes = 0;
         this.#lastPruneStats = null;
     }
 }

package/dist/engine.js

@@ -1,44 +1,90 @@
 var _a;
+import { Buffer } from 'node:buffer';
 import { resolveRevisionTarget } from './engine/revision.js';
 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';
+class PinnedLruSessions {
+    #map = new Map();
+    #pinnedKey;
+    #max;
+    constructor(pinnedKey, max) {
+        this.#pinnedKey = pinnedKey;
+        this.#max = max;
+    }
+    get size() {
+        return this.#map.size;
+    }
+    get(key) {
+        const existing = this.#map.get(key);
+        if (!existing)
+            return undefined;
+        // bump to most-recent
+        this.#map.delete(key);
+        this.#map.set(key, existing);
+        return existing;
+    }
+    set(key, value) {
+        if (this.#map.has(key))
+            this.#map.delete(key);
+        this.#map.set(key, value);
+        this.#evictIfNeeded();
+    }
+    #evictIfNeeded() {
+        while (this.#map.size > this.#max) {
+            const oldestKey = this.#map.keys().next().value;
+            if (!oldestKey)
+                return;
+            if (oldestKey === this.#pinnedKey) {
+                const pinned = this.#map.get(this.#pinnedKey);
+                if (!pinned) {
+                    // Invariant broken; safest is to stop evicting.
+                    return;
+                }
+                // Move pinned to most-recent and try again.
+                this.#map.delete(this.#pinnedKey);
+                this.#map.set(this.#pinnedKey, pinned);
+                continue;
+            }
+            this.#map.delete(oldestKey);
+        }
+    }
+}
+function normalizeSessionId(sessionId) {
+    const key = sessionId.trim();
+    return key.length > 0 ? key : 'default';
+}
 export class ThinkingEngine {
     static DEFAULT_TOTAL_THOUGHTS = 3;
     #maxThoughts;
     #maxMemoryBytes;
     #estimatedThoughtOverheadBytes;
-    #maxSessions;
-    #sessions = new Map();
+    #sessions;
     constructor(options = {}) {
         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, {
+        const maxSessions = normalizeInt(options.maxSessions, 50, {
             min: 1,
             max: 10_000,
         });
-        this.#getSession('default');
+        this.#sessions = new PinnedLruSessions('default', maxSessions);
+        this.#getOrCreateSession('default');
     }
     processThought(input) {
         return this.processThoughtWithSession('default', input);
     }
     processThoughtWithSession(sessionId, input) {
-        const session = this.#getSession(sessionId);
-        if (input.revisesThought !== undefined) {
-            return this.#processRevision(session, input);
-        }
-        return this.#processNewThought(session, input);
+        const session = this.#getOrCreateSession(sessionId);
+        return input.revisesThought !== undefined
+            ? this.#processRevision(session, input)
+            : this.#processNewThought(session, input);
     }
-    #getSession(sessionId) {
-        const key = sessionId.trim() || 'default';
+    #getOrCreateSession(sessionId) {
+        const key = normalizeSessionId(sessionId);
         const existing = this.#sessions.get(key);
-        if (existing) {
-            // bump to most-recent for LRU eviction
-            this.#sessions.delete(key);
-            this.#sessions.set(key, existing);
+        if (existing)
             return existing;
-        }
         const state = {
             store: new ThoughtStore({
                 maxThoughts: this.#maxThoughts,
@@ -48,28 +94,11 @@ export class ThinkingEngine {
             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);
-        }
-    }
     #processNewThought(session, input) {
-        const { stored } = this.#createStoredThought(session.store, input);
-        this.#commitThought(session.store, stored);
+        const stored = this.#createStoredThought(session.store, input);
+        this.#commit(session.store, stored);
         return this.#buildProcessResult(session, stored);
     }
     #processRevision(session, input) {
@@ -78,19 +107,31 @@ export class ThinkingEngine {
         if (!resolved.ok)
             return resolved.result;
         const { targetNumber } = resolved;
-        const { numbers, stored } = this.#createStoredThought(store, input, {
+        const stored = this.#createStoredThought(store, input, {
             revisionOf: targetNumber,
             fallbackTotalThoughts: resolved.target.totalThoughts,
         });
-        const { supersedes, supersedesTotal } = store.supersedeFrom(targetNumber, numbers.thoughtNumber, MAX_SUPERSEDES);
+        const { supersedes, supersedesTotal } = store.supersedeFrom(targetNumber, stored.thoughtNumber, MAX_SUPERSEDES);
         session.hasRevisions = true;
-        this.#commitThought(store, stored);
+        this.#commit(store, stored);
         return this.#buildProcessResult(session, stored, {
             revises: targetNumber,
             supersedes,
             supersedesTotal,
         });
     }
+    #commit(store, stored) {
+        store.storeThought(stored);
+        store.pruneHistoryIfNeeded();
+    }
+    #createStoredThought(store, input, extras = {}) {
+        const totalThoughts = this.#resolveEffectiveTotalThoughts(store, input, extras.fallbackTotalThoughts);
+        const numbers = store.nextThoughtNumbers(totalThoughts);
+        return this.#buildStoredThought(input, {
+            ...numbers,
+            ...(extras.revisionOf !== undefined && { revisionOf: extras.revisionOf }),
+        });
+    }
     #buildStoredThought(input, details) {
         return {
             thought: input.thought,
@@ -107,19 +148,6 @@ export class ThinkingEngine {
             byteLength: Buffer.byteLength(input.thought),
         };
     }
-    #createStoredThought(store, input, extras = {}) {
-        const effectiveTotalThoughts = this.#resolveEffectiveTotalThoughts(store, input, extras.fallbackTotalThoughts);
-        const numbers = store.nextThoughtNumbers(effectiveTotalThoughts);
-        const stored = this.#buildStoredThought(input, {
-            ...numbers,
-            ...(extras.revisionOf !== undefined && { revisionOf: extras.revisionOf }),
-        });
-        return { stored, numbers };
-    }
-    #commitThought(store, stored) {
-        store.storeThought(stored);
-        store.pruneHistoryIfNeeded();
-    }
     #resolveEffectiveTotalThoughts(store, input, fallback) {
         if (input.totalThoughts !== undefined) {
             return normalizeInt(input.totalThoughts, _a.DEFAULT_TOTAL_THOUGHTS, { min: 1, max: MAX_THOUGHTS_CAP });
@@ -128,15 +156,12 @@ export class ThinkingEngine {
             return fallback;
         const activeThoughts = store.getActiveThoughts();
         const lastActive = activeThoughts[activeThoughts.length - 1];
-        if (lastActive !== undefined) {
-            return lastActive.totalThoughts;
-        }
-        return _a.DEFAULT_TOTAL_THOUGHTS;
+        return lastActive?.totalThoughts ?? _a.DEFAULT_TOTAL_THOUGHTS;
     }
     #buildProcessResult(session, stored, revisionInfo) {
         const activeThoughts = session.store.getActiveThoughts();
         const activePathLength = activeThoughts.length;
-        const { progress, isComplete } = this.#calculateMetrics(activePathLength, stored.totalThoughts);
+        const { progress, isComplete } = this.#calculateProgress(activePathLength, stored.totalThoughts);
         return {
             ok: true,
             result: {
@@ -153,11 +178,10 @@ export class ThinkingEngine {
             },
         };
     }
-    #calculateMetrics(active, total) {
-        return {
-            progress: total > 0 ? Math.min(1, active / total) : 1,
-            isComplete: active >= total,
-        };
+    #calculateProgress(active, total) {
+        const safeTotal = total > 0 ? total : 0;
+        const progress = safeTotal > 0 ? Math.min(1, active / safeTotal) : 1;
+        return { progress, isComplete: active >= safeTotal };
     }
 }
 _a = ThinkingEngine;

package/dist/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import process from 'node:process';
 import { installProcessErrorHandlers, run } from './app.js';
 import { ThinkingEngine } from './engine.js';
 import { getCliHelpText, parseCliConfig } from './lib/cli.js';