@iworkforces/tracelattice 2.0.3 → 2.0.5

package/dist/cli.js

@@ -1,20 +1,29 @@
 #!/usr/bin/env bun
-import * as __rspack_external__lib_js_1645bc55 from "./lib.js";
-import * as __rspack_external_node_async_hooks_4d8b1b4a from "node:async_hooks";
+import * as __rspack_external_valibot from "valibot";
 import * as __rspack_external_node_crypto_2e7c4b46 from "node:crypto";
 import * as __rspack_external_node_http_e245b239 from "node:http";
+import * as __rspack_external_node_async_hooks_4d8b1b4a from "node:async_hooks";
+import * as __rspack_external__tmcp_adapter_valibot_0faddfa6 from "@tmcp/adapter-valibot";
+import * as __rspack_external__tmcp_transport_stdio_98e5584f from "@tmcp/transport-stdio";
+import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
+import * as __rspack_external_node_path_806ed179 from "node:path";
 import * as __rspack_external_node_url_3991086a from "node:url";
-import * as __rspack_external_valibot from "valibot";
-import { ValibotJsonSchemaAdapter } from "@tmcp/adapter-valibot";
-import { StdioTransport } from "@tmcp/transport-stdio";
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { McpServer } from "tmcp";
-import { homedir } from "node:os";
-import { parse } from "yaml";
+import * as __rspack_external_tmcp from "tmcp";
+import * as __rspack_external__lib_js_1645bc55 from "./lib.js";
 var __webpack_modules__ = ({
-"y"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var node_async_hooks__rspack_import_0 = __webpack_require__("A");
+"i"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  RE: () => (/* binding */ getRequestId),
+  Vo: () => (/* binding */ runWithContext)
+});
+
+// UNUSED EXPORTS: getOwner
+
+;// CONCATENATED MODULE: external "node:async_hooks"
+
+;// CONCATENATED MODULE: ./src/context/RequestContext.ts
 /**
  * Request context management using AsyncLocalStorage for correlation IDs.
  *
@@ -26,7 +35,7 @@ var __webpack_modules__ = ({
 /**
  * AsyncLocalStorage instance for request context.
  * Stores requestId that propagates across async boundaries.
- */ const store = new node_async_hooks__rspack_import_0.AsyncLocalStorage();
+ */ const store = new __rspack_external_node_async_hooks_4d8b1b4a.AsyncLocalStorage();
 /**
  * Get the current request ID from context.
  *
@@ -57,133 +66,6 @@ var __webpack_modules__ = ({
     return store.getStore()?.owner;
 }
 
-__webpack_require__.d(__webpack_exports__, {
-  QQ: () => (getOwner),
-  RE: () => (getRequestId),
-  Vo: () => (runWithContext)
-});
-
-
-},
-"j"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var _core_ids_js__rspack_import_0 = __webpack_require__("Uz");
-/* import */ var _errors_js__rspack_import_1 = __webpack_require__("U");
-/**
- * Branded identifier types for compile-time slot safety.
- *
- * These nominal types prevent accidental mixing of different ID kinds
- * (e.g. passing a `ThoughtId` where a `SessionId` is expected). At
- * runtime they are plain strings — the brand exists only in the type
- * system.
- *
- * @module contracts/ids
- */ 
-
-/**
- * Validate and brand a string as a {@link SessionId}.
- *
- * Enforces {@link SESSION_ID_PATTERN} and {@link MAX_SESSION_ID_LENGTH}.
- * The reserved global session sentinel `__global__` is always accepted.
- *
- * @throws {ValidationError} when the input is not a valid session id.
- */ function asSessionId(value) {
-    if (value === '__global__') {
-        // eslint-disable-next-line no-restricted-syntax -- branding constructor, cannot self-reference
-        return value;
-    }
-    if (typeof value !== 'string' || value.length === 0) {
-        throw new _errors_js__rspack_import_1/* .ValidationError */.yI('session_id', 'must be a non-empty string');
-    }
-    if (value.length > (/* inlined export .MAX_SESSION_ID_LENGTH */100)) {
-        throw new _errors_js__rspack_import_1/* .ValidationError */.yI('session_id', `exceeds max length of ${(/* inlined export .MAX_SESSION_ID_LENGTH */100)}`);
-    }
-    if (!_core_ids_js__rspack_import_0/* .SESSION_ID_PATTERN.test */.I.test(value)) {
-        throw new _errors_js__rspack_import_1/* .ValidationError */.yI('session_id', 'must match alphanumeric, hyphens, underscores');
-    }
-    // eslint-disable-next-line no-restricted-syntax -- branding constructor, cannot self-reference
-    return value;
-}
-/** Brand a string as a {@link ThoughtId} without validation. */ function asThoughtId(value) {
-    return value;
-}
-/** Brand a string as an {@link EdgeId} without validation. */ function asEdgeId(value) {
-    return value;
-}
-/** Brand a string as a {@link SuspensionToken} without validation. */ function asSuspensionToken(value) {
-    return value;
-}
-/** Brand a string as a {@link BranchId} without validation. */ function asBranchId(value) {
-    return value;
-}
-/** Brand a string as a {@link SummaryId} without validation. */ function asSummaryId(value) {
-    return value;
-}
-/** Generate a fresh {@link ThoughtId}. */ function generateThoughtId() {
-    return generateUlid();
-}
-/** Generate a fresh {@link EdgeId}. */ function generateEdgeId() {
-    return generateUlid();
-}
-/** Generate a fresh {@link SuspensionToken}. */ function generateSuspensionToken() {
-    return generateUlid();
-}
-/** Generate a fresh {@link SummaryId}. */ function generateSummaryId() {
-    return generateUlid();
-}
-/**
- * Reserved sentinel session id used when callers omit `session_id`.
- *
- * Branded once here so production and test code share one constant
- * instead of casting `'__global__'` ad-hoc.
- */ const GLOBAL_SESSION_ID = asSessionId('__global__');
-
-__webpack_require__.d(__webpack_exports__, {
-  Kd: () => (asSessionId)
-});
-
-
-},
-"Uz"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var node_crypto__rspack_import_0 = __webpack_require__("i");
-/**
- * Unique identifier generation utilities for thoughts and edges.
- *
- * @module core/ids
- */ 
-/**
- * Generate a unique lexicographically-sortable identifier.
- *
- * Format: 8-char base36 timestamp + 20-char hex random (10 random bytes).
- * Result is up to 28 characters, sortable by creation time.
- *
- * @returns A unique string identifier.
- *
- * @example
- * ```typescript
- * const id = generateUlid(); // '01h2k3m400a1b2c3d4e5f6...'
- * ```
- */ function generateUlid() {
-    const timestamp = Date.now().toString(36).padStart(8, '0');
-    const random = crypto.randomBytes(10).toString('hex');
-    return `${timestamp}${random}`;
-}
-/**
- * Valid session ID pattern: alphanumeric, hyphens, underscores.
- *
- * Length is enforced separately via {@link MAX_SESSION_ID_LENGTH}.
- * Same character set as branch IDs.
- */ const SESSION_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
-/**
- * Maximum session ID length (in characters).
- *
- * Allows compound identifiers (e.g. `user-123_task-abc`).
- */ const MAX_SESSION_ID_LENGTH = 100;
-
-__webpack_require__.d(__webpack_exports__, {
-}, {
-  I: SESSION_ID_PATTERN
-});
-
 
 },
 "U"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
@@ -920,550 +802,68 @@ class PersistenceClosedError extends SequentialThinkingError {
 
 __webpack_require__.d(__webpack_exports__, {
   Qt: () => (CliShutdownTimeoutError),
-  j1: () => (ConfigurationError),
-  m_: () => (PoolTerminatedError),
-  oN: () => (SequentialThinkingError),
   u1: () => (getErrorMessage),
-  yI: () => (ValidationError),
-  yM: () => (MaxSessionsReachedError)
-}, {
-  OQ: ERROR_CODES
+  yI: () => (ValidationError)
 });
 
 
 },
-"v"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var node_async_hooks__rspack_import_0 = __webpack_require__("A");
-/* import */ var _errors_js__rspack_import_1 = __webpack_require__("U");
-/* import */ var _contracts_ids_js__rspack_import_2 = __webpack_require__("j");
-/* import */ var _utils_js__rspack_import_4 = __webpack_require__("h");
-/* import */ var _PoolErrors_js__rspack_import_3 = __webpack_require__("K");
+"R"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var valibot__rspack_import_0 = __webpack_require__("w");
 /**
- * Connection Pool for managing concurrent user sessions.
+ * Valibot validation schemas for the sequential thinking MCP tool.
+ *
+ * This module defines the validation schemas used for the sequential thinking tool,
+ * including schemas for tool recommendations, skill recommendations, step recommendations,
+ * and the main sequential thinking input. All schemas use Valibot for runtime validation
+ * and provide detailed descriptions for MCP protocol compatibility.
  *
- * This module provides session management for multi-user scenarios,
- * allowing multiple concurrent clients to each have isolated state.
+ * @remarks
+ * **Schema Overview:**
+ * - `ToolRecommendationSchema` - Validates tool recommendation objects with confidence scores
+ * - `SkillRecommendationSchema` - Validates skill recommendation objects
+ * - `StepRecommendationSchema` - Validates step coordination structures
+ * - `SequentialThinkingSchema` - Main schema for thought input validation
+ * - Reasoning enhancement fields: thought_type, quality_score, confidence, hypothesis_id, etc.
  *
  * @example
  * ```typescript
- * const pool = new ConnectionPool({
- *   maxSessions: 100,
- *   sessionTimeout: 300000 // 5 minutes
- * });
+ * import { SequentialThinkingSchema } from './schema.js';
+ * import { safeParse } from 'valibot';
  *
- * const sessionId = await pool.createSession();
- * await pool.process(sessionId, thought);
- * await pool.closeSession(sessionId);
+ * const result = safeParse(SequentialThinkingSchema, inputData);
+ * if (result.success) {
+ *   const thought = result.output;
+ *   // Process the valid thought
+ * } else {
+ *   console.error('Validation failed:', result.issues);
+ * }
  * ```
+ * @module schema
  */ 
+/**
+ * Detailed description for the sequential thinking tool.
+ *
+ * This description is shown to LLMs when they consider using this tool.
+ * It explains when to use the tool, its features, parameters, and best practices.
+ */ const TOOL_DESCRIPTION = `A detailed tool for dynamic and reflective problem-solving through thoughts.
+This tool helps analyze problems through a flexible thinking process that can adapt and evolve.
+Each thought can build on, question, or revise previous insights as understanding deepens.
 
+IMPORTANT: This server facilitates sequential thinking with MCP tool coordination and skill recommendations. The LLM analyzes available tools and skills to make intelligent recommendations, which are then tracked and organized by this server.
 
+Each invocation records exactly one authored thought and returns. When strategy_hint.action is continue, invoke this tool again with the next thought; do not stop or provide a final answer. terminate permits stopping. The server does not author later thoughts or call itself.
 
-
-/**
- * Represents a user session with its own server instance.
- */ class Session {
-    _server;
-    _id;
-    _createdAt;
-    _lastActivityAt;
-    _isActiveValue;
-    _timeout;
-    _cleanupTimer = null;
-    _logger;
-    _closePromise = null;
-    _activeOperationCount = 0;
-    _operationDrain = null;
-    constructor(id, server, timeout, logger){
-        this._server = server;
-        this._id = id;
-        this._createdAt = Date.now();
-        this._lastActivityAt = this._createdAt;
-        this._isActiveValue = true;
-        this._timeout = timeout;
-        this._logger = logger;
-        // Start session timeout timer
-        this._startTimeout();
-    }
-    /**
-	 * Check if the session is active.
-	 */ get isActive() {
-        return this._isActiveValue;
-    }
-    /**
-	 * Process a thought through this session's server instance.
-	 */ async process(input) {
-        if (!this.isActive) {
-            throw new _PoolErrors_js__rspack_import_3/* .SessionNotActiveError */.q(this._id);
-        }
-        // Update last activity
-        this._lastActivityAt = Date.now();
-        // Reset timeout timer
-        this._resetTimeout();
-        // Process the thought
-        return this._server.processThought(input);
-    }
-    processAdmitted(input) {
-        this._lastActivityAt = Date.now();
-        if (this.isActive) this._resetTimeout();
-        return this._server.processThought(input);
-    }
-    runWhileActive(operation) {
-        if (!this.isActive) return Promise.resolve({
-            status: 'inactive'
-        });
-        this._activeOperationCount++;
-        return (async ()=>{
-            try {
-                return {
-                    status: 'completed',
-                    value: await operation(this)
-                };
-            } finally{
-                this._activeOperationCount--;
-                if (this._activeOperationCount === 0) this._operationDrain?.resolve();
-            }
-        })();
-    }
-    /**
-	 * Get session information.
-	 */ getInfo() {
-        return {
-            id: this._id,
-            server: this._server,
-            createdAt: this._createdAt,
-            lastActivityAt: this._lastActivityAt,
-            isActive: this.isActive
-        };
-    }
-    /**
-	 * Check if the session has timed out.
-	 */ isTimedOut() {
-        return Date.now() - this._lastActivityAt > this._timeout;
-    }
-    /**
-	 * Close the session and stop the server.
-	 */ close() {
-        if (this._closePromise) {
-            return this._closePromise;
-        }
-        const completion = Promise.withResolvers();
-        this._closePromise = completion.promise;
-        this._isActiveValue = false;
-        // Stop timeout timer
-        if (this._cleanupTimer) {
-            clearTimeout(this._cleanupTimer);
-            this._cleanupTimer = null;
-        }
-        if (this._activeOperationCount === 0) {
-            this._stopServer(completion);
-        } else {
-            this._operationDrain = Promise.withResolvers();
-            void this._operationDrain.promise.then(()=>this._stopServer(completion));
-        }
-        return completion.promise;
-    }
-    _stopServer(completion) {
-        try {
-            Promise.resolve(this._server.stop()).then(completion.resolve, completion.reject);
-        } catch (error) {
-            completion.reject(error instanceof Error ? error : new AggregateError([
-                error
-            ], 'Session stop failed'));
-        }
-    }
-    /**
-	 * Start the session timeout timer.
-	 */ _startTimeout() {
-        if (this._cleanupTimer) {
-            clearTimeout(this._cleanupTimer);
-        }
-        this._cleanupTimer = setTimeout(()=>{
-            if (this.isTimedOut()) {
-                this._logger.warn(`Session ${this._id} timed out, closing`);
-                this.close().catch((err)=>{
-                    this._logger.error(`Error closing timed out session ${this._id}:`, err);
-                });
-            }
-        }, this._timeout);
-    }
-    /**
-	 * Reset the timeout timer after activity.
-	 */ _resetTimeout() {
-        this._startTimeout();
-    }
-}
-/**
- * ConnectionPool manages multiple concurrent user sessions.
- *
- * Each session has its own server instance with isolated state,
- * allowing multiple users to interact with the system simultaneously.
- */ class ConnectionPool {
-    _sessions = new Map();
-    _closingSessions = new Map();
-    _createSessionLock = null;
-    _maxSessions;
-    _sessionTimeout;
-    _autoCleanup;
-    _cleanupInterval;
-    _cleanupTimerId = null;
-    _terminated = false;
-    _logger;
-    _serverFactory;
-    _terminatePromise = null;
-    _admissionContext = new node_async_hooks__rspack_import_0.AsyncLocalStorage();
-    _pendingCreateStopFailures = new Set();
-    constructor(options = {}){
-        this._maxSessions = options.maxSessions ?? 100;
-        this._sessionTimeout = options.sessionTimeout ?? 300000; // 5 minutes
-        this._autoCleanup = options.autoCleanup ?? true;
-        this._cleanupInterval = options.cleanupInterval ?? 60000; // 1 minute
-        this._serverFactory = options.serverFactory ?? null;
-        this._logger = options.logger ?? this._createNoopLogger();
-        if (this._autoCleanup) {
-            this._startCleanup();
-        }
-    }
-    /**
-	 * Create a no-op logger when none is provided.
-	 */ _createNoopLogger() {
-        return {
-            info: ()=>{},
-            warn: ()=>{},
-            error: ()=>{},
-            debug: ()=>{},
-            setLevel: ()=>{},
-            getLevel: ()=>'info'
-        };
-    }
-    /**
-	 * Create a new session.
-	 *
-	 * @returns The session ID
-	 * @throws Error if max sessions reached
-	 */ async createSession() {
-        while(this._createSessionLock){
-            await this._createSessionLock;
-        }
-        if (this._terminated) {
-            throw new _errors_js__rspack_import_1/* .PoolTerminatedError */.m_();
-        }
-        if (this._sessions.size >= this._maxSessions) {
-            throw new _errors_js__rspack_import_1/* .MaxSessionsReachedError */.yM(this._maxSessions);
-        }
-        if (!this._serverFactory) {
-            throw new Error('ConnectionPool requires a serverFactory option to create sessions');
-        }
-        let resolveLock;
-        this._createSessionLock = new Promise((resolve)=>{
-            resolveLock = resolve;
-        });
-        try {
-            // Generate unique session ID
-            const sessionId = (0,_contracts_ids_js__rspack_import_2/* .asSessionId */.Kd)(`session_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`);
-            // Create a new server instance for this session
-            const server = await this._serverFactory();
-            if (this._terminated) {
-                try {
-                    await server.stop();
-                } catch (error) {
-                    this._pendingCreateStopFailures.add(error);
-                    throw error;
-                }
-                throw new _errors_js__rspack_import_1/* .PoolTerminatedError */.m_();
-            }
-            // Create session
-            const session = new Session(sessionId, server, this._sessionTimeout, this._logger);
-            this._sessions.set(sessionId, session);
-            this._logger.info(`Created session ${sessionId} (${this._sessions.size}/${this._maxSessions} active sessions)`);
-            return sessionId;
-        } finally{
-            resolveLock();
-            this._createSessionLock = null;
-        }
-    }
-    /**
-	 * Process a thought in the specified session.
-	 *
-	 * @param sessionId - The session ID
-	 * @param input - The thought data to process
-	 * @returns Promise with the processing result
-	 * @throws Error if session not found
-	 */ async process(sessionId, input) {
-        const result = await this._runWithSession(sessionId, (session)=>session.processAdmitted(input));
-        switch(result.status){
-            case 'completed':
-                return result.value;
-            case 'inactive':
-                throw new _PoolErrors_js__rspack_import_3/* .SessionNotActiveError */.q(sessionId);
-            case 'missing':
-                throw new _PoolErrors_js__rspack_import_3/* .SessionNotFoundError */.A(sessionId);
-            default:
-                return (0,_utils_js__rspack_import_4/* .assertNever */.x)(result);
-        }
-    }
-    runWithSession(sessionId, operation) {
-        return this._runWithSession(sessionId, (session)=>operation(session.getInfo().server));
-    }
-    _runWithSession(sessionId, operation) {
-        const activeFrame = this._admissionContext.getStore();
-        if (activeFrame?.open === true && activeFrame.sessionId === sessionId) {
-            return (async ()=>({
-                    status: 'completed',
-                    value: await operation(activeFrame.session)
-                }))();
-        }
-        const session = this._sessions.get(sessionId);
-        if (!session) {
-            return Promise.resolve(this._closingSessions.has(sessionId) ? {
-                status: 'inactive'
-            } : {
-                status: 'missing'
-            });
-        }
-        return session.runWhileActive((capturedSession)=>{
-            const frame = {
-                sessionId,
-                session: capturedSession,
-                open: true
-            };
-            return this._admissionContext.run(frame, async ()=>{
-                try {
-                    return await operation(capturedSession);
-                } finally{
-                    frame.open = false;
-                }
-            });
-        });
-    }
-    /**
-	 * Close a session and release resources.
-	 *
-	 * @param sessionId - The session ID to close
-	 * @throws Error if session not found
-	 */ closeSession(sessionId) {
-        const closing = this._closingSessions.get(sessionId);
-        if (closing) {
-            return closing;
-        }
-        const session = this._sessions.get(sessionId);
-        if (!session) {
-            return Promise.reject(new _PoolErrors_js__rspack_import_3/* .SessionNotFoundError */.A(sessionId));
-        }
-        this._sessions.delete(sessionId);
-        const closePromise = session.close();
-        this._closingSessions.set(sessionId, closePromise);
-        void closePromise.then(()=>{
-            this._closingSessions.delete(sessionId);
-            this._logger.info(`Closed session ${sessionId} (${this._sessions.size}/${this._maxSessions} active sessions)`);
-        }, ()=>{
-            this._closingSessions.delete(sessionId);
-        });
-        return closePromise;
-    }
-    /**
-	 * Get information about a session.
-	 *
-	 * @param sessionId - The session ID
-	 * @returns Session info or undefined if not found
-	 */ getSessionInfo(sessionId) {
-        return this._sessions.get(sessionId)?.getInfo();
-    }
-    /**
-	 * Get all active sessions.
-	 *
-	 * @returns Array of session information
-	 */ getActiveSessions() {
-        return Array.from(this._sessions.values()).filter((s)=>s.isActive).map((s)=>s.getInfo());
-    }
-    /**
-	 * Get connection pool statistics.
-	 */ getStats() {
-        const activeSessions = this.getActiveSessions();
-        return {
-            totalSessions: this._sessions.size,
-            activeSessions: activeSessions.length,
-            maxSessions: this._maxSessions,
-            cleanupEnabled: this._autoCleanup,
-            sessionTimeout: this._sessionTimeout
-        };
-    }
-    /**
-	 * Start the automatic cleanup timer.
-	 */ _startCleanup() {
-        if (this._cleanupTimerId !== null) {
-            clearInterval(this._cleanupTimerId);
-        }
-        this._cleanupTimerId = setInterval(()=>{
-            this._cleanupTimedOutSessions();
-        }, this._cleanupInterval);
-    }
-    /**
-	 * Remove timed-out sessions.
-	 */ _cleanupTimedOutSessions() {
-        let cleaned = 0;
-        for (const [sessionId, session] of this._sessions.entries()){
-            if (session.isTimedOut()) {
-                this.closeSession(sessionId).catch((err)=>{
-                    this._logger.error(`Error closing timed out session ${sessionId}:`, err);
-                });
-                cleaned++;
-            }
-        }
-        if (cleaned > 0) {
-            this._logger.info(`Cleaned ${cleaned} timed-out sessions (${this._sessions.size}/${this._maxSessions} active sessions)`);
-        }
-    }
-    /**
-	 * Close all sessions and stop the cleanup timer.
-	 */ terminate() {
-        if (this._terminatePromise) {
-            return this._terminatePromise;
-        }
-        const completion = Promise.withResolvers();
-        this._terminatePromise = completion.promise;
-        this._terminated = true;
-        // Stop cleanup timer
-        if (this._cleanupTimerId !== null) {
-            clearInterval(this._cleanupTimerId);
-            this._cleanupTimerId = null;
-        }
-        const sessions = Array.from(this._sessions.values());
-        this._sessions.clear();
-        const closePromises = new Set(this._closingSessions.values());
-        if (this._createSessionLock) {
-            closePromises.add(this._createSessionLock);
-        }
-        for (const session of sessions){
-            closePromises.add(session.close());
-        }
-        void Promise.allSettled(closePromises).then((outcomes)=>{
-            const failures = [
-                ...this._pendingCreateStopFailures,
-                ...outcomes.filter((outcome)=>outcome.status === 'rejected').map((outcome)=>outcome.reason)
-            ];
-            if (failures.length > 0) {
-                completion.reject(new AggregateError(failures, 'ConnectionPool termination failed'));
-                return;
-            }
-            this._logger.info('ConnectionPool terminated');
-            completion.resolve();
-        });
-        return completion.promise;
-    }
-    /**
-	 * Dispose of the connection pool, releasing all resources.
-	 * Implements the IDisposable interface.
-	 * Delegates to terminate() for backward compatibility.
-	 */ dispose() {
-        return this.terminate();
-    }
-    /**
-	 * Check if the connection pool is active.
-	 */ isRunning() {
-        return !this._terminated;
-    }
-}
-/**
- * Create a connection pool with the given options.
- *
- * @param options - Connection pool configuration
- * @returns A configured connection pool
- *
- * @example
- * ```typescript
- * const pool = createConnectionPool({
- *   maxSessions: 50,
- *   sessionTimeout: 300000
- * });
- * ```
- */ function createConnectionPool(options) {
-    return new ConnectionPool(options);
-}
-
-__webpack_require__.d(__webpack_exports__, {
-  createConnectionPool: () => (createConnectionPool)
-});
-
-
-},
-"K"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var _errors_js__rspack_import_0 = __webpack_require__("U");
-
-/** Error thrown when attempting to process a session that is not active. */ class SessionNotActiveError extends _errors_js__rspack_import_0/* .SequentialThinkingError */.oN {
-    constructor(sessionId){
-        super(`Session '${sessionId}' is not active`, _errors_js__rspack_import_0/* .ERROR_CODES.SESSION_NOT_ACTIVE */.OQ.SESSION_NOT_ACTIVE);
-        this.name = 'SessionNotActiveError';
-    }
-}
-/** Error thrown when a requested session is not found in the pool. */ class SessionNotFoundError extends _errors_js__rspack_import_0/* .SequentialThinkingError */.oN {
-    constructor(sessionId){
-        super(`Session not found: ${sessionId}`, _errors_js__rspack_import_0/* .ERROR_CODES.SESSION_NOT_FOUND */.OQ.SESSION_NOT_FOUND);
-        this.name = 'SessionNotFoundError';
-    }
-}
-
-__webpack_require__.d(__webpack_exports__, {
-  A: () => (SessionNotFoundError),
-  q: () => (SessionNotActiveError)
-});
-
-
-},
-"R"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var valibot__rspack_import_0 = __webpack_require__("w");
-/**
- * Valibot validation schemas for the sequential thinking MCP tool.
- *
- * This module defines the validation schemas used for the sequential thinking tool,
- * including schemas for tool recommendations, skill recommendations, step recommendations,
- * and the main sequential thinking input. All schemas use Valibot for runtime validation
- * and provide detailed descriptions for MCP protocol compatibility.
- *
- * @remarks
- * **Schema Overview:**
- * - `ToolRecommendationSchema` - Validates tool recommendation objects with confidence scores
- * - `SkillRecommendationSchema` - Validates skill recommendation objects
- * - `StepRecommendationSchema` - Validates step coordination structures
- * - `SequentialThinkingSchema` - Main schema for thought input validation
- * - Reasoning enhancement fields: thought_type, quality_score, confidence, hypothesis_id, etc.
- *
- * @example
- * ```typescript
- * import { SequentialThinkingSchema } from './schema.js';
- * import { safeParse } from 'valibot';
- *
- * const result = safeParse(SequentialThinkingSchema, inputData);
- * if (result.success) {
- *   const thought = result.output;
- *   // Process the valid thought
- * } else {
- *   console.error('Validation failed:', result.issues);
- * }
- * ```
- * @module schema
- */ 
-/**
- * Detailed description for the sequential thinking tool.
- *
- * This description is shown to LLMs when they consider using this tool.
- * It explains when to use the tool, its features, parameters, and best practices.
- */ const TOOL_DESCRIPTION = `A detailed tool for dynamic and reflective problem-solving through thoughts.
-This tool helps analyze problems through a flexible thinking process that can adapt and evolve.
-Each thought can build on, question, or revise previous insights as understanding deepens.
-
-IMPORTANT: This server facilitates sequential thinking with MCP tool coordination and skill recommendations. The LLM analyzes available tools and skills to make intelligent recommendations, which are then tracked and organized by this server.
-
-When to use this tool:
-- Breaking down complex problems into steps
-- Planning and design with room for revision
-- Analysis that might need course correction
-- Problems where the full scope might not be clear initially
-- Problems that require a multi-step solution
-- Tasks that need to maintain context over multiple steps
-- Situations where irrelevant information needs to be filtered out
-- When you need guidance on which tools to use and in what order
-- When you need guidance on which skills to invoke for specific workflows
+When to use this tool:
+- Breaking down complex problems into steps
+- Planning and design with room for revision
+- Analysis that might need course correction
+- Problems where the full scope might not be clear initially
+- Problems that require a multi-step solution
+- Tasks that need to maintain context over multiple steps
+- Situations where irrelevant information needs to be filtered out
+- When you need guidance on which tools to use and in what order
+- When you need guidance on which skills to invoke for specific workflows
 
 Key features:
 - You can adjust total_thoughts up or down as you progress
@@ -1491,7 +891,7 @@ Parameters explained:
 * Hypothesis generation
 * Hypothesis verification
 * Tool recommendations and rationale
-- next_thought_needed: True if you need more thinking, even if at what seemed like the end
+- next_thought_needed: True if you need more thinking, even if at what seemed like the end. Omission defaults to true; the effective next action is in strategy_hint.
 - thought_number: Current number in sequence (can go beyond initial total if needed)
 - total_thoughts: Current estimate of thoughts needed (can be adjusted up/down)
 - is_revision: A boolean indicating if this thought revises previous thinking
@@ -1785,7 +1185,7 @@ You should:
     available_skills: valibot__rspack_import_0.optional(valibot__rspack_import_0.pipe(valibot__rspack_import_0.array(valibot__rspack_import_0.string()), valibot__rspack_import_0.description('Array of skill names available for use (e.g., ["commit", "review-pr", "pdf"])'))),
     thought: valibot__rspack_import_0.pipe(valibot__rspack_import_0.string(), valibot__rspack_import_0.description('Your current thinking step')),
     id: valibot__rspack_import_0.optional(valibot__rspack_import_0.pipe(valibot__rspack_import_0.string(), valibot__rspack_import_0.minLength(1), valibot__rspack_import_0.maxLength(30), valibot__rspack_import_0.description('Unique identifier for this thought. Auto-generated if not provided.'))),
-    next_thought_needed: valibot__rspack_import_0.optional(valibot__rspack_import_0.pipe(valibot__rspack_import_0.boolean(), valibot__rspack_import_0.description('Whether another thought step is needed (defaults to true if not provided)'))),
+    next_thought_needed: valibot__rspack_import_0.optional(valibot__rspack_import_0.pipe(valibot__rspack_import_0.boolean(), valibot__rspack_import_0.description('Omission defaults to true; the effective next action is returned in strategy_hint.'))),
     thought_number: valibot__rspack_import_0.pipe(valibot__rspack_import_0.number(), valibot__rspack_import_0.minValue(1), valibot__rspack_import_0.description('Current thought number')),
     total_thoughts: valibot__rspack_import_0.pipe(valibot__rspack_import_0.number(), valibot__rspack_import_0.minValue(1), valibot__rspack_import_0.description('Estimated total thoughts needed')),
     is_revision: valibot__rspack_import_0.optional(valibot__rspack_import_0.pipe(valibot__rspack_import_0.boolean(), valibot__rspack_import_0.description('Whether this revises previous thinking'))),
@@ -1926,8 +1326,61 @@ __webpack_require__.d(__webpack_exports__, {
 
 
 },
-"o"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var _core_ids_js__rspack_import_0 = __webpack_require__("Uz");
+"E"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  StreamableHttpTransport: () => (/* binding */ StreamableHttpTransport)
+});
+
+// UNUSED EXPORTS: createStreamableHttpTransport
+
+;// CONCATENATED MODULE: external "node:crypto"
+
+;// CONCATENATED MODULE: external "node:http"
+
+// EXTERNAL MODULE: external "valibot"
+var external_valibot_ = __webpack_require__("w");
+// EXTERNAL MODULE: ./src/errors.ts
+var errors = __webpack_require__("U");
+// EXTERNAL MODULE: ./src/schema.ts
+var schema = __webpack_require__("R");
+;// CONCATENATED MODULE: ./src/core/ids.ts
+/**
+ * Unique identifier generation utilities for thoughts and edges.
+ *
+ * @module core/ids
+ */ 
+/**
+ * Generate a unique lexicographically-sortable identifier.
+ *
+ * Format: 8-char base36 timestamp + 20-char hex random (10 random bytes).
+ * Result is up to 28 characters, sortable by creation time.
+ *
+ * @returns A unique string identifier.
+ *
+ * @example
+ * ```typescript
+ * const id = generateUlid(); // '01h2k3m400a1b2c3d4e5f6...'
+ * ```
+ */ function ids_generateUlid() {
+    const timestamp = Date.now().toString(36).padStart(8, '0');
+    const random = crypto.randomBytes(10).toString('hex');
+    return `${timestamp}${random}`;
+}
+/**
+ * Valid session ID pattern: alphanumeric, hyphens, underscores.
+ *
+ * Length is enforced separately via {@link MAX_SESSION_ID_LENGTH}.
+ * Same character set as branch IDs.
+ */ const SESSION_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+/**
+ * Maximum session ID length (in characters).
+ *
+ * Allows compound identifiers (e.g. `user-123_task-abc`).
+ */ const MAX_SESSION_ID_LENGTH = 100;
+
+;// CONCATENATED MODULE: ./src/transport/BaseTransport.ts
 /**
  * Base transport implementation.
  *
@@ -2018,7 +1471,7 @@ class BaseTransport {
         if (sessionId.length > (/* inlined export .MAX_SESSION_ID_LENGTH */100)) {
             return false;
         }
-        return _core_ids_js__rspack_import_0/* .SESSION_ID_PATTERN.test */.I.test(sessionId);
+        return SESSION_ID_PATTERN.test(sessionId);
     }
     /**
 	 * Sanitize query parameters by removing any not in whitelist.
@@ -2256,669 +1709,83 @@ class BaseTransport {
     }
 }
 
-__webpack_require__.d(__webpack_exports__, {
-  j: () => (BaseTransport)
-});
-
-
-},
-"W"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var node_http__rspack_import_0 = __webpack_require__("S");
-/* import */ var node_crypto__rspack_import_1 = __webpack_require__("i");
-/* import */ var node_url__rspack_import_2 = __webpack_require__("Y");
-/* import */ var valibot__rspack_import_3 = __webpack_require__("w");
-/* import */ var _errors_js__rspack_import_4 = __webpack_require__("U");
-/* import */ var _pool_PoolErrors_js__rspack_import_5 = __webpack_require__("K");
-/* import */ var _schema_js__rspack_import_6 = __webpack_require__("R");
-/* import */ var _BaseTransport_js__rspack_import_7 = __webpack_require__("o");
-/* import */ var _contracts_ids_js__rspack_import_8 = __webpack_require__("j");
-/* import */ var _context_RequestContext_js__rspack_import_9 = __webpack_require__("y");
-/* import */ var _utils_js__rspack_import_10 = __webpack_require__("h");
+;// CONCATENATED MODULE: ./src/contracts/ids.ts
 /**
- * SSE (Server-Sent Events) Transport implementation.
- *
- * This transport allows multiple concurrent connections over HTTP using Server-Sent Events,
- * enabling multi-user scenarios and horizontal scaling.
+ * Branded identifier types for compile-time slot safety.
  *
- * When a ConnectionPool is provided, each SSE client gets an isolated session with its own
- * thought history. Without a pool, all clients share a single server instance (backward compatible).
+ * These nominal types prevent accidental mixing of different ID kinds
+ * (e.g. passing a `ThoughtId` where a `SessionId` is expected). At
+ * runtime they are plain strings — the brand exists only in the type
+ * system.
  *
- * @example
- * ```typescript
- * const transport = new SseTransport({
- *   port: 3000,
- *   host: 'localhost'
- * });
- * await transport.connect(server);
- * ```
+ * @module contracts/ids
  */ 
 
-
-
-
-
-
-
-
-
-
-/** Rejects persistence backends that cannot isolate pooled SSE child servers. */ function assertPooledSsePersistence(poolingEnabled, persistence) {
-    if (poolingEnabled && persistence?.enabled === true && (persistence.backend === 'file' || persistence.backend === 'sqlite')) {
-        throw new _errors_js__rspack_import_4/* .ConfigurationError */.j1(`pooled SSE does not support ${persistence.backend} persistence`);
-    }
-}
 /**
- * SSE Transport for MCP server over HTTP.
- *
- * This transport uses Server-Sent Events (SSE) to communicate with clients,
- * allowing multiple concurrent connections and web-based clients.
+ * Validate and brand a string as a {@link SessionId}.
  *
- * @remarks
- * **Security Features:**
- * - Session ID validation (alphanumeric, max 64 chars)
- * - Query parameter sanitization (whitelist allowed keys)
- * - Rate limiting per IP (configurable, default 100 req/min)
- * - CORS origin validation
+ * Enforces {@link SESSION_ID_PATTERN} and {@link MAX_SESSION_ID_LENGTH}.
+ * The reserved global session sentinel `__global__` is always accepted.
  *
- * **Rate Limiting:**
- * - Tracks requests per IP address within a time window
- * - Returns 429 Too Many Requests when limit exceeded
- * - Can be disabled via `enableRateLimit: false`
- */ class SseTransport extends _BaseTransport_js__rspack_import_7/* .BaseTransport */.j {
-    get kind() {
-        return 'sse';
+ * @throws {ValidationError} when the input is not a valid session id.
+ */ function asSessionId(value) {
+    if (value === '__global__') {
+        // eslint-disable-next-line no-restricted-syntax -- branding constructor, cannot self-reference
+        return value;
     }
-    _server;
-    _path;
-    _clients = new Set();
-    _clientSessionMap = new Map();
-    _sessionAttachmentCounts = new Map();
-    _releasePromises = new WeakMap();
-    _pendingReleases = new Set();
-    _releaseFailures = new Set();
-    _messageQueue = new Map();
-    _metrics;
-    _connectionPool;
-    _stopPromise = null;
-    constructor(options = {}){
-        assertPooledSsePersistence(options.connectionPool !== undefined, options.persistence);
-        super(options);
-        this._path = options.path ?? '/sse';
-        this._metrics = options.metrics;
-        this._connectionPool = options.connectionPool;
-        this._updateActiveConnectionsMetric();
-        this._server = (0,node_http__rspack_import_0.createServer)((req, res)=>this._handleRequest(req, res));
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new errors/* .ValidationError */.yI('session_id', 'must be a non-empty string');
     }
-    /**
-	 * Connect MCP server to this transport.
-	 *
-	 * @param mcpServer - The MCP server instance
-	 */ async connect(mcpServer) {
-        this._mcpServer = mcpServer;
-        return new Promise((resolve, reject)=>{
-            const cleanup = ()=>{
-                this._server.off('error', onError);
-                this._server.off('listening', onListening);
-            };
-            const onError = (error)=>{
-                cleanup();
-                reject(error);
-            };
-            const onListening = ()=>{
-                cleanup();
-                this.log('info', `SSE transport listening on http://${this._host}:${this._port}`);
-                resolve();
-            };
-            this._server.once('error', onError);
-            this._server.once('listening', onListening);
-            try {
-                this._server.listen(this._port, this._host);
-            } catch (error) {
-                cleanup();
-                reject(error);
-            }
-        });
+    if (value.length > (/* inlined export .MAX_SESSION_ID_LENGTH */100)) {
+        throw new errors/* .ValidationError */.yI('session_id', `exceeds max length of ${(/* inlined export .MAX_SESSION_ID_LENGTH */100)}`);
     }
-    _mcpServer = null;
-    /**
-	 * Handle incoming HTTP requests
-	 */ async _handleRequest(req, res) {
-        const routing = this._prepareRequest(req, res);
-        if (!routing) return;
-        if (this._enableCors && req.method === 'OPTIONS') {
-            res.writeHead(204);
-            res.end();
-            return;
-        }
-        if (routing.url.pathname === this._path && req.method === 'GET') {
-            await this._handleSseConnection(req, res, routing.params);
-            return;
-        }
-        if (routing.url.pathname === `${this._path}/message` && req.method === 'POST') {
-            await this._handleMessage(req, res, routing.params);
-            return;
-        }
-        if (routing.url.pathname === '/health') {
-            this._handleHealthCheck(res);
-            return;
-        }
-        if (routing.url.pathname === '/ready') {
-            await this._handleReadinessCheck(res);
-            return;
-        }
-        res.writeHead(404, {
-            'Content-Type': 'text/plain'
-        });
-        res.end('Not Found');
-    }
-    _prepareRequest(req, res) {
-        const startTime = Date.now();
-        const requestPath = req.url || '/';
-        const requestMethod = req.method || 'GET';
-        this._metrics?.counter('http_requests_total', 1, {
-            transport: 'sse',
-            method: requestMethod,
-            path: requestPath
-        }, 'Total HTTP requests');
-        res.once('finish', ()=>{
-            const durationSeconds = (Date.now() - startTime) / 1000;
-            this._metrics?.histogram('http_request_duration_seconds', durationSeconds, {
-                transport: 'sse',
-                path: requestPath
-            });
-        });
-        if (!this.validateHostHeader(req)) {
-            this._metrics?.counter('http_request_errors_total', 1, {
-                transport: 'sse',
-                error_type: 'forbidden'
-            }, 'Total HTTP request errors');
-            res.writeHead(403, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify({
-                error: 'Forbidden - invalid host header'
-            }));
-            return;
-        }
-        const url = new node_url__rspack_import_2.URL(req.url || '', `http://${req.headers.host}`);
-        // Check rate limit first
-        const clientIp = this.getClientIp(req);
-        if (this.checkRateLimit(clientIp)) {
-            this._metrics?.counter('http_request_errors_total', 1, {
-                transport: 'sse',
-                error_type: 'rate_limit'
-            }, 'Total HTTP request errors');
-            res.writeHead(429, {
-                'Content-Type': 'application/json',
-                'Retry-After': '60'
-            });
-            res.end(JSON.stringify({
-                error: 'Too many requests'
-            }));
-            return;
-        }
-        // Validate CORS origin
-        if (!this.validateCorsOrigin(req)) {
-            this._metrics?.counter('http_request_errors_total', 1, {
-                transport: 'sse',
-                error_type: 'forbidden'
-            }, 'Total HTTP request errors');
-            res.writeHead(403, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify({
-                error: 'Forbidden - invalid origin'
-            }));
-            return;
-        }
-        // Set CORS headers
-        this.setCorsHeaders(res);
-        // Sanitize query parameters
-        const sanitizedParams = this.sanitizeQueryParams(url);
-        // Validate session ID if present
-        const requestSessionId = sanitizedParams.session ?? sanitizedParams.sessionId;
-        if (requestSessionId !== undefined && !this.validateSessionId(requestSessionId)) {
-            this._metrics?.counter('http_request_errors_total', 1, {
-                transport: 'sse',
-                error_type: 'validation'
-            }, 'Total HTTP request errors');
-            res.writeHead(400, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify({
-                error: 'Invalid session ID format'
-            }));
-            return undefined;
-        }
-        return {
-            url,
-            params: sanitizedParams
-        };
-    }
-    /**
-	 * Handle health check (liveness) endpoint
-	 */ _handleHealthCheck(res) {
-        const healthData = {
-            status: 'healthy',
-            clients: this._clients.size
-        };
-        if (this._connectionPool) {
-            const poolStats = this._connectionPool.getStats();
-            healthData.pool = poolStats;
-        }
-        if (this._healthChecker) {
-            const liveness = this._healthChecker.checkLiveness();
-            healthData.liveness = liveness;
-        }
-        res.writeHead(200, {
-            'Content-Type': 'application/json'
-        });
-        res.end(JSON.stringify(healthData));
-    }
-    /**
-	 * Handle readiness check endpoint
-	 */ async _handleReadinessCheck(res) {
-        if (this._healthChecker) {
-            const readiness = await this._healthChecker.checkReadiness();
-            const statusCode = readiness.status === 'ok' ? 200 : 503;
-            res.writeHead(statusCode, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify(readiness));
-        } else {
-            res.writeHead(200, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify({
-                status: 'ok',
-                timestamp: new Date().toISOString(),
-                components: {}
-            }));
-        }
-    }
-    /**
-	 * Handle new SSE connection
-	 */ async _handleSseConnection(req, res, params) {
-        // Set SSE headers
-        res.writeHead(200, {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache',
-            Connection: 'keep-alive'
-        });
-        // Resolve session ID when pool is active
-        let sessionId;
-        if (this._connectionPool) {
-            const requestedSession = params.session ?? params.sessionId;
-            const requestedSessionId = requestedSession ? (0,_contracts_ids_js__rspack_import_8/* .asSessionId */.Kd)(requestedSession) : undefined;
-            if (requestedSessionId && this._connectionPool.getSessionInfo(requestedSessionId)) {
-                sessionId = requestedSessionId;
-            } else {
-                try {
-                    sessionId = await this._connectionPool.createSession();
-                } catch (error) {
-                    res.write(`event: error\n`);
-                    res.write(`data: ${JSON.stringify({
-                        error: error instanceof Error ? error.message : 'Failed to create session'
-                    })}\n\n`);
-                    res.end();
-                    return;
-                }
-            }
-            this._clientSessionMap.set(res, sessionId);
-            this._sessionAttachmentCounts.set(sessionId, (this._sessionAttachmentCounts.get(sessionId) ?? 0) + 1);
-            this._updatePoolMetrics();
-        }
-        this._clients.add(res);
-        this._updateActiveConnectionsMetric();
-        const release = ()=>this._releaseAfterDisconnect(res);
-        req.once('close', release);
-        res.once('close', release);
-        res.once('error', release);
-        // Send initial connection event
-        const connectedPayload = {
-            timestamp: Date.now()
-        };
-        if (sessionId) {
-            connectedPayload.sessionId = sessionId;
-        }
-        this._sendSseEvent(res, 'connected', connectedPayload);
-        // Send any queued messages
-        const clientId = this._generateClientId();
-        const queued = this._messageQueue.get(clientId);
-        if (queued) {
-            for (const message of queued){
-                this._sendSseEvent(res, 'message', message);
-            }
-            this._messageQueue.delete(clientId);
-        }
-    }
-    /**
-	 * Handle incoming message from client
-	 */ async _handleMessage(req, res, params) {
-        let pooledOwner;
-        if (this._connectionPool) {
-            const correlation = params.session ?? params.sessionId;
-            if (correlation === undefined) {
-                res.writeHead(400, {
-                    'Content-Type': 'application/json'
-                });
-                res.end(JSON.stringify({
-                    error: 'Missing session ID'
-                }));
-                return;
-            }
-            pooledOwner = (0,_contracts_ids_js__rspack_import_8/* .asSessionId */.Kd)(correlation);
-        }
-        const jsonRpcRequest = await this._parseMessage(req, res);
-        if (!jsonRpcRequest) return;
-        const mcpServer = this._mcpServer;
-        if (!mcpServer) {
-            this._metrics?.counter('http_request_errors_total', 1, {
-                transport: 'sse',
-                error_type: 'server_not_ready'
-            }, 'Total HTTP request errors');
-            res.writeHead(503, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify({
-                error: 'Server not ready'
-            }));
-            return;
-        }
-        const owner = pooledOwner ?? `sse-${(0,node_crypto__rspack_import_1.randomUUID)()}`;
-        const receive = ()=>(0,_context_RequestContext_js__rspack_import_9/* .runWithContext */.Vo)({
-                requestId: (0,node_crypto__rspack_import_1.randomUUID)(),
-                owner
-            }, ()=>mcpServer.receive(jsonRpcRequest, {
-                    sessionInfo: {}
-                }));
-        try {
-            let response;
-            if (this._connectionPool && pooledOwner) {
-                if (typeof this._connectionPool.runWithSession !== 'function') {
-                    this._writeSessionUnavailable(res);
-                    return;
-                }
-                const result = await this._connectionPool.runWithSession(pooledOwner, receive);
-                switch(result.status){
-                    case 'completed':
-                        response = result.value;
-                        break;
-                    case 'inactive':
-                    case 'missing':
-                        this._writeSessionUnavailable(res);
-                        return;
-                    default:
-                        return (0,_utils_js__rspack_import_10/* .assertNever */.x)(result);
-                }
-            } else {
-                response = await receive();
-            }
-            res.writeHead(200, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify(response ?? {
-                jsonrpc: '2.0',
-                id: 'id' in jsonRpcRequest ? jsonRpcRequest.id : null,
-                result: null
-            }));
-        } catch (error) {
-            if (error instanceof _pool_PoolErrors_js__rspack_import_5/* .SessionNotFoundError */.A || error instanceof _pool_PoolErrors_js__rspack_import_5/* .SessionNotActiveError */.q) {
-                this._writeSessionUnavailable(res);
-                return;
-            }
-            throw error;
-        }
-    }
-    async _parseMessage(req, res) {
-        let body = '';
-        for await (const chunk of req){
-            body += chunk.toString();
-        }
-        let rawBody;
-        try {
-            rawBody = JSON.parse(body);
-        } catch (error) {
-            if (!(error instanceof SyntaxError)) throw error;
-            this._metrics?.counter('http_request_errors_total', 1, {
-                transport: 'sse',
-                error_type: 'parse_error'
-            }, 'Total HTTP request errors');
-            res.writeHead(400, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify({
-                error: 'Invalid JSON'
-            }));
-            return;
-        }
-        const parseResult = (0,valibot__rspack_import_3.safeParse)(_schema_js__rspack_import_6/* .JsonRpcRequestSchema */.Uv, rawBody);
-        const rawId = rawBody && typeof rawBody === 'object' && 'id' in rawBody ? rawBody.id ?? null : null;
-        if (!parseResult.success) {
-            this._metrics?.counter('http_request_errors_total', 1, {
-                transport: 'sse',
-                error_type: 'validation'
-            }, 'Total HTTP request errors');
-            res.writeHead(200, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify({
-                jsonrpc: '2.0',
-                id: rawId,
-                error: {
-                    code: -32600,
-                    message: 'Invalid Request',
-                    data: parseResult.issues
-                }
-            }));
-            return;
-        }
-        return parseResult.output;
-    }
-    _writeSessionUnavailable(res) {
-        res.writeHead(404, {
-            'Content-Type': 'application/json'
-        });
-        res.end(JSON.stringify({
-            error: 'Session not found'
-        }));
-    }
-    _releaseClient(res) {
-        const existing = this._releasePromises.get(res);
-        if (existing) {
-            return existing;
-        }
-        this._clients.delete(res);
-        const sessionId = this._clientSessionMap.get(res);
-        this._clientSessionMap.delete(res);
-        this._updateActiveConnectionsMetric();
-        let releasePromise = Promise.resolve();
-        if (sessionId && this._connectionPool) {
-            const attachmentCount = this._sessionAttachmentCounts.get(sessionId);
-            if (attachmentCount !== undefined && attachmentCount > 1) {
-                this._sessionAttachmentCounts.set(sessionId, attachmentCount - 1);
-            } else {
-                this._sessionAttachmentCounts.delete(sessionId);
-                releasePromise = this._connectionPool.closeSession(sessionId).catch((error)=>{
-                    if (error instanceof _pool_PoolErrors_js__rspack_import_5/* .SessionNotFoundError */.A) {
-                        return;
-                    }
-                    throw error;
-                });
-            }
-            this._updatePoolMetrics();
-        }
-        this._releasePromises.set(res, releasePromise);
-        this._pendingReleases.add(releasePromise);
-        void releasePromise.then(()=>this._pendingReleases.delete(releasePromise), (error)=>{
-            this._pendingReleases.delete(releasePromise);
-            this._releaseFailures.add(error);
-        });
-        return releasePromise;
-    }
-    _releaseAfterDisconnect(res) {
-        void this._releaseClient(res).catch((error)=>{
-            this.log('error', 'SSE pooled session release failed', {
-                error
-            });
-        });
-    }
-    /**
-	 * Send an SSE event to a specific client
-	 */ _sendSseEvent(res, event, data) {
-        try {
-            res.write(`event: ${event}\n`);
-            res.write(`data: ${JSON.stringify(data)}\n\n`);
-        } catch  {
-            this._releaseAfterDisconnect(res);
-        }
-    }
-    _updateActiveConnectionsMetric() {
-        this._metrics?.gauge('sse_active_connections', this._clients.size, {}, 'Current active SSE connections');
-    }
-    _updatePoolMetrics() {
-        if (!this._connectionPool || !this._metrics) {
-            return;
-        }
-        const stats = this._connectionPool.getStats();
-        this._metrics.gauge('sse_pool_active_sessions', stats.activeSessions, {}, 'Active sessions in connection pool');
-        this._metrics.gauge('sse_pool_total_sessions', stats.totalSessions, {}, 'Total sessions in connection pool');
-        this._metrics.gauge('sse_pool_max_sessions', stats.maxSessions, {}, 'Maximum sessions in connection pool');
-    }
-    /**
-	 * Broadcast a message to all connected clients
-	 */ broadcast(event, data) {
-        for (const client of this._clients){
-            this._sendSseEvent(client, event, data);
-        }
-    }
-    /**
-	 * Generate a unique client ID
-	 */ _generateClientId() {
-        return `client_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
-    }
-    /**
-	 * Get number of connected clients
-	 */ get clientCount() {
-        return this._clients.size;
-    }
-    /**
-	 * Get the connection pool, if one was configured.
-	 */ get connectionPool() {
-        return this._connectionPool;
-    }
-    /**
-	 * Stop the transport server with graceful shutdown.
-	 *
-	 * @param timeout - Maximum time to wait for requests to drain (not used for SSE)
-	 * @returns Promise that resolves when shutdown is complete
-	 */ stop(_timeout) {
-        if (this._stopPromise) {
-            return this._stopPromise;
-        }
-        const completion = Promise.withResolvers();
-        this._stopPromise = completion.promise;
-        this._isShuttingDown = true;
-        this._stopRateLimitCleanup();
-        const operations = new Set();
-        for (const client of Array.from(this._clients)){
-            operations.add(this._releaseClient(client));
-            try {
-                client.end();
-            } catch (error) {
-                operations.add(Promise.reject(error instanceof Error ? error : new AggregateError([
-                    error
-                ], 'SSE client close failed')));
-            }
-        }
-        for (const release of this._pendingReleases){
-            operations.add(release);
-        }
-        if (this._connectionPool) {
-            operations.add(this._connectionPool.terminate());
-        }
-        operations.add(this._server.listening ? new Promise((resolve, reject)=>{
-            this._server.close((error)=>error ? reject(error) : resolve());
-        }) : Promise.resolve());
-        void Promise.allSettled(operations).then((outcomes)=>{
-            const failures = new Set(this._releaseFailures);
-            for (const outcome of outcomes){
-                if (outcome.status !== 'rejected') {
-                    continue;
-                }
-                if (outcome.reason instanceof AggregateError) {
-                    for (const error of outcome.reason.errors)failures.add(error);
-                } else {
-                    failures.add(outcome.reason);
-                }
-            }
-            this._clients.clear();
-            this._clientSessionMap.clear();
-            this._sessionAttachmentCounts.clear();
-            this._updateActiveConnectionsMetric();
-            this._updatePoolMetrics();
-            if (failures.size > 0) {
-                completion.reject(new AggregateError(failures, 'SSE transport shutdown failed'));
-                return;
-            }
-            this.log('info', 'SSE transport stopped');
-            completion.resolve();
-        });
-        return completion.promise;
+    if (!SESSION_ID_PATTERN.test(value)) {
+        throw new errors/* .ValidationError */.yI('session_id', 'must match alphanumeric, hyphens, underscores');
     }
+    // eslint-disable-next-line no-restricted-syntax -- branding constructor, cannot self-reference
+    return value;
+}
+/** Brand a string as a {@link ThoughtId} without validation. */ function asThoughtId(value) {
+    return value;
+}
+/** Brand a string as an {@link EdgeId} without validation. */ function asEdgeId(value) {
+    return value;
+}
+/** Brand a string as a {@link SuspensionToken} without validation. */ function asSuspensionToken(value) {
+    return value;
+}
+/** Brand a string as a {@link BranchId} without validation. */ function asBranchId(value) {
+    return value;
+}
+/** Brand a string as a {@link SummaryId} without validation. */ function asSummaryId(value) {
+    return value;
+}
+/** Generate a fresh {@link ThoughtId}. */ function generateThoughtId() {
+    return generateUlid();
+}
+/** Generate a fresh {@link EdgeId}. */ function generateEdgeId() {
+    return generateUlid();
+}
+/** Generate a fresh {@link SuspensionToken}. */ function generateSuspensionToken() {
+    return generateUlid();
+}
+/** Generate a fresh {@link SummaryId}. */ function generateSummaryId() {
+    return generateUlid();
 }
 /**
- * Create an SSE transport with given options.
- *
- * @param options - Transport configuration
- * @returns A configured SSE transport
+ * Reserved sentinel session id used when callers omit `session_id`.
  *
- * @example
- * ```typescript
- * const transport = createSseTransport({ port: 3000 });
- * await transport.connect(mcpServer);
- * ```
- */ function createSseTransport(options = {}) {
-    return new SseTransport(options);
-}
-
-__webpack_require__.d(__webpack_exports__, {
-  SseTransport: () => (SseTransport),
-  c: () => (assertPooledSsePersistence)
-});
-
-
-},
-"J"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  StreamableHttpTransport: () => (/* binding */ StreamableHttpTransport)
-});
-
-// UNUSED EXPORTS: createStreamableHttpTransport
+ * Branded once here so production and test code share one constant
+ * instead of casting `'__global__'` ad-hoc.
+ */ const GLOBAL_SESSION_ID = asSessionId('__global__');
 
-// EXTERNAL MODULE: external "node:crypto"
-var external_node_crypto_ = __webpack_require__("i");
-// EXTERNAL MODULE: external "node:http"
-var external_node_http_ = __webpack_require__("S");
-// EXTERNAL MODULE: external "valibot"
-var external_valibot_ = __webpack_require__("w");
-// EXTERNAL MODULE: ./src/errors.ts
-var errors = __webpack_require__("U");
-// EXTERNAL MODULE: ./src/schema.ts
-var schema = __webpack_require__("R");
-// EXTERNAL MODULE: ./src/transport/BaseTransport.ts
-var BaseTransport = __webpack_require__("o");
-// EXTERNAL MODULE: ./src/contracts/ids.ts
-var ids = __webpack_require__("j");
 ;// CONCATENATED MODULE: ./src/transport/HttpHelpers.ts
 /**
  * Shared HTTP helper utilities for MCP transport implementations.
  *
  * Centralizes JSON-RPC response formatting, request body reading,
  * and common HTTP response patterns to eliminate duplication across
- * HttpTransport, StreamableHttpTransport, and SseTransport.
+ * HttpTransport and StreamableHttpTransport.
  *
  * @module transport/HttpHelpers
  */ /**
@@ -3003,8 +1870,8 @@ var ids = __webpack_require__("j");
     return body;
 }
 
-// EXTERNAL MODULE: ./src/context/RequestContext.ts
-var RequestContext = __webpack_require__("y");
+// EXTERNAL MODULE: ./src/context/RequestContext.ts + 1 modules
+var RequestContext = __webpack_require__("i");
 ;// CONCATENATED MODULE: ./src/transport/HttpRequestLifecycle.ts
 /** Maximum number of reporting failures retained for diagnostics. */ const LIFECYCLE_REPORTING_FAILURE_CAPACITY = 32;
 class LifecycleFailureReporter {
@@ -3160,7 +2027,7 @@ class AcceptedWorkTracker {
  * - 429: Too Many Requests
  * - 500: Internal Server Error
  * - 503: Server Not Ready / Shutting Down
- */ class StreamableHttpTransport extends BaseTransport/* .BaseTransport */.j {
+ */ class StreamableHttpTransport extends BaseTransport {
     get kind() {
         return 'streamable-http';
     }
@@ -3184,7 +2051,7 @@ class AcceptedWorkTracker {
         super(options);
         this._path = options.path ?? '/mcp';
         this._stateful = options.stateful ?? true;
-        this._sessionIdGenerator = options.sessionIdGenerator ?? (()=>(0,external_node_crypto_.randomUUID)());
+        this._sessionIdGenerator = options.sessionIdGenerator ?? (()=>(0,__rspack_external_node_crypto_2e7c4b46.randomUUID)());
         this._bodySizeLimitEnabled = options.enableBodySizeLimit ?? true;
         this._maxBodySize = options.maxBodySize ?? 10 * 1024 * 1024;
         this._requestTimeout = options.requestTimeout ?? 30000;
@@ -3217,7 +2084,7 @@ class AcceptedWorkTracker {
 	 * Connects MCP server to this transport and starts listening.
 	 */ async connect(mcpServer) {
         this._mcpServer = mcpServer;
-        const server = (0,external_node_http_.createServer)((req, res)=>{
+        const server = (0,__rspack_external_node_http_e245b239.createServer)((req, res)=>{
             const responseFinalizer = new ResponseFinalizer(res, this._lifecycleFailureReporter);
             void this._handleRequest(req, res).catch((error)=>{
                 this._lifecycleFailureReporter.report(error);
@@ -3435,9 +2302,9 @@ class AcceptedWorkTracker {
         }
     }
     async _receiveAndFinalize(jsonRpcRequest, sessionId, responseFinalizer) {
-        const owner = this._stateful ? sessionId ?? (0,external_node_crypto_.randomUUID)() : (0,external_node_crypto_.randomUUID)();
+        const owner = this._stateful ? sessionId ?? (0,__rspack_external_node_crypto_2e7c4b46.randomUUID)() : (0,__rspack_external_node_crypto_2e7c4b46.randomUUID)();
         const response = await (0,RequestContext/* .runWithContext */.Vo)({
-            requestId: (0,external_node_crypto_.randomUUID)(),
+            requestId: (0,__rspack_external_node_crypto_2e7c4b46.randomUUID)(),
             owner
         }, ()=>this._requireMcpServer().receive(jsonRpcRequest, {
                 sessionInfo: {}
@@ -3496,7 +2363,7 @@ class AcceptedWorkTracker {
             }));
             return;
         }
-        const session = this._sessions.get((0,ids/* .asSessionId */.Kd)(sessionId));
+        const session = this._sessions.get(asSessionId(sessionId));
         if (!session) {
             res.writeHead(404, {
                 'Content-Type': 'application/json'
@@ -3549,7 +2416,7 @@ class AcceptedWorkTracker {
                 };
             }
             // Check if session exists
-            const session = this._sessions.get((0,ids/* .asSessionId */.Kd)(headerSessionId));
+            const session = this._sessions.get(asSessionId(headerSessionId));
             if (session) {
                 session.lastActivityAt = Date.now();
                 return headerSessionId;
@@ -3569,7 +2436,7 @@ class AcceptedWorkTracker {
             lastActivityAt: Date.now(),
             notificationStreams: new Set()
         };
-        this._sessions.set((0,ids/* .asSessionId */.Kd)(newSessionId), sessionState);
+        this._sessions.set(asSessionId(newSessionId), sessionState);
         this.log('info', `New session created: ${newSessionId}`);
         this._updateSessionMetrics();
         return newSessionId;
@@ -3600,7 +2467,7 @@ class AcceptedWorkTracker {
 	 * @param event - SSE event name
 	 * @param data - Event payload
 	 */ broadcastToSession(sessionId, event, data) {
-        const session = this._sessions.get((0,ids/* .asSessionId */.Kd)(sessionId));
+        const session = this._sessions.get(asSessionId(sessionId));
         if (!session) {
             return;
         }
@@ -3741,76 +2608,12 @@ class AcceptedWorkTracker {
  *
  * @example
  * ```typescript
- * const transport = createStreamableHttpTransport({ port: 3000, stateful: true });
- * await transport.connect(server);
- * ```
- */ function createStreamableHttpTransport(options = {}) {
-    return new StreamableHttpTransport(options);
-}
-
-
-},
-"h"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/**
- * Shared utility helpers.
- *
- * @module utils
- */ /**
- * Asserts that a value is `never`. Use in switch default cases to enforce
- * exhaustiveness over discriminated unions. TypeScript will error at compile
- * time if any variant of the union is unhandled.
- *
- * @param value - The value that should be statically `never`.
- * @param message - Optional error message override.
- * @returns Never returns; always throws.
- *
- * @example
- * ```ts
- * function handle(t: ThoughtType): string {
- *   switch (t) {
- *     case 'regular': return 'r';
- *     // ... all other cases ...
- *     default: assertNever(t);
- *   }
- * }
- * ```
- */ function assertNever(value, message) {
-    throw new Error(message ?? `Unexpected value: ${String(value)}`);
-}
-
-__webpack_require__.d(__webpack_exports__, {
-  x: () => (assertNever)
-});
-
-
-},
-"r"(module) {
-
-module.exports = __rspack_external__lib_js_1645bc55;
-
-
-},
-"A"(module) {
-
-module.exports = __rspack_external_node_async_hooks_4d8b1b4a;
-
-
-},
-"i"(module) {
-
-module.exports = __rspack_external_node_crypto_2e7c4b46;
-
-
-},
-"S"(module) {
-
-module.exports = __rspack_external_node_http_e245b239;
-
-
-},
-"Y"(module) {
-
-module.exports = __rspack_external_node_url_3991086a;
+ * const transport = createStreamableHttpTransport({ port: 3000, stateful: true });
+ * await transport.connect(server);
+ * ```
+ */ function createStreamableHttpTransport(options = {}) {
+    return new StreamableHttpTransport(options);
+}
 
 
 },
@@ -3875,8 +2678,8 @@ var __webpack_exports__ = {};
 
 ;// CONCATENATED MODULE: external "node:path"
 
-// EXTERNAL MODULE: external "node:url"
-var external_node_url_ = __webpack_require__("Y");
+;// CONCATENATED MODULE: external "node:url"
+
 ;// CONCATENATED MODULE: external "tmcp"
 
 // EXTERNAL MODULE: ./src/errors.ts
@@ -3974,734 +2777,10 @@ function createCliShutdownHandler(lifecycle, boundary) {
     };
 }
 
-// EXTERNAL MODULE: external "./lib.js"
-var external_lib_js_ = __webpack_require__("r");
-;// CONCATENATED MODULE: external "node:os"
-
-;// CONCATENATED MODULE: ./src/ServerConfig.ts
-/**
- * Server configuration management with validation.
- *
- * This module provides the `ServerConfig` class which handles all server configuration
- * with built-in validation and sensible defaults. Configuration values are validated
- * on construction and warnings are emitted for out-of-range values.
- *
- * @module ServerConfig
- */ 
-
-
-/**
- * Server configuration with validation and defaults.
- *
- * This class manages all server configuration including history limits,
- * branch limits, discovery directories, cache settings, and persistence.
- * All values are validated on construction with appropriate defaults applied.
- *
- * @remarks
- * - Values outside recommended ranges trigger warnings but are still applied
- * - Environment variables override file-based configuration
- * - The `toJSON()` method provides a plain object representation
- *
- * @example
- * ```typescript
- * // Using defaults
- * const config1 = new ServerConfig();
- * console.log(config1.maxHistorySize); // 10000
- *
- * // With custom options
- * const config2 = new ServerConfig({
- *   maxHistorySize: 500,
- *   persistence: { enabled: true, backend: 'file', options: { dataDir: './data' } }
- * });
- *
- * // Export as plain object
- * const json = config2.toJSON();
- * ```
- */ class ServerConfig {
-    /** Maximum number of thoughts to keep in history. */ maxHistorySize;
-    /** Maximum number of branches to maintain. */ maxBranches;
-    /** Maximum size of each branch. */ maxBranchSize;
-    /** Directory paths to search for skills. */ skillDirs;
-    /** Directory paths to search for tools. */ toolDirs;
-    /** Discovery cache configuration. */ discoveryCache;
-    /** Persistence configuration. */ persistence;
-    /** Maximum number of thoughts to buffer before flushing to persistence. */ persistenceBufferSize;
-    /** Interval in milliseconds between periodic persistence flushes. */ persistenceFlushInterval;
-    /** Maximum number of retries for failed persistence flushes. */ persistenceMaxRetries;
-    /** Feature flag toggles. */ features;
-    /** TTL in milliseconds for suspended tool-interleave entries. */ toolInterleaveTtlMs;
-    /** Sweep interval in milliseconds for SuspensionStore expiration cleanup. */ toolInterleaveSweepMs;
-    /** Maximum sessions per owner (LRU per-owner bucket). */ maxSessionsPerOwner;
-    /**
-	 * Creates a new ServerConfig instance with validation.
-	 *
-	 * All values are validated and defaults are applied for undefined options.
-	 * Warnings are emitted to console for values outside recommended ranges.
-	 *
-	 * @param options - Optional configuration overrides
-	 *
-	 * @example
-	 * ```typescript
-	 * const config = new ServerConfig({
-	 *   maxHistorySize: 500,
-	 *   skillDirs: ['./my-skills']
-	 * });
-	 * ```
-	 */ constructor(options = {}){
-        this.maxHistorySize = this.validateMaxHistorySize(options.maxHistorySize);
-        this.maxBranches = this.validateMaxBranches(options.maxBranches);
-        this.maxBranchSize = this.validateMaxBranchSize(options.maxBranchSize);
-        this.skillDirs = this.validateSkillDirs(options.skillDirs);
-        this.toolDirs = this.validateToolDirs(options.toolDirs);
-        this.discoveryCache = this.validateDiscoveryCache(options.discoveryCache);
-        this.persistence = this.validatePersistence(options.persistence);
-        this.persistenceBufferSize = this.validatePersistenceBufferSize(options.persistenceBufferSize);
-        this.persistenceFlushInterval = this.validatePersistenceFlushInterval(options.persistenceFlushInterval);
-        this.persistenceMaxRetries = this.validatePersistenceMaxRetries(options.persistenceMaxRetries);
-        this.features = this.validateFeatures(options.features);
-        this.toolInterleaveTtlMs = this.validatePositiveMs(options.toolInterleaveTtlMs, 60000, 'toolInterleaveTtlMs');
-        this.toolInterleaveSweepMs = this.validatePositiveMs(options.toolInterleaveSweepMs, 60000, 'toolInterleaveSweepMs');
-        this.maxSessionsPerOwner = this.validateMaxSessionsPerOwner(options.maxSessionsPerOwner);
-    }
-    /**
-	 * Validates the max history size value.
-	 * @param value - The value to validate
-	 * @returns The validated value or default (1000)
-	 * @private
-	 */ validateMaxHistorySize(value) {
-        const defaultValue = 10000;
-        if (value === undefined || value === null) return defaultValue;
-        if (typeof value !== 'number' || !Number.isFinite(value)) {
-            throw new errors/* .ConfigurationError */.j1(`maxHistorySize must be a finite number, got ${value}`);
-        }
-        if (value < 1) {
-            throw new errors/* .ConfigurationError */.j1(`maxHistorySize must be at least 1, got ${value}`);
-        }
-        if (value > 10000) {
-            throw new errors/* .ConfigurationError */.j1(`maxHistorySize must not exceed 10000, got ${value}`);
-        }
-        return value;
-    }
-    /**
-	 * Validates the max branches value.
-	 * @param value - The value to validate
-	 * @returns The validated value or default (50)
-	 * @private
-	 */ validateMaxBranches(value) {
-        const defaultValue = 50;
-        if (value === undefined || value === null) return defaultValue;
-        if (typeof value !== 'number' || !Number.isFinite(value)) {
-            throw new errors/* .ConfigurationError */.j1(`maxBranches must be a finite number, got ${value}`);
-        }
-        if (value < 0) {
-            throw new errors/* .ConfigurationError */.j1(`maxBranches must be non-negative, got ${value}`);
-        }
-        if (value > 1000) {
-            throw new errors/* .ConfigurationError */.j1(`maxBranches must not exceed 1000, got ${value}`);
-        }
-        return value;
-    }
-    /**
-	 * Validates the max branch size value.
-	 * @param value - The value to validate
-	 * @returns The validated value or default (100)
-	 * @private
-	 */ validateMaxBranchSize(value) {
-        const defaultValue = 100;
-        if (value === undefined || value === null) return defaultValue;
-        if (typeof value !== 'number' || !Number.isFinite(value)) {
-            throw new errors/* .ConfigurationError */.j1(`maxBranchSize must be a finite number, got ${value}`);
-        }
-        if (value < 1) {
-            throw new errors/* .ConfigurationError */.j1(`maxBranchSize must be at least 1, got ${value}`);
-        }
-        if (value > 1000) {
-            throw new errors/* .ConfigurationError */.j1(`maxBranchSize must not exceed 1000, got ${value}`);
-        }
-        return value;
-    }
-    /**
-	 * Validates the skill directories value.
-	 * @param value - The value to validate
-	 * @returns The validated value or default ['.claude/skills', '~/.claude/skills', '.agents/skills', '~/.agents/skills']
-	 * @private
-	 */ validateSkillDirs(value) {
-        const defaultValue = [
-            '.claude/skills',
-            join(homedir(), '.claude/skills'),
-            '.agents/skills',
-            join(homedir(), '.agents/skills')
-        ];
-        return value === undefined ? defaultValue : [
-            ...value
-        ];
-    }
-    validateToolDirs(value) {
-        const defaultValue = [
-            '.claude/tools',
-            join(homedir(), '.claude/tools')
-        ];
-        return value === undefined ? defaultValue : [
-            ...value
-        ];
-    }
-    /**
-	 * Validates the discovery cache configuration.
-	 * @param value - The value to validate
-	 * @returns The validated value with defaults applied
-	 * @private
-	 */ validateDiscoveryCache(value) {
-        return {
-            ttl: value?.ttl ?? 300000,
-            maxSize: value?.maxSize ?? 100
-        };
-    }
-    /**
-	 * Validates the persistence configuration.
-	 * @param value - The value to validate
-	 * @returns The validated value with defaults applied
-	 * @private
-	 */ validatePersistence(value) {
-        if (!value) {
-            // Default to in-memory (no actual persistence, just consistency)
-            return {
-                enabled: false,
-                backend: 'memory'
-            };
-        }
-        // Validate backend type
-        const validBackends = [
-            'file',
-            'sqlite',
-            'memory'
-        ];
-        const backend = value.backend ?? 'memory';
-        if (!validBackends.includes(backend)) {
-            throw new errors/* .ConfigurationError */.j1(`persistence.backend must be one of ${validBackends.join(', ')}, got ${backend}`);
-        }
-        return {
-            enabled: value.enabled ?? false,
-            backend,
-            options: value.options ?? {}
-        };
-    }
-    /**
-	 * Validates the persistence buffer size value.
-	 * @param value - The value to validate
-	 * @returns The validated value or default (100)
-	 * @private
-	 */ validatePersistenceBufferSize(value) {
-        const defaultValue = 100;
-        if (value === undefined || value === null) return defaultValue;
-        if (typeof value !== 'number' || !Number.isFinite(value)) {
-            throw new errors/* .ConfigurationError */.j1(`persistenceBufferSize must be a finite number, got ${value}`);
-        }
-        if (value < 1) {
-            throw new errors/* .ConfigurationError */.j1(`persistenceBufferSize must be at least 1, got ${value}`);
-        }
-        if (value > 10000) {
-            throw new errors/* .ConfigurationError */.j1(`persistenceBufferSize must not exceed 10000, got ${value}`);
-        }
-        return value;
-    }
-    /**
-	 * Validates the persistence flush interval value.
-	 * @param value - The value to validate
-	 * @returns The validated value or default (1000)
-	 * @private
-	 */ validatePersistenceFlushInterval(value) {
-        const defaultValue = 1000;
-        if (value === undefined || value === null) return defaultValue;
-        if (typeof value !== 'number' || !Number.isFinite(value)) {
-            throw new errors/* .ConfigurationError */.j1(`persistenceFlushInterval must be a finite number, got ${value}`);
-        }
-        if (value < 100) {
-            throw new errors/* .ConfigurationError */.j1(`persistenceFlushInterval must be at least 100, got ${value}`);
-        }
-        if (value > 60000) {
-            throw new errors/* .ConfigurationError */.j1(`persistenceFlushInterval must not exceed 60000, got ${value}`);
-        }
-        return value;
-    }
-    /**
-	 * Validates the persistence max retries value.
-	 * @param value - The value to validate
-	 * @returns The validated value or default (3)
-	 * @private
-	 */ validatePersistenceMaxRetries(value) {
-        const defaultValue = 3;
-        if (value === undefined || value === null) return defaultValue;
-        if (typeof value !== 'number' || !Number.isFinite(value)) {
-            throw new errors/* .ConfigurationError */.j1(`persistenceMaxRetries must be a finite number, got ${value}`);
-        }
-        if (value < 0) {
-            throw new errors/* .ConfigurationError */.j1(`persistenceMaxRetries must be non-negative, got ${value}`);
-        }
-        if (value > 10) {
-            throw new errors/* .ConfigurationError */.j1(`persistenceMaxRetries must not exceed 10, got ${value}`);
-        }
-        return value;
-    }
-    /**
-	 * Validates feature flags and fills defaults for missing fields.
-	 * @param value - Partial feature flag overrides
-	 * @returns Fully populated FeatureFlags with defaults applied
-	 * @private
-	 */ validateFeatures(value) {
-        const reasoningStrategy = value?.reasoningStrategy ?? 'sequential';
-        if (reasoningStrategy !== 'sequential' && reasoningStrategy !== 'tot') {
-            throw new errors/* .ConfigurationError */.j1(`features.reasoningStrategy must be one of sequential, tot, got ${reasoningStrategy}`);
-        }
-        return {
-            dagEdges: value?.dagEdges ?? true,
-            reasoningStrategy,
-            calibration: value?.calibration ?? true,
-            compression: value?.compression ?? true,
-            toolInterleave: value?.toolInterleave ?? true,
-            newThoughtTypes: value?.newThoughtTypes ?? true,
-            outcomeRecording: value?.outcomeRecording ?? true
-        };
-    }
-    /**
-	 * Validates a positive millisecond value with a default fallback.
-	 * @param value - The value to validate
-	 * @param defaultValue - Default applied if value is undefined/null
-	 * @param fieldName - Field name for error messages
-	 * @returns The validated millisecond value
-	 * @private
-	 */ validatePositiveMs(value, defaultValue, fieldName) {
-        if (value === undefined || value === null) return defaultValue;
-        if (typeof value !== 'number' || !Number.isFinite(value)) {
-            throw new errors/* .ConfigurationError */.j1(`${fieldName} must be a finite number, got ${value}`);
-        }
-        if (value < 1) {
-            throw new errors/* .ConfigurationError */.j1(`${fieldName} must be at least 1, got ${value}`);
-        }
-        return value;
-    }
-    /**
-	 * Validates the max sessions per owner value.
-	 * @param value - The value to validate
-	 * @returns The validated value or default (50)
-	 * @private
-	 */ validateMaxSessionsPerOwner(value) {
-        const defaultValue = 50;
-        if (value === undefined || value === null) return defaultValue;
-        if (typeof value !== 'number' || !Number.isFinite(value)) {
-            throw new errors/* .ConfigurationError */.j1(`maxSessionsPerOwner must be a finite number, got ${value}`);
-        }
-        if (value < 1) {
-            throw new errors/* .ConfigurationError */.j1(`maxSessionsPerOwner must be at least 1, got ${value}`);
-        }
-        if (value > 10000) {
-            throw new errors/* .ConfigurationError */.j1(`maxSessionsPerOwner must not exceed 10000, got ${value}`);
-        }
-        return value;
-    }
-    /**
-	 * Converts the configuration to a plain object.
-	 *
-	 * Useful for serialization, logging, or when a plain object representation
-	 * is preferred over the ServerConfig instance.
-	 *
-	 * @returns A plain object representation of the configuration
-	 *
-	 * @example
-	 * ```typescript
-	 * const config = new ServerConfig({ maxHistorySize: 500 });
-	 * const json = config.toJSON();
-	 * console.log(JSON.stringify(json, null, 2));
-	 * ```
-	 */ toJSON() {
-        return {
-            maxHistorySize: this.maxHistorySize,
-            maxBranches: this.maxBranches,
-            maxBranchSize: this.maxBranchSize,
-            skillDirs: this.skillDirs,
-            toolDirs: this.toolDirs,
-            discoveryCache: this.discoveryCache,
-            persistence: this.persistence,
-            persistenceBufferSize: this.persistenceBufferSize,
-            persistenceFlushInterval: this.persistenceFlushInterval,
-            persistenceMaxRetries: this.persistenceMaxRetries,
-            features: this.features,
-            toolInterleaveTtlMs: this.toolInterleaveTtlMs,
-            toolInterleaveSweepMs: this.toolInterleaveSweepMs,
-            maxSessionsPerOwner: this.maxSessionsPerOwner
-        };
-    }
-}
-
-;// CONCATENATED MODULE: external "yaml"
-
-// EXTERNAL MODULE: external "valibot"
-var external_valibot_ = __webpack_require__("w");
-;// CONCATENATED MODULE: ./src/config/ConfigLoader.ts
-/**
- * Configuration file loading with environment variable override support.
- *
- * This module provides the `ConfigLoader` class which handles loading configuration
- * from YAML and JSON files in standard locations, with automatic environment variable
- * overrides for all settings.
- *
- * @module config
- */ 
-
-
-
-
-
-/**
- * Lenient runtime schema for config files. Only validates top-level shape;
- * unknown extra fields are preserved by Valibot's default object behavior
- * being strict is avoided by using `v.looseObject`. All fields are optional.
- */ const ConfigFileOptionsSchema = external_valibot_.looseObject({
-    maxHistorySize: external_valibot_.optional(external_valibot_.number()),
-    maxBranches: external_valibot_.optional(external_valibot_.number()),
-    maxBranchSize: external_valibot_.optional(external_valibot_.number()),
-    logLevel: external_valibot_.optional(external_valibot_.picklist([
-        'debug',
-        'info',
-        'warn',
-        'error'
-    ])),
-    prettyLog: external_valibot_.optional(external_valibot_.boolean()),
-    skillDirs: external_valibot_.optional(external_valibot_.array(external_valibot_.string())),
-    toolDirs: external_valibot_.optional(external_valibot_.array(external_valibot_.string())),
-    discoveryCache: external_valibot_.optional(external_valibot_.looseObject({
-        ttl: external_valibot_.optional(external_valibot_.number()),
-        maxSize: external_valibot_.optional(external_valibot_.number())
-    })),
-    persistence: external_valibot_.optional(external_valibot_.looseObject({})),
-    features: external_valibot_.optional(external_valibot_.looseObject({})),
-    toolInterleaveTtlMs: external_valibot_.optional(external_valibot_.number()),
-    toolInterleaveSweepMs: external_valibot_.optional(external_valibot_.number()),
-    maxSessionsPerOwner: external_valibot_.optional(external_valibot_.number())
-});
-/**
- * Loads configuration from files with environment variable overrides.
- *
- * This class searches for configuration files in standard locations and applies
- * environment variable overrides. Files are searched in priority order, with the
- * first match being used. Environment variables always take precedence over file values.
- *
- * @remarks
- * **Config File Search Order (priority):**
- * 1. Custom path (if provided to constructor)
- * 2. `.claude/config.json` (project-local)
- * 3. `.claude/config.yaml` (project-local)
- * 4. `.claude/config.yml` (project-local)
- * 5. `~/.claude/config.json` (user-global)
- * 6. `~/.claude/config.yaml` (user-global)
- * 7. `~/.claude/config.yml` (user-global)
- *
- * **Environment Variable Overrides:**
- * | Variable | Type | Description |
- * |----------|------|-------------|
- * | `MAX_HISTORY_SIZE` | number | Max thoughts in history |
- * | `MAX_BRANCHES` | number | Max number of branches |
- * | `MAX_BRANCH_SIZE` | number | Max size of each branch |
- * | `LOG_LEVEL` | string | Logging level (debug/info/warn/error) |
- * | `PRETTY_LOG` | string | "false" to disable pretty logging |
- * | `SKILL_DIRS` | string | Colon-separated directory paths |
- * | `TOOL_DIRS` | string | Colon-separated directory paths |
- * | `DISCOVERY_CACHE_TTL` | number | TTL in seconds (converted to ms) |
- * | `DISCOVERY_CACHE_MAX_SIZE` | number | Max cache entries |
- *
- * @example
- * ```typescript
- * // Use default search paths
- * const loader1 = new ConfigLoader();
- * const config1 = loader1.load();
- *
- * // Use custom config path
- * const loader2 = new ConfigLoader('./my-config.yaml');
- * const config2 = loader2.load();
- *
- * // Convert to ServerConfig options
- * const serverOptions = loader2.toServerConfigOptions(config2);
- * ```
- */ class ConfigLoader {
-    /** Array of config file paths to search, in priority order. */ _configPaths;
-    /**
-	 * Creates a new ConfigLoader instance.
-	 *
-	 * @param customPath - Optional custom config file path. If provided, only this path will be checked.
-	 *
-	 * @example
-	 * ```typescript
-	 * // Use default search paths
-	 * const loader1 = new ConfigLoader();
-	 *
-	 * // Use a specific config file
-	 * const loader2 = new ConfigLoader('./custom-config.json');
-	 * ```
-	 */ constructor(customPath){
-        this._configPaths = customPath ? [
-            customPath
-        ] : [
-            '.claude/config.json',
-            '.claude/config.yaml',
-            '.claude/config.yml',
-            join(homedir(), '.claude/config.json'),
-            join(homedir(), '.claude/config.yaml'),
-            join(homedir(), '.claude/config.yml')
-        ];
-    }
-    /**
-	 * Loads configuration from files and applies environment overrides.
-	 *
-	 * Searches for config files in the configured paths (in priority order),
-	 * parses the first match, and applies environment variable overrides.
-	 * Returns null if no config file is found and no environment overrides are set.
-	 *
-	 * @returns The loaded configuration with environment overrides applied, or null if no config found
-	 *
-	 * @example
-	 * ```typescript
-	 * const loader = new ConfigLoader();
-	 * const config = loader.load();
-	 *
-	 * if (config) {
-	 *   console.log('Max history size:', config.maxHistorySize);
-	 *   console.log('Log level:', config.logLevel);
-	 * }
-	 * ```
-	 */ load() {
-        let config = null;
-        for (const configPath of this._configPaths){
-            if (existsSync(configPath)) {
-                try {
-                    config = this.parseConfig(configPath);
-                    break;
-                } catch (error) {
-                    console.error(`Failed to load config from ${configPath}:`, (0,errors/* .getErrorMessage */.u1)(error));
-                }
-            }
-        }
-        return this.applyEnvironmentOverrides(config || {});
-    }
-    /**
-	 * Applies environment variable overrides to the configuration.
-	 *
-	 * Environment variables take precedence over file-based configuration.
-	 * Supported environment variables:
-	 * - `MAX_HISTORY_SIZE`, `MAX_BRANCHES`, `MAX_BRANCH_SIZE` (numbers)
-	 * - `LOG_LEVEL` (debug/info/warn/error)
-	 * - `PRETTY_LOG` ("false" to disable)
-	 * - `SKILL_DIRS` (colon-separated paths)
-	 * - `TOOL_DIRS` (colon-separated paths)
-	 * - `DISCOVERY_CACHE_TTL` (in seconds, converted to ms)
-	 * - `DISCOVERY_CACHE_MAX_SIZE` (number)
-	 *
-	 * @param config - The configuration to apply overrides to
-	 * @returns A new configuration object with environment overrides applied
-	 */ applyEnvironmentOverrides(config) {
-        const result = {
-            ...config,
-            ...config.skillDirs === undefined ? {} : {
-                skillDirs: [
-                    ...config.skillDirs
-                ]
-            },
-            ...config.toolDirs === undefined ? {} : {
-                toolDirs: [
-                    ...config.toolDirs
-                ]
-            },
-            ...config.discoveryCache === undefined ? {} : {
-                discoveryCache: {
-                    ...config.discoveryCache
-                }
-            },
-            ...config.persistence === undefined ? {} : {
-                persistence: {
-                    ...config.persistence,
-                    ...config.persistence.options === undefined ? {} : {
-                        options: {
-                            ...config.persistence.options
-                        }
-                    }
-                }
-            },
-            ...config.features === undefined ? {} : {
-                features: {
-                    ...config.features
-                }
-            }
-        };
-        if (process.env.MAX_HISTORY_SIZE !== undefined) {
-            result.maxHistorySize = this.parseEnvironmentInteger('MAX_HISTORY_SIZE', process.env.MAX_HISTORY_SIZE);
-        }
-        if (process.env.MAX_BRANCHES !== undefined) {
-            result.maxBranches = this.parseEnvironmentInteger('MAX_BRANCHES', process.env.MAX_BRANCHES);
-        }
-        if (process.env.MAX_BRANCH_SIZE !== undefined) {
-            result.maxBranchSize = this.parseEnvironmentInteger('MAX_BRANCH_SIZE', process.env.MAX_BRANCH_SIZE);
-        }
-        if (process.env.LOG_LEVEL && [
-            'debug',
-            'info',
-            'warn',
-            'error'
-        ].includes(process.env.LOG_LEVEL)) {
-            result.logLevel = process.env.LOG_LEVEL;
-        }
-        if (process.env.PRETTY_LOG === 'false') {
-            result.prettyLog = false;
-        }
-        if (process.env.SKILL_DIRS !== undefined) {
-            result.skillDirs = process.env.SKILL_DIRS === '' ? [] : process.env.SKILL_DIRS.split(':');
-        }
-        if (process.env.TOOL_DIRS !== undefined) {
-            result.toolDirs = process.env.TOOL_DIRS === '' ? [] : process.env.TOOL_DIRS.split(':');
-        }
-        if (process.env.DISCOVERY_CACHE_TTL !== undefined) {
-            const seconds = this.parseEnvironmentInteger('DISCOVERY_CACHE_TTL', process.env.DISCOVERY_CACHE_TTL);
-            const ttl = seconds * 1000;
-            if (!Number.isSafeInteger(ttl)) {
-                throw new errors/* .ConfigurationError */.j1('DISCOVERY_CACHE_TTL exceeds the safe integer range');
-            }
-            result.discoveryCache = {
-                ...result.discoveryCache,
-                ttl
-            };
-        }
-        if (process.env.DISCOVERY_CACHE_MAX_SIZE !== undefined) {
-            const maxSize = this.parseEnvironmentInteger('DISCOVERY_CACHE_MAX_SIZE', process.env.DISCOVERY_CACHE_MAX_SIZE);
-            result.discoveryCache = {
-                ...result.discoveryCache,
-                maxSize
-            };
-        }
-        if (process.env.TRACELATTICE_TOOL_INTERLEAVE_TTL_MS !== undefined) {
-            result.toolInterleaveTtlMs = this.parseEnvironmentInteger('TRACELATTICE_TOOL_INTERLEAVE_TTL_MS', process.env.TRACELATTICE_TOOL_INTERLEAVE_TTL_MS);
-        }
-        if (process.env.TRACELATTICE_TOOL_INTERLEAVE_SWEEP_MS !== undefined) {
-            result.toolInterleaveSweepMs = this.parseEnvironmentInteger('TRACELATTICE_TOOL_INTERLEAVE_SWEEP_MS', process.env.TRACELATTICE_TOOL_INTERLEAVE_SWEEP_MS);
-        }
-        if (process.env.SESSION_MAX_PER_OWNER !== undefined) {
-            result.maxSessionsPerOwner = this.parseEnvironmentInteger('SESSION_MAX_PER_OWNER', process.env.SESSION_MAX_PER_OWNER);
-        }
-        this.applyFeatureFlagOverrides(result);
-        return result;
-    }
-    /**
-	 * Applies TRACELATTICE_FEATURES_* environment variable overrides for feature flags.
-	 * Booleans accept 'true'/'false'/'1'/'0' (case-insensitive).
-	 * Invalid reasoningStrategy values are rejected.
-	 *
-	 * @param result - Configuration object to mutate with feature flag overrides
-	 * @private
-	 */ applyFeatureFlagOverrides(result) {
-        const boolMap = {
-            TRACELATTICE_FEATURES_DAG_EDGES: 'dagEdges',
-            TRACELATTICE_FEATURES_CALIBRATION: 'calibration',
-            TRACELATTICE_FEATURES_COMPRESSION: 'compression',
-            TRACELATTICE_FEATURES_TOOL_INTERLEAVE: 'toolInterleave',
-            TRACELATTICE_FEATURES_NEW_THOUGHT_TYPES: 'newThoughtTypes',
-            TRACELATTICE_FEATURES_OUTCOME_RECORDING: 'outcomeRecording'
-        };
-        for (const [envVar, key] of Object.entries(boolMap)){
-            const raw = process.env[envVar];
-            if (raw === undefined) continue;
-            const parsed = this.parseBoolean(raw);
-            if (parsed === undefined) {
-                console.warn(`Invalid boolean value for ${envVar}: "${raw}" (expected true/false/1/0). Ignoring.`);
-                continue;
-            }
-            const features = result.features ?? {};
-            features[key] = parsed;
-            result.features = features;
-        }
-        const strategyRaw = process.env.TRACELATTICE_FEATURES_REASONING_STRATEGY;
-        if (strategyRaw !== undefined) {
-            if (strategyRaw !== 'sequential' && strategyRaw !== 'tot') {
-                throw new errors/* .ConfigurationError */.j1(`TRACELATTICE_FEATURES_REASONING_STRATEGY must be one of sequential, tot, got ${strategyRaw}`);
-            }
-            const features = result.features ?? {};
-            features.reasoningStrategy = strategyRaw;
-            result.features = features;
-        }
-    }
-    parseEnvironmentInteger(environmentName, raw) {
-        if (!/^(0|[1-9]\d*)$/.test(raw)) {
-            throw new errors/* .ConfigurationError */.j1(`${environmentName} must be an integer, got ${raw}`);
-        }
-        const parsed = Number(raw);
-        if (!Number.isSafeInteger(parsed)) {
-            throw new errors/* .ConfigurationError */.j1(`${environmentName} must be a safe integer, got ${raw}`);
-        }
-        return parsed;
-    }
-    /**
-	 * Parses a boolean from an environment variable string.
-	 * Accepts 'true'/'false'/'1'/'0' case-insensitively.
-	 *
-	 * @param raw - Raw environment variable string
-	 * @returns Parsed boolean, or undefined if the value is invalid
-	 * @private
-	 */ parseBoolean(raw) {
-        const v = raw.trim().toLowerCase();
-        if (v === 'true' || v === '1') return true;
-        if (v === 'false' || v === '0') return false;
-        return undefined;
-    }
-    /**
-	 * Parses a configuration file (JSON or YAML).
-	 *
-	 * Detects the file type by extension and uses the appropriate parser.
-	 * Supports `.json`, `.yaml`, and `.yml` file extensions.
-	 *
-	 * @param filePath - Path to the configuration file to parse
-	 * @returns The parsed configuration object
-	 * @throws {Error} If the file cannot be parsed
-	 * @private
-	 */ parseConfig(filePath) {
-        const content = readFileSync(filePath, 'utf-8');
-        const ext = filePath.split('.').pop()?.toLowerCase();
-        const raw = ext === 'yaml' || ext === 'yml' ? parse(content) : JSON.parse(content);
-        return external_valibot_.parse(ConfigFileOptionsSchema, raw);
-    }
-    /**
-	 * Converts file-based configuration to ServerConfig options.
-	 *
-	 * This is a convenience method for extracting the ServerConfig-relevant
-	 * options from a file-based configuration.
-	 *
-	 * @param config - The configuration to convert
-	 * @returns An object with ServerConfig-compatible options
-	 *
-	 * @example
-	 * ```typescript
-	 * const loader = new ConfigLoader();
-	 * const config = loader.load();
-	 * if (config) {
-	 *   const serverOpts = loader.toServerConfigOptions(config);
-	 *   const serverConfig = new ServerConfig(serverOpts);
-	 * }
-	 * ```
-	 */ toServerConfigOptions(config) {
-        return {
-            maxHistorySize: config.maxHistorySize,
-            maxBranches: config.maxBranches,
-            maxBranchSize: config.maxBranchSize,
-            skillDirs: config.skillDirs,
-            toolDirs: config.toolDirs,
-            discoveryCache: config.discoveryCache,
-            persistence: config.persistence,
-            features: config.features,
-            toolInterleaveTtlMs: config.toolInterleaveTtlMs,
-            toolInterleaveSweepMs: config.toolInterleaveSweepMs,
-            maxSessionsPerOwner: config.maxSessionsPerOwner
-        };
-    }
-}
+;// CONCATENATED MODULE: external "./lib.js"
 
-// EXTERNAL MODULE: ./src/contracts/ids.ts
-var ids = __webpack_require__("j");
-// EXTERNAL MODULE: ./src/context/RequestContext.ts
-var RequestContext = __webpack_require__("y");
+// EXTERNAL MODULE: ./src/context/RequestContext.ts + 1 modules
+var RequestContext = __webpack_require__("i");
 ;// CONCATENATED MODULE: ./src/logger/StructuredLogger.ts
 /**
  * Lightweight structured logging without external dependencies.
@@ -4959,8 +3038,6 @@ var RequestContext = __webpack_require__("y");
 
 // EXTERNAL MODULE: ./src/schema.ts
 var schema = __webpack_require__("R");
-// EXTERNAL MODULE: ./src/transport/SseTransport.ts
-var transport_SseTransport = __webpack_require__("W");
 ;// CONCATENATED MODULE: ./src/cli.ts
 //#!/usr/bin/env bun
 // CLI entry point for tracelattice MCP server.
@@ -4977,16 +3054,11 @@ var transport_SseTransport = __webpack_require__("W");
 
 
 
-
-
-
-
-
 // Get version from package.json
 const CLI_NAME = 'tracelattice';
-const cli_filename = (0,external_node_url_.fileURLToPath)(import.meta.url);
-const cli_dirname = dirname(cli_filename);
-const package_json = JSON.parse(readFileSync(join(cli_dirname, '../package.json'), 'utf-8'));
+const cli_filename = (0,__rspack_external_node_url_3991086a.fileURLToPath)(import.meta.url);
+const cli_dirname = (0,__rspack_external_node_path_806ed179.dirname)(cli_filename);
+const package_json = JSON.parse((0,__rspack_external_node_fs_1b05aee1.readFileSync)((0,__rspack_external_node_path_806ed179.join)(cli_dirname, '../package.json'), 'utf-8'));
 const { version } = package_json;
 // Handle CLI arguments
 const args = process.argv.slice(2);
@@ -4997,14 +3069,8 @@ if (shouldShowVersion) {
 }
 async function main() {
     const transportType = process.env.TRANSPORT_TYPE || 'stdio';
-    if (transportType === 'sse' && process.env.SSE_ENABLE_POOL !== 'false') {
-        const configLoader = new ConfigLoader();
-        const fileConfig = configLoader.load();
-        const effectiveConfig = new ServerConfig(configLoader.toServerConfigOptions(fileConfig ?? {}));
-        (0,transport_SseTransport/* .assertPooledSsePersistence */.c)(true, effectiveConfig.persistence);
-    }
-    const adapter = new ValibotJsonSchemaAdapter();
-    const server = new McpServer({
+    const adapter = new __rspack_external__tmcp_adapter_valibot_0faddfa6.ValibotJsonSchemaAdapter();
+    const server = new __rspack_external_tmcp.McpServer({
         name: CLI_NAME,
         version,
         description: 'Semantic Sequential Thinking MCP Server'
@@ -5016,88 +3082,30 @@ async function main() {
             }
         }
     });
-    const thinkingServer = await (0,external_lib_js_.initializeServer)();
+    const thinkingServer = await (0,__rspack_external__lib_js_1645bc55.initializeServer)();
     const lifecycle = new CliLifecycle(thinkingServer);
     try {
-        if (transportType === 'sse') {
-            await startSseTransport(server, thinkingServer, lifecycle);
+        server.tool({
+            name: 'sequentialthinking_tools',
+            description: schema/* .SEQUENTIAL_THINKING_TOOL.description */.iV.description,
+            schema: schema/* .SequentialThinkingSchema */.ZK
+        }, async (input)=>thinkingServer.processThought(input));
+        if (transportType === 'streamable-http') {
+            await startStreamableHttpTransport(server, thinkingServer, lifecycle);
         } else {
-            server.tool({
-                name: 'sequentialthinking_tools',
-                description: schema/* .SEQUENTIAL_THINKING_TOOL.description */.iV.description,
-                schema: schema/* .SequentialThinkingSchema */.ZK
-            }, async (input)=>thinkingServer.processThought(input));
-            if (transportType === 'streamable-http') {
-                await startStreamableHttpTransport(server, thinkingServer, lifecycle);
-            } else {
-                await startStdioTransport(server, thinkingServer, lifecycle);
-            }
+            await startStdioTransport(server, thinkingServer, lifecycle);
         }
         registerShutdownHandlers(lifecycle, thinkingServer, transportType === 'stdio');
     } catch (error) {
         await lifecycle.rollbackStartup(error);
     }
 }
-/**
- * Start SSE transport for multi-user support
- */ async function startSseTransport(server, thinkingServer, lifecycle) {
-    const { SseTransport } = await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, "W"));
-    const { createConnectionPool } = await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, "v"));
-    const port = parseInt(process.env.SSE_PORT || '3000', 10);
-    const host = process.env.SSE_HOST || 'localhost';
-    const transportMetrics = thinkingServer.getContainer().resolve('Metrics');
-    const enablePool = process.env.SSE_ENABLE_POOL !== 'false';
-    const maxSessions = parseInt(process.env.SSE_MAX_SESSIONS || '100', 10);
-    const sessionTimeout = parseInt(process.env.SSE_SESSION_TIMEOUT || '300000', 10);
-    const connectionPool = enablePool ? createConnectionPool({
-        maxSessions,
-        sessionTimeout,
-        logger: thinkingServer['_logger'],
-        serverFactory: async ()=>{
-            const { createServer: createThinkingServer } = await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, "r"));
-            const sessionServer = await createThinkingServer({
-                autoDiscover: true
-            });
-            return sessionServer;
-        }
-    }) : undefined;
-    const sseTransport = new SseTransport({
-        port,
-        host,
-        corsOrigin: process.env.CORS_ORIGIN || '*',
-        enableCors: process.env.ENABLE_CORS !== 'false',
-        allowedHosts: process.env.ALLOWED_HOSTS?.split(',').map((hostValue)=>hostValue.trim()),
-        metrics: transportMetrics,
-        connectionPool,
-        persistence: thinkingServer.config.persistence
-    });
-    lifecycle.attachTransport(sseTransport);
-    server.tool({
-        name: 'sequentialthinking_tools',
-        description: schema/* .SEQUENTIAL_THINKING_TOOL.description */.iV.description,
-        schema: schema/* .SequentialThinkingSchema */.ZK
-    }, async (input)=>{
-        if (!connectionPool) {
-            return thinkingServer.processThought(input);
-        }
-        const result = await connectionPool.process((0,ids/* .asSessionId */.Kd)((0,RequestContext/* .getOwner */.QQ)() ?? ''), input);
-        return {
-            content: result.content,
-            ...result.isError === undefined ? {} : {
-                isError: result.isError
-            }
-        };
-    });
-    // Connect the SSE transport
-    await sseTransport.connect(server);
-    thinkingServer['_logger'].info(`Sequential Thinking MCP Server running on SSE transport at http://${host}:${port}`);
-}
 /**
  * Start Streamable HTTP transport (MCP spec recommended)
  */ async function startStreamableHttpTransport(server, thinkingServer, lifecycle) {
-    const { StreamableHttpTransport } = await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, "J"));
-    const port = parseInt(process.env.STREAMABLE_HTTP_PORT || process.env.SSE_PORT || '3000', 10);
-    const host = process.env.STREAMABLE_HTTP_HOST || process.env.SSE_HOST || 'localhost';
+    const { StreamableHttpTransport } = await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, "E"));
+    const port = parseInt(process.env.STREAMABLE_HTTP_PORT || '9007', 10);
+    const host = process.env.STREAMABLE_HTTP_HOST || 'localhost';
     const transportMetrics = thinkingServer.getContainer().resolve('Metrics');
     const stateful = process.env.STREAMABLE_HTTP_STATEFUL !== 'false';
     const streamableTransport = new StreamableHttpTransport({
@@ -5117,7 +3125,7 @@ async function main() {
 /**
  * Start stdio transport (default, single-user)
  */ async function startStdioTransport(server, thinkingServer, lifecycle) {
-    const transport = new StdioTransport(server);
+    const transport = new __rspack_external__tmcp_transport_stdio_98e5584f.StdioTransport(server);
     const processListeners = {
         sigint: new Set(process.listeners('SIGINT')),
         sigterm: new Set(process.listeners('SIGTERM')),