threadnote 0.7.12 → 1.1.0

package/dist/mcp_server.cjs

@@ -3645,49 +3645,49 @@ var require_fast_uri = __commonJS({
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative2, options, skipNormalization) {
+    function resolveComponent(base, relative3, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse3(serialize(base, options), options);
-        relative2 = parse3(serialize(relative2, options), options);
+        relative3 = parse3(serialize(relative3, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative2.scheme) {
-        target.scheme = relative2.scheme;
-        target.userinfo = relative2.userinfo;
-        target.host = relative2.host;
-        target.port = relative2.port;
-        target.path = removeDotSegments(relative2.path || "");
-        target.query = relative2.query;
+      if (!options.tolerant && relative3.scheme) {
+        target.scheme = relative3.scheme;
+        target.userinfo = relative3.userinfo;
+        target.host = relative3.host;
+        target.port = relative3.port;
+        target.path = removeDotSegments(relative3.path || "");
+        target.query = relative3.query;
       } else {
-        if (relative2.userinfo !== void 0 || relative2.host !== void 0 || relative2.port !== void 0) {
-          target.userinfo = relative2.userinfo;
-          target.host = relative2.host;
-          target.port = relative2.port;
-          target.path = removeDotSegments(relative2.path || "");
-          target.query = relative2.query;
+        if (relative3.userinfo !== void 0 || relative3.host !== void 0 || relative3.port !== void 0) {
+          target.userinfo = relative3.userinfo;
+          target.host = relative3.host;
+          target.port = relative3.port;
+          target.path = removeDotSegments(relative3.path || "");
+          target.query = relative3.query;
         } else {
-          if (!relative2.path) {
+          if (!relative3.path) {
             target.path = base.path;
-            if (relative2.query !== void 0) {
-              target.query = relative2.query;
+            if (relative3.query !== void 0) {
+              target.query = relative3.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative2.path[0] === "/") {
-              target.path = removeDotSegments(relative2.path);
+            if (relative3.path[0] === "/") {
+              target.path = removeDotSegments(relative3.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative2.path;
+                target.path = "/" + relative3.path;
               } else if (!base.path) {
-                target.path = relative2.path;
+                target.path = relative3.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative2.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative3.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative2.query;
+            target.query = relative3.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -3695,7 +3695,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative2.fragment;
+      target.fragment = relative3.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -25867,6 +25867,7 @@ var InitializedNotificationSchema = NotificationSchema.extend({
   method: literal("notifications/initialized"),
   params: NotificationsParamsSchema.optional()
 });
+var isInitializedNotification = (value) => InitializedNotificationSchema.safeParse(value).success;
 var PingRequestSchema = RequestSchema.extend({
   method: literal("ping"),
   params: BaseRequestParamsSchema.optional()
@@ -29350,6 +29351,715 @@ var AjvJsonSchemaValidator = class {
   }
 };
 
+// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/client.js
+var ExperimentalClientTasks = class {
+  constructor(_client) {
+    this._client = _client;
+  }
+  /**
+   * Calls a tool and returns an AsyncGenerator that yields response messages.
+   * The generator is guaranteed to end with either a 'result' or 'error' message.
+   *
+   * This method provides streaming access to tool execution, allowing you to
+   * observe intermediate task status updates for long-running tool calls.
+   * Automatically validates structured output if the tool has an outputSchema.
+   *
+   * @example
+   * ```typescript
+   * const stream = client.experimental.tasks.callToolStream({ name: 'myTool', arguments: {} });
+   * for await (const message of stream) {
+   *   switch (message.type) {
+   *     case 'taskCreated':
+   *       console.log('Tool execution started:', message.task.taskId);
+   *       break;
+   *     case 'taskStatus':
+   *       console.log('Tool status:', message.task.status);
+   *       break;
+   *     case 'result':
+   *       console.log('Tool result:', message.result);
+   *       break;
+   *     case 'error':
+   *       console.error('Tool error:', message.error);
+   *       break;
+   *   }
+   * }
+   * ```
+   *
+   * @param params - Tool call parameters (name and arguments)
+   * @param resultSchema - Zod schema for validating the result (defaults to CallToolResultSchema)
+   * @param options - Optional request options (timeout, signal, task creation params, etc.)
+   * @returns AsyncGenerator that yields ResponseMessage objects
+   *
+   * @experimental
+   */
+  async *callToolStream(params, resultSchema = CallToolResultSchema, options) {
+    const clientInternal = this._client;
+    const optionsWithTask = {
+      ...options,
+      // We check if the tool is known to be a task during auto-configuration, but assume
+      // the caller knows what they're doing if they pass this explicitly
+      task: options?.task ?? (clientInternal.isToolTask(params.name) ? {} : void 0)
+    };
+    const stream = clientInternal.requestStream({ method: "tools/call", params }, resultSchema, optionsWithTask);
+    const validator = clientInternal.getToolOutputValidator(params.name);
+    for await (const message of stream) {
+      if (message.type === "result" && validator) {
+        const result = message.result;
+        if (!result.structuredContent && !result.isError) {
+          yield {
+            type: "error",
+            error: new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`)
+          };
+          return;
+        }
+        if (result.structuredContent) {
+          try {
+            const validationResult = validator(result.structuredContent);
+            if (!validationResult.valid) {
+              yield {
+                type: "error",
+                error: new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`)
+              };
+              return;
+            }
+          } catch (error51) {
+            if (error51 instanceof McpError) {
+              yield { type: "error", error: error51 };
+              return;
+            }
+            yield {
+              type: "error",
+              error: new McpError(ErrorCode.InvalidParams, `Failed to validate structured content: ${error51 instanceof Error ? error51.message : String(error51)}`)
+            };
+            return;
+          }
+        }
+      }
+      yield message;
+    }
+  }
+  /**
+   * Gets the current status of a task.
+   *
+   * @param taskId - The task identifier
+   * @param options - Optional request options
+   * @returns The task status
+   *
+   * @experimental
+   */
+  async getTask(taskId, options) {
+    return this._client.getTask({ taskId }, options);
+  }
+  /**
+   * Retrieves the result of a completed task.
+   *
+   * @param taskId - The task identifier
+   * @param resultSchema - Zod schema for validating the result
+   * @param options - Optional request options
+   * @returns The task result
+   *
+   * @experimental
+   */
+  async getTaskResult(taskId, resultSchema, options) {
+    return this._client.getTaskResult({ taskId }, resultSchema, options);
+  }
+  /**
+   * Lists tasks with optional pagination.
+   *
+   * @param cursor - Optional pagination cursor
+   * @param options - Optional request options
+   * @returns List of tasks with optional next cursor
+   *
+   * @experimental
+   */
+  async listTasks(cursor, options) {
+    return this._client.listTasks(cursor ? { cursor } : void 0, options);
+  }
+  /**
+   * Cancels a running task.
+   *
+   * @param taskId - The task identifier
+   * @param options - Optional request options
+   *
+   * @experimental
+   */
+  async cancelTask(taskId, options) {
+    return this._client.cancelTask({ taskId }, options);
+  }
+  /**
+   * Sends a request and returns an AsyncGenerator that yields response messages.
+   * The generator is guaranteed to end with either a 'result' or 'error' message.
+   *
+   * This method provides streaming access to request processing, allowing you to
+   * observe intermediate task status updates for task-augmented requests.
+   *
+   * @param request - The request to send
+   * @param resultSchema - Zod schema for validating the result
+   * @param options - Optional request options (timeout, signal, task creation params, etc.)
+   * @returns AsyncGenerator that yields ResponseMessage objects
+   *
+   * @experimental
+   */
+  requestStream(request, resultSchema, options) {
+    return this._client.requestStream(request, resultSchema, options);
+  }
+};
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
+function assertToolsCallTaskCapability(requests, method, entityName) {
+  if (!requests) {
+    throw new Error(`${entityName} does not support task creation (required for ${method})`);
+  }
+  switch (method) {
+    case "tools/call":
+      if (!requests.tools?.call) {
+        throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
+      }
+      break;
+    default:
+      break;
+  }
+}
+function assertClientRequestTaskCapability(requests, method, entityName) {
+  if (!requests) {
+    throw new Error(`${entityName} does not support task creation (required for ${method})`);
+  }
+  switch (method) {
+    case "sampling/createMessage":
+      if (!requests.sampling?.createMessage) {
+        throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
+      }
+      break;
+    case "elicitation/create":
+      if (!requests.elicitation?.create) {
+        throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/index.js
+function applyElicitationDefaults(schema2, data) {
+  if (!schema2 || data === null || typeof data !== "object")
+    return;
+  if (schema2.type === "object" && schema2.properties && typeof schema2.properties === "object") {
+    const obj = data;
+    const props = schema2.properties;
+    for (const key of Object.keys(props)) {
+      const propSchema = props[key];
+      if (obj[key] === void 0 && Object.prototype.hasOwnProperty.call(propSchema, "default")) {
+        obj[key] = propSchema.default;
+      }
+      if (obj[key] !== void 0) {
+        applyElicitationDefaults(propSchema, obj[key]);
+      }
+    }
+  }
+  if (Array.isArray(schema2.anyOf)) {
+    for (const sub of schema2.anyOf) {
+      if (typeof sub !== "boolean") {
+        applyElicitationDefaults(sub, data);
+      }
+    }
+  }
+  if (Array.isArray(schema2.oneOf)) {
+    for (const sub of schema2.oneOf) {
+      if (typeof sub !== "boolean") {
+        applyElicitationDefaults(sub, data);
+      }
+    }
+  }
+}
+function getSupportedElicitationModes(capabilities) {
+  if (!capabilities) {
+    return { supportsFormMode: false, supportsUrlMode: false };
+  }
+  const hasFormCapability = capabilities.form !== void 0;
+  const hasUrlCapability = capabilities.url !== void 0;
+  const supportsFormMode = hasFormCapability || !hasFormCapability && !hasUrlCapability;
+  const supportsUrlMode = hasUrlCapability;
+  return { supportsFormMode, supportsUrlMode };
+}
+var Client = class extends Protocol {
+  /**
+   * Initializes this client with the given name and version information.
+   */
+  constructor(_clientInfo, options) {
+    super(options);
+    this._clientInfo = _clientInfo;
+    this._cachedToolOutputValidators = /* @__PURE__ */ new Map();
+    this._cachedKnownTaskTools = /* @__PURE__ */ new Set();
+    this._cachedRequiredTaskTools = /* @__PURE__ */ new Set();
+    this._listChangedDebounceTimers = /* @__PURE__ */ new Map();
+    this._capabilities = options?.capabilities ?? {};
+    this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
+    if (options?.listChanged) {
+      this._pendingListChangedConfig = options.listChanged;
+    }
+  }
+  /**
+   * Set up handlers for list changed notifications based on config and server capabilities.
+   * This should only be called after initialization when server capabilities are known.
+   * Handlers are silently skipped if the server doesn't advertise the corresponding listChanged capability.
+   * @internal
+   */
+  _setupListChangedHandlers(config2) {
+    if (config2.tools && this._serverCapabilities?.tools?.listChanged) {
+      this._setupListChangedHandler("tools", ToolListChangedNotificationSchema, config2.tools, async () => {
+        const result = await this.listTools();
+        return result.tools;
+      });
+    }
+    if (config2.prompts && this._serverCapabilities?.prompts?.listChanged) {
+      this._setupListChangedHandler("prompts", PromptListChangedNotificationSchema, config2.prompts, async () => {
+        const result = await this.listPrompts();
+        return result.prompts;
+      });
+    }
+    if (config2.resources && this._serverCapabilities?.resources?.listChanged) {
+      this._setupListChangedHandler("resources", ResourceListChangedNotificationSchema, config2.resources, async () => {
+        const result = await this.listResources();
+        return result.resources;
+      });
+    }
+  }
+  /**
+   * Access experimental features.
+   *
+   * WARNING: These APIs are experimental and may change without notice.
+   *
+   * @experimental
+   */
+  get experimental() {
+    if (!this._experimental) {
+      this._experimental = {
+        tasks: new ExperimentalClientTasks(this)
+      };
+    }
+    return this._experimental;
+  }
+  /**
+   * Registers new capabilities. This can only be called before connecting to a transport.
+   *
+   * The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
+   */
+  registerCapabilities(capabilities) {
+    if (this.transport) {
+      throw new Error("Cannot register capabilities after connecting to transport");
+    }
+    this._capabilities = mergeCapabilities(this._capabilities, capabilities);
+  }
+  /**
+   * Override request handler registration to enforce client-side validation for elicitation.
+   */
+  setRequestHandler(requestSchema, handler) {
+    const shape = getObjectShape(requestSchema);
+    const methodSchema = shape?.method;
+    if (!methodSchema) {
+      throw new Error("Schema is missing a method literal");
+    }
+    let methodValue;
+    if (isZ4Schema(methodSchema)) {
+      const v4Schema = methodSchema;
+      const v4Def = v4Schema._zod?.def;
+      methodValue = v4Def?.value ?? v4Schema.value;
+    } else {
+      const v3Schema = methodSchema;
+      const legacyDef = v3Schema._def;
+      methodValue = legacyDef?.value ?? v3Schema.value;
+    }
+    if (typeof methodValue !== "string") {
+      throw new Error("Schema method literal must be a string");
+    }
+    const method = methodValue;
+    if (method === "elicitation/create") {
+      const wrappedHandler = async (request, extra) => {
+        const validatedRequest = safeParse2(ElicitRequestSchema, request);
+        if (!validatedRequest.success) {
+          const errorMessage2 = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation request: ${errorMessage2}`);
+        }
+        const { params } = validatedRequest.data;
+        params.mode = params.mode ?? "form";
+        const { supportsFormMode, supportsUrlMode } = getSupportedElicitationModes(this._capabilities.elicitation);
+        if (params.mode === "form" && !supportsFormMode) {
+          throw new McpError(ErrorCode.InvalidParams, "Client does not support form-mode elicitation requests");
+        }
+        if (params.mode === "url" && !supportsUrlMode) {
+          throw new McpError(ErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests");
+        }
+        const result = await Promise.resolve(handler(request, extra));
+        if (params.task) {
+          const taskValidationResult = safeParse2(CreateTaskResultSchema, result);
+          if (!taskValidationResult.success) {
+            const errorMessage2 = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage2}`);
+          }
+          return taskValidationResult.data;
+        }
+        const validationResult = safeParse2(ElicitResultSchema, result);
+        if (!validationResult.success) {
+          const errorMessage2 = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation result: ${errorMessage2}`);
+        }
+        const validatedResult = validationResult.data;
+        const requestedSchema = params.mode === "form" ? params.requestedSchema : void 0;
+        if (params.mode === "form" && validatedResult.action === "accept" && validatedResult.content && requestedSchema) {
+          if (this._capabilities.elicitation?.form?.applyDefaults) {
+            try {
+              applyElicitationDefaults(requestedSchema, validatedResult.content);
+            } catch {
+            }
+          }
+        }
+        return validatedResult;
+      };
+      return super.setRequestHandler(requestSchema, wrappedHandler);
+    }
+    if (method === "sampling/createMessage") {
+      const wrappedHandler = async (request, extra) => {
+        const validatedRequest = safeParse2(CreateMessageRequestSchema, request);
+        if (!validatedRequest.success) {
+          const errorMessage2 = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid sampling request: ${errorMessage2}`);
+        }
+        const { params } = validatedRequest.data;
+        const result = await Promise.resolve(handler(request, extra));
+        if (params.task) {
+          const taskValidationResult = safeParse2(CreateTaskResultSchema, result);
+          if (!taskValidationResult.success) {
+            const errorMessage2 = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage2}`);
+          }
+          return taskValidationResult.data;
+        }
+        const hasTools = params.tools || params.toolChoice;
+        const resultSchema = hasTools ? CreateMessageResultWithToolsSchema : CreateMessageResultSchema;
+        const validationResult = safeParse2(resultSchema, result);
+        if (!validationResult.success) {
+          const errorMessage2 = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid sampling result: ${errorMessage2}`);
+        }
+        return validationResult.data;
+      };
+      return super.setRequestHandler(requestSchema, wrappedHandler);
+    }
+    return super.setRequestHandler(requestSchema, handler);
+  }
+  assertCapability(capability, method) {
+    if (!this._serverCapabilities?.[capability]) {
+      throw new Error(`Server does not support ${capability} (required for ${method})`);
+    }
+  }
+  async connect(transport, options) {
+    await super.connect(transport);
+    if (transport.sessionId !== void 0) {
+      return;
+    }
+    try {
+      const result = await this.request({
+        method: "initialize",
+        params: {
+          protocolVersion: LATEST_PROTOCOL_VERSION,
+          capabilities: this._capabilities,
+          clientInfo: this._clientInfo
+        }
+      }, InitializeResultSchema, options);
+      if (result === void 0) {
+        throw new Error(`Server sent invalid initialize result: ${result}`);
+      }
+      if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) {
+        throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`);
+      }
+      this._serverCapabilities = result.capabilities;
+      this._serverVersion = result.serverInfo;
+      if (transport.setProtocolVersion) {
+        transport.setProtocolVersion(result.protocolVersion);
+      }
+      this._instructions = result.instructions;
+      await this.notification({
+        method: "notifications/initialized"
+      });
+      if (this._pendingListChangedConfig) {
+        this._setupListChangedHandlers(this._pendingListChangedConfig);
+        this._pendingListChangedConfig = void 0;
+      }
+    } catch (error51) {
+      void this.close();
+      throw error51;
+    }
+  }
+  /**
+   * After initialization has completed, this will be populated with the server's reported capabilities.
+   */
+  getServerCapabilities() {
+    return this._serverCapabilities;
+  }
+  /**
+   * After initialization has completed, this will be populated with information about the server's name and version.
+   */
+  getServerVersion() {
+    return this._serverVersion;
+  }
+  /**
+   * After initialization has completed, this may be populated with information about the server's instructions.
+   */
+  getInstructions() {
+    return this._instructions;
+  }
+  assertCapabilityForMethod(method) {
+    switch (method) {
+      case "logging/setLevel":
+        if (!this._serverCapabilities?.logging) {
+          throw new Error(`Server does not support logging (required for ${method})`);
+        }
+        break;
+      case "prompts/get":
+      case "prompts/list":
+        if (!this._serverCapabilities?.prompts) {
+          throw new Error(`Server does not support prompts (required for ${method})`);
+        }
+        break;
+      case "resources/list":
+      case "resources/templates/list":
+      case "resources/read":
+      case "resources/subscribe":
+      case "resources/unsubscribe":
+        if (!this._serverCapabilities?.resources) {
+          throw new Error(`Server does not support resources (required for ${method})`);
+        }
+        if (method === "resources/subscribe" && !this._serverCapabilities.resources.subscribe) {
+          throw new Error(`Server does not support resource subscriptions (required for ${method})`);
+        }
+        break;
+      case "tools/call":
+      case "tools/list":
+        if (!this._serverCapabilities?.tools) {
+          throw new Error(`Server does not support tools (required for ${method})`);
+        }
+        break;
+      case "completion/complete":
+        if (!this._serverCapabilities?.completions) {
+          throw new Error(`Server does not support completions (required for ${method})`);
+        }
+        break;
+      case "initialize":
+        break;
+      case "ping":
+        break;
+    }
+  }
+  assertNotificationCapability(method) {
+    switch (method) {
+      case "notifications/roots/list_changed":
+        if (!this._capabilities.roots?.listChanged) {
+          throw new Error(`Client does not support roots list changed notifications (required for ${method})`);
+        }
+        break;
+      case "notifications/initialized":
+        break;
+      case "notifications/cancelled":
+        break;
+      case "notifications/progress":
+        break;
+    }
+  }
+  assertRequestHandlerCapability(method) {
+    if (!this._capabilities) {
+      return;
+    }
+    switch (method) {
+      case "sampling/createMessage":
+        if (!this._capabilities.sampling) {
+          throw new Error(`Client does not support sampling capability (required for ${method})`);
+        }
+        break;
+      case "elicitation/create":
+        if (!this._capabilities.elicitation) {
+          throw new Error(`Client does not support elicitation capability (required for ${method})`);
+        }
+        break;
+      case "roots/list":
+        if (!this._capabilities.roots) {
+          throw new Error(`Client does not support roots capability (required for ${method})`);
+        }
+        break;
+      case "tasks/get":
+      case "tasks/list":
+      case "tasks/result":
+      case "tasks/cancel":
+        if (!this._capabilities.tasks) {
+          throw new Error(`Client does not support tasks capability (required for ${method})`);
+        }
+        break;
+      case "ping":
+        break;
+    }
+  }
+  assertTaskCapability(method) {
+    assertToolsCallTaskCapability(this._serverCapabilities?.tasks?.requests, method, "Server");
+  }
+  assertTaskHandlerCapability(method) {
+    if (!this._capabilities) {
+      return;
+    }
+    assertClientRequestTaskCapability(this._capabilities.tasks?.requests, method, "Client");
+  }
+  async ping(options) {
+    return this.request({ method: "ping" }, EmptyResultSchema, options);
+  }
+  async complete(params, options) {
+    return this.request({ method: "completion/complete", params }, CompleteResultSchema, options);
+  }
+  async setLoggingLevel(level, options) {
+    return this.request({ method: "logging/setLevel", params: { level } }, EmptyResultSchema, options);
+  }
+  async getPrompt(params, options) {
+    return this.request({ method: "prompts/get", params }, GetPromptResultSchema, options);
+  }
+  async listPrompts(params, options) {
+    return this.request({ method: "prompts/list", params }, ListPromptsResultSchema, options);
+  }
+  async listResources(params, options) {
+    return this.request({ method: "resources/list", params }, ListResourcesResultSchema, options);
+  }
+  async listResourceTemplates(params, options) {
+    return this.request({ method: "resources/templates/list", params }, ListResourceTemplatesResultSchema, options);
+  }
+  async readResource(params, options) {
+    return this.request({ method: "resources/read", params }, ReadResourceResultSchema, options);
+  }
+  async subscribeResource(params, options) {
+    return this.request({ method: "resources/subscribe", params }, EmptyResultSchema, options);
+  }
+  async unsubscribeResource(params, options) {
+    return this.request({ method: "resources/unsubscribe", params }, EmptyResultSchema, options);
+  }
+  /**
+   * Calls a tool and waits for the result. Automatically validates structured output if the tool has an outputSchema.
+   *
+   * For task-based execution with streaming behavior, use client.experimental.tasks.callToolStream() instead.
+   */
+  async callTool(params, resultSchema = CallToolResultSchema, options) {
+    if (this.isToolTaskRequired(params.name)) {
+      throw new McpError(ErrorCode.InvalidRequest, `Tool "${params.name}" requires task-based execution. Use client.experimental.tasks.callToolStream() instead.`);
+    }
+    const result = await this.request({ method: "tools/call", params }, resultSchema, options);
+    const validator = this.getToolOutputValidator(params.name);
+    if (validator) {
+      if (!result.structuredContent && !result.isError) {
+        throw new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`);
+      }
+      if (result.structuredContent) {
+        try {
+          const validationResult = validator(result.structuredContent);
+          if (!validationResult.valid) {
+            throw new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`);
+          }
+        } catch (error51) {
+          if (error51 instanceof McpError) {
+            throw error51;
+          }
+          throw new McpError(ErrorCode.InvalidParams, `Failed to validate structured content: ${error51 instanceof Error ? error51.message : String(error51)}`);
+        }
+      }
+    }
+    return result;
+  }
+  isToolTask(toolName) {
+    if (!this._serverCapabilities?.tasks?.requests?.tools?.call) {
+      return false;
+    }
+    return this._cachedKnownTaskTools.has(toolName);
+  }
+  /**
+   * Check if a tool requires task-based execution.
+   * Unlike isToolTask which includes 'optional' tools, this only checks for 'required'.
+   */
+  isToolTaskRequired(toolName) {
+    return this._cachedRequiredTaskTools.has(toolName);
+  }
+  /**
+   * Cache validators for tool output schemas.
+   * Called after listTools() to pre-compile validators for better performance.
+   */
+  cacheToolMetadata(tools) {
+    this._cachedToolOutputValidators.clear();
+    this._cachedKnownTaskTools.clear();
+    this._cachedRequiredTaskTools.clear();
+    for (const tool of tools) {
+      if (tool.outputSchema) {
+        const toolValidator = this._jsonSchemaValidator.getValidator(tool.outputSchema);
+        this._cachedToolOutputValidators.set(tool.name, toolValidator);
+      }
+      const taskSupport = tool.execution?.taskSupport;
+      if (taskSupport === "required" || taskSupport === "optional") {
+        this._cachedKnownTaskTools.add(tool.name);
+      }
+      if (taskSupport === "required") {
+        this._cachedRequiredTaskTools.add(tool.name);
+      }
+    }
+  }
+  /**
+   * Get cached validator for a tool
+   */
+  getToolOutputValidator(toolName) {
+    return this._cachedToolOutputValidators.get(toolName);
+  }
+  async listTools(params, options) {
+    const result = await this.request({ method: "tools/list", params }, ListToolsResultSchema, options);
+    this.cacheToolMetadata(result.tools);
+    return result;
+  }
+  /**
+   * Set up a single list changed handler.
+   * @internal
+   */
+  _setupListChangedHandler(listType, notificationSchema, options, fetcher) {
+    const parseResult = ListChangedOptionsBaseSchema.safeParse(options);
+    if (!parseResult.success) {
+      throw new Error(`Invalid ${listType} listChanged options: ${parseResult.error.message}`);
+    }
+    if (typeof options.onChanged !== "function") {
+      throw new Error(`Invalid ${listType} listChanged options: onChanged must be a function`);
+    }
+    const { autoRefresh, debounceMs } = parseResult.data;
+    const { onChanged } = options;
+    const refresh = async () => {
+      if (!autoRefresh) {
+        onChanged(null, null);
+        return;
+      }
+      try {
+        const items = await fetcher();
+        onChanged(null, items);
+      } catch (e) {
+        const error51 = e instanceof Error ? e : new Error(String(e));
+        onChanged(error51, null);
+      }
+    };
+    const handler = () => {
+      if (debounceMs) {
+        const existingTimer = this._listChangedDebounceTimers.get(listType);
+        if (existingTimer) {
+          clearTimeout(existingTimer);
+        }
+        const timer = setTimeout(refresh, debounceMs);
+        this._listChangedDebounceTimers.set(listType, timer);
+      } else {
+        refresh();
+      }
+    };
+    this.setNotificationHandler(notificationSchema, handler);
+  }
+  async sendRootsListChanged() {
+    return this.notification({ method: "notifications/roots/list_changed" });
+  }
+};
+
 // node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
 var ExperimentalServerTasks = class {
   constructor(_server) {
@@ -29563,41 +30273,6 @@ var ExperimentalServerTasks = class {
   }
 };
 
-// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
-function assertToolsCallTaskCapability(requests, method, entityName) {
-  if (!requests) {
-    throw new Error(`${entityName} does not support task creation (required for ${method})`);
-  }
-  switch (method) {
-    case "tools/call":
-      if (!requests.tools?.call) {
-        throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
-      }
-      break;
-    default:
-      break;
-  }
-}
-function assertClientRequestTaskCapability(requests, method, entityName) {
-  if (!requests) {
-    throw new Error(`${entityName} does not support task creation (required for ${method})`);
-  }
-  switch (method) {
-    case "sampling/createMessage":
-      if (!requests.sampling?.createMessage) {
-        throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
-      }
-      break;
-    case "elicitation/create":
-      if (!requests.elicitation?.create) {
-        throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
-      }
-      break;
-    default:
-      break;
-  }
-}
-
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
 var Server = class extends Protocol {
   /**
@@ -30949,15 +31624,1476 @@ var StdioServerTransport = class {
   }
 };
 
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/transport.js
+function normalizeHeaders(headers) {
+  if (!headers)
+    return {};
+  if (headers instanceof Headers) {
+    return Object.fromEntries(headers.entries());
+  }
+  if (Array.isArray(headers)) {
+    return Object.fromEntries(headers);
+  }
+  return { ...headers };
+}
+function createFetchWithInit(baseFetch = fetch, baseInit) {
+  if (!baseInit) {
+    return baseFetch;
+  }
+  return async (url2, init) => {
+    const mergedInit = {
+      ...baseInit,
+      ...init,
+      // Headers need special handling - merge instead of replace
+      headers: init?.headers ? { ...normalizeHeaders(baseInit.headers), ...normalizeHeaders(init.headers) } : baseInit.headers
+    };
+    return baseFetch(url2, mergedInit);
+  };
+}
+
+// node_modules/pkce-challenge/dist/index.node.js
+var crypto;
+crypto = globalThis.crypto?.webcrypto ?? // Node.js [18-16] REPL
+globalThis.crypto ?? // Node.js >18
+import("node:crypto").then((m) => m.webcrypto);
+async function getRandomValues(size) {
+  return (await crypto).getRandomValues(new Uint8Array(size));
+}
+async function random(size) {
+  const mask = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
+  const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % mask.length;
+  let result = "";
+  while (result.length < size) {
+    const randomBytes = await getRandomValues(size - result.length);
+    for (const randomByte of randomBytes) {
+      if (randomByte < evenDistCutoff) {
+        result += mask[randomByte % mask.length];
+      }
+    }
+  }
+  return result;
+}
+async function generateVerifier(length) {
+  return await random(length);
+}
+async function generateChallenge(code_verifier) {
+  const buffer = await (await crypto).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
+  return btoa(String.fromCharCode(...new Uint8Array(buffer))).replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, "");
+}
+async function pkceChallenge(length) {
+  if (!length)
+    length = 43;
+  if (length < 43 || length > 128) {
+    throw `Expected a length between 43 and 128. Received ${length}.`;
+  }
+  const verifier = await generateVerifier(length);
+  const challenge = await generateChallenge(verifier);
+  return {
+    code_verifier: verifier,
+    code_challenge: challenge
+  };
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js
+var SafeUrlSchema = url().superRefine((val, ctx) => {
+  if (!URL.canParse(val)) {
+    ctx.addIssue({
+      code: ZodIssueCode2.custom,
+      message: "URL must be parseable",
+      fatal: true
+    });
+    return NEVER;
+  }
+}).refine((url2) => {
+  const u = new URL(url2);
+  return u.protocol !== "javascript:" && u.protocol !== "data:" && u.protocol !== "vbscript:";
+}, { message: "URL cannot use javascript:, data:, or vbscript: scheme" });
+var OAuthProtectedResourceMetadataSchema = looseObject({
+  resource: string2().url(),
+  authorization_servers: array(SafeUrlSchema).optional(),
+  jwks_uri: string2().url().optional(),
+  scopes_supported: array(string2()).optional(),
+  bearer_methods_supported: array(string2()).optional(),
+  resource_signing_alg_values_supported: array(string2()).optional(),
+  resource_name: string2().optional(),
+  resource_documentation: string2().optional(),
+  resource_policy_uri: string2().url().optional(),
+  resource_tos_uri: string2().url().optional(),
+  tls_client_certificate_bound_access_tokens: boolean2().optional(),
+  authorization_details_types_supported: array(string2()).optional(),
+  dpop_signing_alg_values_supported: array(string2()).optional(),
+  dpop_bound_access_tokens_required: boolean2().optional()
+});
+var OAuthMetadataSchema = looseObject({
+  issuer: string2(),
+  authorization_endpoint: SafeUrlSchema,
+  token_endpoint: SafeUrlSchema,
+  registration_endpoint: SafeUrlSchema.optional(),
+  scopes_supported: array(string2()).optional(),
+  response_types_supported: array(string2()),
+  response_modes_supported: array(string2()).optional(),
+  grant_types_supported: array(string2()).optional(),
+  token_endpoint_auth_methods_supported: array(string2()).optional(),
+  token_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  service_documentation: SafeUrlSchema.optional(),
+  revocation_endpoint: SafeUrlSchema.optional(),
+  revocation_endpoint_auth_methods_supported: array(string2()).optional(),
+  revocation_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  introspection_endpoint: string2().optional(),
+  introspection_endpoint_auth_methods_supported: array(string2()).optional(),
+  introspection_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  code_challenge_methods_supported: array(string2()).optional(),
+  client_id_metadata_document_supported: boolean2().optional()
+});
+var OpenIdProviderMetadataSchema = looseObject({
+  issuer: string2(),
+  authorization_endpoint: SafeUrlSchema,
+  token_endpoint: SafeUrlSchema,
+  userinfo_endpoint: SafeUrlSchema.optional(),
+  jwks_uri: SafeUrlSchema,
+  registration_endpoint: SafeUrlSchema.optional(),
+  scopes_supported: array(string2()).optional(),
+  response_types_supported: array(string2()),
+  response_modes_supported: array(string2()).optional(),
+  grant_types_supported: array(string2()).optional(),
+  acr_values_supported: array(string2()).optional(),
+  subject_types_supported: array(string2()),
+  id_token_signing_alg_values_supported: array(string2()),
+  id_token_encryption_alg_values_supported: array(string2()).optional(),
+  id_token_encryption_enc_values_supported: array(string2()).optional(),
+  userinfo_signing_alg_values_supported: array(string2()).optional(),
+  userinfo_encryption_alg_values_supported: array(string2()).optional(),
+  userinfo_encryption_enc_values_supported: array(string2()).optional(),
+  request_object_signing_alg_values_supported: array(string2()).optional(),
+  request_object_encryption_alg_values_supported: array(string2()).optional(),
+  request_object_encryption_enc_values_supported: array(string2()).optional(),
+  token_endpoint_auth_methods_supported: array(string2()).optional(),
+  token_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  display_values_supported: array(string2()).optional(),
+  claim_types_supported: array(string2()).optional(),
+  claims_supported: array(string2()).optional(),
+  service_documentation: string2().optional(),
+  claims_locales_supported: array(string2()).optional(),
+  ui_locales_supported: array(string2()).optional(),
+  claims_parameter_supported: boolean2().optional(),
+  request_parameter_supported: boolean2().optional(),
+  request_uri_parameter_supported: boolean2().optional(),
+  require_request_uri_registration: boolean2().optional(),
+  op_policy_uri: SafeUrlSchema.optional(),
+  op_tos_uri: SafeUrlSchema.optional(),
+  client_id_metadata_document_supported: boolean2().optional()
+});
+var OpenIdProviderDiscoveryMetadataSchema = object2({
+  ...OpenIdProviderMetadataSchema.shape,
+  ...OAuthMetadataSchema.pick({
+    code_challenge_methods_supported: true
+  }).shape
+});
+var OAuthTokensSchema = object2({
+  access_token: string2(),
+  id_token: string2().optional(),
+  // Optional for OAuth 2.1, but necessary in OpenID Connect
+  token_type: string2(),
+  expires_in: coerce_exports2.number().optional(),
+  scope: string2().optional(),
+  refresh_token: string2().optional()
+}).strip();
+var OAuthErrorResponseSchema = object2({
+  error: string2(),
+  error_description: string2().optional(),
+  error_uri: string2().optional()
+});
+var OptionalSafeUrlSchema = SafeUrlSchema.optional().or(literal("").transform(() => void 0));
+var OAuthClientMetadataSchema = object2({
+  redirect_uris: array(SafeUrlSchema),
+  token_endpoint_auth_method: string2().optional(),
+  grant_types: array(string2()).optional(),
+  response_types: array(string2()).optional(),
+  client_name: string2().optional(),
+  client_uri: SafeUrlSchema.optional(),
+  logo_uri: OptionalSafeUrlSchema,
+  scope: string2().optional(),
+  contacts: array(string2()).optional(),
+  tos_uri: OptionalSafeUrlSchema,
+  policy_uri: string2().optional(),
+  jwks_uri: SafeUrlSchema.optional(),
+  jwks: any().optional(),
+  software_id: string2().optional(),
+  software_version: string2().optional(),
+  software_statement: string2().optional()
+}).strip();
+var OAuthClientInformationSchema = object2({
+  client_id: string2(),
+  client_secret: string2().optional(),
+  client_id_issued_at: number2().optional(),
+  client_secret_expires_at: number2().optional()
+}).strip();
+var OAuthClientInformationFullSchema = OAuthClientMetadataSchema.merge(OAuthClientInformationSchema);
+var OAuthClientRegistrationErrorSchema = object2({
+  error: string2(),
+  error_description: string2().optional()
+}).strip();
+var OAuthTokenRevocationRequestSchema = object2({
+  token: string2(),
+  token_type_hint: string2().optional()
+}).strip();
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth-utils.js
+function resourceUrlFromServerUrl(url2) {
+  const resourceURL = typeof url2 === "string" ? new URL(url2) : new URL(url2.href);
+  resourceURL.hash = "";
+  return resourceURL;
+}
+function checkResourceAllowed({ requestedResource, configuredResource }) {
+  const requested = typeof requestedResource === "string" ? new URL(requestedResource) : new URL(requestedResource.href);
+  const configured = typeof configuredResource === "string" ? new URL(configuredResource) : new URL(configuredResource.href);
+  if (requested.origin !== configured.origin) {
+    return false;
+  }
+  if (requested.pathname.length < configured.pathname.length) {
+    return false;
+  }
+  const requestedPath = requested.pathname.endsWith("/") ? requested.pathname : requested.pathname + "/";
+  const configuredPath = configured.pathname.endsWith("/") ? configured.pathname : configured.pathname + "/";
+  return requestedPath.startsWith(configuredPath);
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/auth/errors.js
+var OAuthError = class extends Error {
+  constructor(message, errorUri) {
+    super(message);
+    this.errorUri = errorUri;
+    this.name = this.constructor.name;
+  }
+  /**
+   * Converts the error to a standard OAuth error response object
+   */
+  toResponseObject() {
+    const response = {
+      error: this.errorCode,
+      error_description: this.message
+    };
+    if (this.errorUri) {
+      response.error_uri = this.errorUri;
+    }
+    return response;
+  }
+  get errorCode() {
+    return this.constructor.errorCode;
+  }
+};
+var InvalidRequestError = class extends OAuthError {
+};
+InvalidRequestError.errorCode = "invalid_request";
+var InvalidClientError = class extends OAuthError {
+};
+InvalidClientError.errorCode = "invalid_client";
+var InvalidGrantError = class extends OAuthError {
+};
+InvalidGrantError.errorCode = "invalid_grant";
+var UnauthorizedClientError = class extends OAuthError {
+};
+UnauthorizedClientError.errorCode = "unauthorized_client";
+var UnsupportedGrantTypeError = class extends OAuthError {
+};
+UnsupportedGrantTypeError.errorCode = "unsupported_grant_type";
+var InvalidScopeError = class extends OAuthError {
+};
+InvalidScopeError.errorCode = "invalid_scope";
+var AccessDeniedError = class extends OAuthError {
+};
+AccessDeniedError.errorCode = "access_denied";
+var ServerError = class extends OAuthError {
+};
+ServerError.errorCode = "server_error";
+var TemporarilyUnavailableError = class extends OAuthError {
+};
+TemporarilyUnavailableError.errorCode = "temporarily_unavailable";
+var UnsupportedResponseTypeError = class extends OAuthError {
+};
+UnsupportedResponseTypeError.errorCode = "unsupported_response_type";
+var UnsupportedTokenTypeError = class extends OAuthError {
+};
+UnsupportedTokenTypeError.errorCode = "unsupported_token_type";
+var InvalidTokenError = class extends OAuthError {
+};
+InvalidTokenError.errorCode = "invalid_token";
+var MethodNotAllowedError = class extends OAuthError {
+};
+MethodNotAllowedError.errorCode = "method_not_allowed";
+var TooManyRequestsError = class extends OAuthError {
+};
+TooManyRequestsError.errorCode = "too_many_requests";
+var InvalidClientMetadataError = class extends OAuthError {
+};
+InvalidClientMetadataError.errorCode = "invalid_client_metadata";
+var InsufficientScopeError = class extends OAuthError {
+};
+InsufficientScopeError.errorCode = "insufficient_scope";
+var InvalidTargetError = class extends OAuthError {
+};
+InvalidTargetError.errorCode = "invalid_target";
+var OAUTH_ERRORS = {
+  [InvalidRequestError.errorCode]: InvalidRequestError,
+  [InvalidClientError.errorCode]: InvalidClientError,
+  [InvalidGrantError.errorCode]: InvalidGrantError,
+  [UnauthorizedClientError.errorCode]: UnauthorizedClientError,
+  [UnsupportedGrantTypeError.errorCode]: UnsupportedGrantTypeError,
+  [InvalidScopeError.errorCode]: InvalidScopeError,
+  [AccessDeniedError.errorCode]: AccessDeniedError,
+  [ServerError.errorCode]: ServerError,
+  [TemporarilyUnavailableError.errorCode]: TemporarilyUnavailableError,
+  [UnsupportedResponseTypeError.errorCode]: UnsupportedResponseTypeError,
+  [UnsupportedTokenTypeError.errorCode]: UnsupportedTokenTypeError,
+  [InvalidTokenError.errorCode]: InvalidTokenError,
+  [MethodNotAllowedError.errorCode]: MethodNotAllowedError,
+  [TooManyRequestsError.errorCode]: TooManyRequestsError,
+  [InvalidClientMetadataError.errorCode]: InvalidClientMetadataError,
+  [InsufficientScopeError.errorCode]: InsufficientScopeError,
+  [InvalidTargetError.errorCode]: InvalidTargetError
+};
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/auth.js
+var UnauthorizedError = class extends Error {
+  constructor(message) {
+    super(message ?? "Unauthorized");
+  }
+};
+function isClientAuthMethod(method) {
+  return ["client_secret_basic", "client_secret_post", "none"].includes(method);
+}
+var AUTHORIZATION_CODE_RESPONSE_TYPE = "code";
+var AUTHORIZATION_CODE_CHALLENGE_METHOD = "S256";
+function selectClientAuthMethod(clientInformation, supportedMethods) {
+  const hasClientSecret = clientInformation.client_secret !== void 0;
+  if ("token_endpoint_auth_method" in clientInformation && clientInformation.token_endpoint_auth_method && isClientAuthMethod(clientInformation.token_endpoint_auth_method) && (supportedMethods.length === 0 || supportedMethods.includes(clientInformation.token_endpoint_auth_method))) {
+    return clientInformation.token_endpoint_auth_method;
+  }
+  if (supportedMethods.length === 0) {
+    return hasClientSecret ? "client_secret_basic" : "none";
+  }
+  if (hasClientSecret && supportedMethods.includes("client_secret_basic")) {
+    return "client_secret_basic";
+  }
+  if (hasClientSecret && supportedMethods.includes("client_secret_post")) {
+    return "client_secret_post";
+  }
+  if (supportedMethods.includes("none")) {
+    return "none";
+  }
+  return hasClientSecret ? "client_secret_post" : "none";
+}
+function applyClientAuthentication(method, clientInformation, headers, params) {
+  const { client_id, client_secret } = clientInformation;
+  switch (method) {
+    case "client_secret_basic":
+      applyBasicAuth(client_id, client_secret, headers);
+      return;
+    case "client_secret_post":
+      applyPostAuth(client_id, client_secret, params);
+      return;
+    case "none":
+      applyPublicAuth(client_id, params);
+      return;
+    default:
+      throw new Error(`Unsupported client authentication method: ${method}`);
+  }
+}
+function applyBasicAuth(clientId, clientSecret, headers) {
+  if (!clientSecret) {
+    throw new Error("client_secret_basic authentication requires a client_secret");
+  }
+  const credentials = btoa(`${clientId}:${clientSecret}`);
+  headers.set("Authorization", `Basic ${credentials}`);
+}
+function applyPostAuth(clientId, clientSecret, params) {
+  params.set("client_id", clientId);
+  if (clientSecret) {
+    params.set("client_secret", clientSecret);
+  }
+}
+function applyPublicAuth(clientId, params) {
+  params.set("client_id", clientId);
+}
+async function parseErrorResponse(input) {
+  const statusCode = input instanceof Response ? input.status : void 0;
+  const body = input instanceof Response ? await input.text() : input;
+  try {
+    const result = OAuthErrorResponseSchema.parse(JSON.parse(body));
+    const { error: error51, error_description, error_uri } = result;
+    const errorClass = OAUTH_ERRORS[error51] || ServerError;
+    return new errorClass(error_description || "", error_uri);
+  } catch (error51) {
+    const errorMessage2 = `${statusCode ? `HTTP ${statusCode}: ` : ""}Invalid OAuth error response: ${error51}. Raw body: ${body}`;
+    return new ServerError(errorMessage2);
+  }
+}
+async function auth(provider, options) {
+  try {
+    return await authInternal(provider, options);
+  } catch (error51) {
+    if (error51 instanceof InvalidClientError || error51 instanceof UnauthorizedClientError) {
+      await provider.invalidateCredentials?.("all");
+      return await authInternal(provider, options);
+    } else if (error51 instanceof InvalidGrantError) {
+      await provider.invalidateCredentials?.("tokens");
+      return await authInternal(provider, options);
+    }
+    throw error51;
+  }
+}
+async function authInternal(provider, { serverUrl, authorizationCode, scope, resourceMetadataUrl, fetchFn }) {
+  const cachedState = await provider.discoveryState?.();
+  let resourceMetadata;
+  let authorizationServerUrl;
+  let metadata;
+  let effectiveResourceMetadataUrl = resourceMetadataUrl;
+  if (!effectiveResourceMetadataUrl && cachedState?.resourceMetadataUrl) {
+    effectiveResourceMetadataUrl = new URL(cachedState.resourceMetadataUrl);
+  }
+  if (cachedState?.authorizationServerUrl) {
+    authorizationServerUrl = cachedState.authorizationServerUrl;
+    resourceMetadata = cachedState.resourceMetadata;
+    metadata = cachedState.authorizationServerMetadata ?? await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn });
+    if (!resourceMetadata) {
+      try {
+        resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl }, fetchFn);
+      } catch {
+      }
+    }
+    if (metadata !== cachedState.authorizationServerMetadata || resourceMetadata !== cachedState.resourceMetadata) {
+      await provider.saveDiscoveryState?.({
+        authorizationServerUrl: String(authorizationServerUrl),
+        resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
+        resourceMetadata,
+        authorizationServerMetadata: metadata
+      });
+    }
+  } else {
+    const serverInfo = await discoverOAuthServerInfo(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl, fetchFn });
+    authorizationServerUrl = serverInfo.authorizationServerUrl;
+    metadata = serverInfo.authorizationServerMetadata;
+    resourceMetadata = serverInfo.resourceMetadata;
+    await provider.saveDiscoveryState?.({
+      authorizationServerUrl: String(authorizationServerUrl),
+      resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
+      resourceMetadata,
+      authorizationServerMetadata: metadata
+    });
+  }
+  const resource = await selectResourceURL(serverUrl, provider, resourceMetadata);
+  const resolvedScope = scope || resourceMetadata?.scopes_supported?.join(" ") || provider.clientMetadata.scope;
+  let clientInformation = await Promise.resolve(provider.clientInformation());
+  if (!clientInformation) {
+    if (authorizationCode !== void 0) {
+      throw new Error("Existing OAuth client information is required when exchanging an authorization code");
+    }
+    const supportsUrlBasedClientId = metadata?.client_id_metadata_document_supported === true;
+    const clientMetadataUrl = provider.clientMetadataUrl;
+    if (clientMetadataUrl && !isHttpsUrl(clientMetadataUrl)) {
+      throw new InvalidClientMetadataError(`clientMetadataUrl must be a valid HTTPS URL with a non-root pathname, got: ${clientMetadataUrl}`);
+    }
+    const shouldUseUrlBasedClientId = supportsUrlBasedClientId && clientMetadataUrl;
+    if (shouldUseUrlBasedClientId) {
+      clientInformation = {
+        client_id: clientMetadataUrl
+      };
+      await provider.saveClientInformation?.(clientInformation);
+    } else {
+      if (!provider.saveClientInformation) {
+        throw new Error("OAuth client information must be saveable for dynamic registration");
+      }
+      const fullInformation = await registerClient(authorizationServerUrl, {
+        metadata,
+        clientMetadata: provider.clientMetadata,
+        scope: resolvedScope,
+        fetchFn
+      });
+      await provider.saveClientInformation(fullInformation);
+      clientInformation = fullInformation;
+    }
+  }
+  const nonInteractiveFlow = !provider.redirectUrl;
+  if (authorizationCode !== void 0 || nonInteractiveFlow) {
+    const tokens2 = await fetchToken(provider, authorizationServerUrl, {
+      metadata,
+      resource,
+      authorizationCode,
+      fetchFn
+    });
+    await provider.saveTokens(tokens2);
+    return "AUTHORIZED";
+  }
+  const tokens = await provider.tokens();
+  if (tokens?.refresh_token) {
+    try {
+      const newTokens = await refreshAuthorization(authorizationServerUrl, {
+        metadata,
+        clientInformation,
+        refreshToken: tokens.refresh_token,
+        resource,
+        addClientAuthentication: provider.addClientAuthentication,
+        fetchFn
+      });
+      await provider.saveTokens(newTokens);
+      return "AUTHORIZED";
+    } catch (error51) {
+      if (!(error51 instanceof OAuthError) || error51 instanceof ServerError) {
+      } else {
+        throw error51;
+      }
+    }
+  }
+  const state = provider.state ? await provider.state() : void 0;
+  const { authorizationUrl, codeVerifier } = await startAuthorization(authorizationServerUrl, {
+    metadata,
+    clientInformation,
+    state,
+    redirectUrl: provider.redirectUrl,
+    scope: resolvedScope,
+    resource
+  });
+  await provider.saveCodeVerifier(codeVerifier);
+  await provider.redirectToAuthorization(authorizationUrl);
+  return "REDIRECT";
+}
+function isHttpsUrl(value) {
+  if (!value)
+    return false;
+  try {
+    const url2 = new URL(value);
+    return url2.protocol === "https:" && url2.pathname !== "/";
+  } catch {
+    return false;
+  }
+}
+async function selectResourceURL(serverUrl, provider, resourceMetadata) {
+  const defaultResource = resourceUrlFromServerUrl(serverUrl);
+  if (provider.validateResourceURL) {
+    return await provider.validateResourceURL(defaultResource, resourceMetadata?.resource);
+  }
+  if (!resourceMetadata) {
+    return void 0;
+  }
+  if (!checkResourceAllowed({ requestedResource: defaultResource, configuredResource: resourceMetadata.resource })) {
+    throw new Error(`Protected resource ${resourceMetadata.resource} does not match expected ${defaultResource} (or origin)`);
+  }
+  return new URL(resourceMetadata.resource);
+}
+function extractWWWAuthenticateParams(res) {
+  const authenticateHeader = res.headers.get("WWW-Authenticate");
+  if (!authenticateHeader) {
+    return {};
+  }
+  const [type2, scheme] = authenticateHeader.split(" ");
+  if (type2.toLowerCase() !== "bearer" || !scheme) {
+    return {};
+  }
+  const resourceMetadataMatch = extractFieldFromWwwAuth(res, "resource_metadata") || void 0;
+  let resourceMetadataUrl;
+  if (resourceMetadataMatch) {
+    try {
+      resourceMetadataUrl = new URL(resourceMetadataMatch);
+    } catch {
+    }
+  }
+  const scope = extractFieldFromWwwAuth(res, "scope") || void 0;
+  const error51 = extractFieldFromWwwAuth(res, "error") || void 0;
+  return {
+    resourceMetadataUrl,
+    scope,
+    error: error51
+  };
+}
+function extractFieldFromWwwAuth(response, fieldName) {
+  const wwwAuthHeader = response.headers.get("WWW-Authenticate");
+  if (!wwwAuthHeader) {
+    return null;
+  }
+  const pattern = new RegExp(`${fieldName}=(?:"([^"]+)"|([^\\s,]+))`);
+  const match = wwwAuthHeader.match(pattern);
+  if (match) {
+    return match[1] || match[2];
+  }
+  return null;
+}
+async function discoverOAuthProtectedResourceMetadata(serverUrl, opts, fetchFn = fetch) {
+  const response = await discoverMetadataWithFallback(serverUrl, "oauth-protected-resource", fetchFn, {
+    protocolVersion: opts?.protocolVersion,
+    metadataUrl: opts?.resourceMetadataUrl
+  });
+  if (!response || response.status === 404) {
+    await response?.body?.cancel();
+    throw new Error(`Resource server does not implement OAuth 2.0 Protected Resource Metadata.`);
+  }
+  if (!response.ok) {
+    await response.body?.cancel();
+    throw new Error(`HTTP ${response.status} trying to load well-known OAuth protected resource metadata.`);
+  }
+  return OAuthProtectedResourceMetadataSchema.parse(await response.json());
+}
+async function fetchWithCorsRetry(url2, headers, fetchFn = fetch) {
+  try {
+    return await fetchFn(url2, { headers });
+  } catch (error51) {
+    if (error51 instanceof TypeError) {
+      if (headers) {
+        return fetchWithCorsRetry(url2, void 0, fetchFn);
+      } else {
+        return void 0;
+      }
+    }
+    throw error51;
+  }
+}
+function buildWellKnownPath(wellKnownPrefix, pathname = "", options = {}) {
+  if (pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+  return options.prependPathname ? `${pathname}/.well-known/${wellKnownPrefix}` : `/.well-known/${wellKnownPrefix}${pathname}`;
+}
+async function tryMetadataDiscovery(url2, protocolVersion, fetchFn = fetch) {
+  const headers = {
+    "MCP-Protocol-Version": protocolVersion
+  };
+  return await fetchWithCorsRetry(url2, headers, fetchFn);
+}
+function shouldAttemptFallback(response, pathname) {
+  return !response || response.status >= 400 && response.status < 500 && pathname !== "/";
+}
+async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, opts) {
+  const issuer = new URL(serverUrl);
+  const protocolVersion = opts?.protocolVersion ?? LATEST_PROTOCOL_VERSION;
+  let url2;
+  if (opts?.metadataUrl) {
+    url2 = new URL(opts.metadataUrl);
+  } else {
+    const wellKnownPath = buildWellKnownPath(wellKnownType, issuer.pathname);
+    url2 = new URL(wellKnownPath, opts?.metadataServerUrl ?? issuer);
+    url2.search = issuer.search;
+  }
+  let response = await tryMetadataDiscovery(url2, protocolVersion, fetchFn);
+  if (!opts?.metadataUrl && shouldAttemptFallback(response, issuer.pathname)) {
+    const rootUrl = new URL(`/.well-known/${wellKnownType}`, issuer);
+    response = await tryMetadataDiscovery(rootUrl, protocolVersion, fetchFn);
+  }
+  return response;
+}
+function buildDiscoveryUrls(authorizationServerUrl) {
+  const url2 = typeof authorizationServerUrl === "string" ? new URL(authorizationServerUrl) : authorizationServerUrl;
+  const hasPath = url2.pathname !== "/";
+  const urlsToTry = [];
+  if (!hasPath) {
+    urlsToTry.push({
+      url: new URL("/.well-known/oauth-authorization-server", url2.origin),
+      type: "oauth"
+    });
+    urlsToTry.push({
+      url: new URL(`/.well-known/openid-configuration`, url2.origin),
+      type: "oidc"
+    });
+    return urlsToTry;
+  }
+  let pathname = url2.pathname;
+  if (pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+  urlsToTry.push({
+    url: new URL(`/.well-known/oauth-authorization-server${pathname}`, url2.origin),
+    type: "oauth"
+  });
+  urlsToTry.push({
+    url: new URL(`/.well-known/openid-configuration${pathname}`, url2.origin),
+    type: "oidc"
+  });
+  urlsToTry.push({
+    url: new URL(`${pathname}/.well-known/openid-configuration`, url2.origin),
+    type: "oidc"
+  });
+  return urlsToTry;
+}
+async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn = fetch, protocolVersion = LATEST_PROTOCOL_VERSION } = {}) {
+  const headers = {
+    "MCP-Protocol-Version": protocolVersion,
+    Accept: "application/json"
+  };
+  const urlsToTry = buildDiscoveryUrls(authorizationServerUrl);
+  for (const { url: endpointUrl, type: type2 } of urlsToTry) {
+    const response = await fetchWithCorsRetry(endpointUrl, headers, fetchFn);
+    if (!response) {
+      continue;
+    }
+    if (!response.ok) {
+      await response.body?.cancel();
+      if (response.status >= 400 && response.status < 500) {
+        continue;
+      }
+      throw new Error(`HTTP ${response.status} trying to load ${type2 === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${endpointUrl}`);
+    }
+    if (type2 === "oauth") {
+      return OAuthMetadataSchema.parse(await response.json());
+    } else {
+      return OpenIdProviderDiscoveryMetadataSchema.parse(await response.json());
+    }
+  }
+  return void 0;
+}
+async function discoverOAuthServerInfo(serverUrl, opts) {
+  let resourceMetadata;
+  let authorizationServerUrl;
+  try {
+    resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: opts?.resourceMetadataUrl }, opts?.fetchFn);
+    if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) {
+      authorizationServerUrl = resourceMetadata.authorization_servers[0];
+    }
+  } catch {
+  }
+  if (!authorizationServerUrl) {
+    authorizationServerUrl = String(new URL("/", serverUrl));
+  }
+  const authorizationServerMetadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn: opts?.fetchFn });
+  return {
+    authorizationServerUrl,
+    authorizationServerMetadata,
+    resourceMetadata
+  };
+}
+async function startAuthorization(authorizationServerUrl, { metadata, clientInformation, redirectUrl, scope, state, resource }) {
+  let authorizationUrl;
+  if (metadata) {
+    authorizationUrl = new URL(metadata.authorization_endpoint);
+    if (!metadata.response_types_supported.includes(AUTHORIZATION_CODE_RESPONSE_TYPE)) {
+      throw new Error(`Incompatible auth server: does not support response type ${AUTHORIZATION_CODE_RESPONSE_TYPE}`);
+    }
+    if (metadata.code_challenge_methods_supported && !metadata.code_challenge_methods_supported.includes(AUTHORIZATION_CODE_CHALLENGE_METHOD)) {
+      throw new Error(`Incompatible auth server: does not support code challenge method ${AUTHORIZATION_CODE_CHALLENGE_METHOD}`);
+    }
+  } else {
+    authorizationUrl = new URL("/authorize", authorizationServerUrl);
+  }
+  const challenge = await pkceChallenge();
+  const codeVerifier = challenge.code_verifier;
+  const codeChallenge = challenge.code_challenge;
+  authorizationUrl.searchParams.set("response_type", AUTHORIZATION_CODE_RESPONSE_TYPE);
+  authorizationUrl.searchParams.set("client_id", clientInformation.client_id);
+  authorizationUrl.searchParams.set("code_challenge", codeChallenge);
+  authorizationUrl.searchParams.set("code_challenge_method", AUTHORIZATION_CODE_CHALLENGE_METHOD);
+  authorizationUrl.searchParams.set("redirect_uri", String(redirectUrl));
+  if (state) {
+    authorizationUrl.searchParams.set("state", state);
+  }
+  if (scope) {
+    authorizationUrl.searchParams.set("scope", scope);
+  }
+  if (scope?.includes("offline_access")) {
+    authorizationUrl.searchParams.append("prompt", "consent");
+  }
+  if (resource) {
+    authorizationUrl.searchParams.set("resource", resource.href);
+  }
+  return { authorizationUrl, codeVerifier };
+}
+function prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, redirectUri) {
+  return new URLSearchParams({
+    grant_type: "authorization_code",
+    code: authorizationCode,
+    code_verifier: codeVerifier,
+    redirect_uri: String(redirectUri)
+  });
+}
+async function executeTokenRequest(authorizationServerUrl, { metadata, tokenRequestParams, clientInformation, addClientAuthentication, resource, fetchFn }) {
+  const tokenUrl = metadata?.token_endpoint ? new URL(metadata.token_endpoint) : new URL("/token", authorizationServerUrl);
+  const headers = new Headers({
+    "Content-Type": "application/x-www-form-urlencoded",
+    Accept: "application/json"
+  });
+  if (resource) {
+    tokenRequestParams.set("resource", resource.href);
+  }
+  if (addClientAuthentication) {
+    await addClientAuthentication(headers, tokenRequestParams, tokenUrl, metadata);
+  } else if (clientInformation) {
+    const supportedMethods = metadata?.token_endpoint_auth_methods_supported ?? [];
+    const authMethod = selectClientAuthMethod(clientInformation, supportedMethods);
+    applyClientAuthentication(authMethod, clientInformation, headers, tokenRequestParams);
+  }
+  const response = await (fetchFn ?? fetch)(tokenUrl, {
+    method: "POST",
+    headers,
+    body: tokenRequestParams
+  });
+  if (!response.ok) {
+    throw await parseErrorResponse(response);
+  }
+  return OAuthTokensSchema.parse(await response.json());
+}
+async function refreshAuthorization(authorizationServerUrl, { metadata, clientInformation, refreshToken, resource, addClientAuthentication, fetchFn }) {
+  const tokenRequestParams = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: refreshToken
+  });
+  const tokens = await executeTokenRequest(authorizationServerUrl, {
+    metadata,
+    tokenRequestParams,
+    clientInformation,
+    addClientAuthentication,
+    resource,
+    fetchFn
+  });
+  return { refresh_token: refreshToken, ...tokens };
+}
+async function fetchToken(provider, authorizationServerUrl, { metadata, resource, authorizationCode, fetchFn } = {}) {
+  const scope = provider.clientMetadata.scope;
+  let tokenRequestParams;
+  if (provider.prepareTokenRequest) {
+    tokenRequestParams = await provider.prepareTokenRequest(scope);
+  }
+  if (!tokenRequestParams) {
+    if (!authorizationCode) {
+      throw new Error("Either provider.prepareTokenRequest() or authorizationCode is required");
+    }
+    if (!provider.redirectUrl) {
+      throw new Error("redirectUrl is required for authorization_code flow");
+    }
+    const codeVerifier = await provider.codeVerifier();
+    tokenRequestParams = prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, provider.redirectUrl);
+  }
+  const clientInformation = await provider.clientInformation();
+  return executeTokenRequest(authorizationServerUrl, {
+    metadata,
+    tokenRequestParams,
+    clientInformation: clientInformation ?? void 0,
+    addClientAuthentication: provider.addClientAuthentication,
+    resource,
+    fetchFn
+  });
+}
+async function registerClient(authorizationServerUrl, { metadata, clientMetadata, scope, fetchFn }) {
+  let registrationUrl;
+  if (metadata) {
+    if (!metadata.registration_endpoint) {
+      throw new Error("Incompatible auth server: does not support dynamic client registration");
+    }
+    registrationUrl = new URL(metadata.registration_endpoint);
+  } else {
+    registrationUrl = new URL("/register", authorizationServerUrl);
+  }
+  const response = await (fetchFn ?? fetch)(registrationUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      ...clientMetadata,
+      ...scope !== void 0 ? { scope } : {}
+    })
+  });
+  if (!response.ok) {
+    throw await parseErrorResponse(response);
+  }
+  return OAuthClientInformationFullSchema.parse(await response.json());
+}
+
+// node_modules/eventsource-parser/dist/index.js
+var ParseError = class extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+};
+var LF = 10;
+var CR = 13;
+var SPACE = 32;
+function noop(_arg) {
+}
+function createParser(callbacks) {
+  if (typeof callbacks == "function")
+    throw new TypeError(
+      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks, pendingFragments = [];
+  let isFirstChunk = true, id, data = "", dataLines = 0, eventType;
+  function feed(chunk) {
+    if (isFirstChunk && (isFirstChunk = false, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+      const trailing2 = processLines(chunk);
+      trailing2 !== "" && pendingFragments.push(trailing2);
+      return;
+    }
+    if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+      pendingFragments.push(chunk);
+      return;
+    }
+    pendingFragments.push(chunk);
+    const input = pendingFragments.join("");
+    pendingFragments.length = 0;
+    const trailing = processLines(input);
+    trailing !== "" && pendingFragments.push(trailing);
+  }
+  function processLines(chunk) {
+    let searchIndex = 0;
+    if (chunk.indexOf("\r") === -1) {
+      let lfIndex = chunk.indexOf(`
+`, searchIndex);
+      for (; lfIndex !== -1; ) {
+        if (searchIndex === lfIndex) {
+          dataLines > 0 && onEvent({ id, event: eventType, data }), id = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+          continue;
+        }
+        const firstCharCode = chunk.charCodeAt(searchIndex);
+        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+          const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
+          if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+            onEvent({ id, event: eventType, data: value }), id = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+            continue;
+          }
+          data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        } else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(
+          chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6,
+          lfIndex
+        ) || void 0 : parseLine(chunk, searchIndex, lfIndex);
+        searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+      }
+      return chunk.slice(searchIndex);
+    }
+    for (; searchIndex < chunk.length; ) {
+      const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+      let lineEnd = -1;
+      if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1)
+        break;
+      parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
+    }
+    return chunk.slice(searchIndex);
+  }
+  function parseLine(chunk, start, end) {
+    if (start === end) {
+      dispatchEvent();
+      return;
+    }
+    const firstCharCode = chunk.charCodeAt(start);
+    if (isDataPrefix(chunk, start, firstCharCode)) {
+      const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
+      data = dataLines === 0 ? value2 : `${data}
+${value2}`, dataLines++;
+      return;
+    }
+    if (isEventPrefix(chunk, start, firstCharCode)) {
+      eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
+      return;
+    }
+    if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+      const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+      id = value2.includes("\0") ? void 0 : value2;
+      return;
+    }
+    if (firstCharCode === 58) {
+      if (onComment) {
+        const line2 = chunk.slice(start, end);
+        onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+      }
+      return;
+    }
+    const line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex === -1) {
+      processField(line, "", line);
+      return;
+    }
+    const field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+    processField(field, value, line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value || void 0;
+        break;
+      case "data":
+        data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        break;
+      case "id":
+        id = value.includes("\0") ? void 0 : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    dataLines > 0 && onEvent({
+      id,
+      event: eventType,
+      data
+    }), id = void 0, data = "", dataLines = 0, eventType = void 0;
+  }
+  function reset(options = {}) {
+    if (options.consume && pendingFragments.length > 0) {
+      const incompleteLine = pendingFragments.join("");
+      parseLine(incompleteLine, 0, incompleteLine.length);
+    }
+    isFirstChunk = true, id = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0;
+  }
+  return { feed, reset };
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
+}
+
+// node_modules/eventsource-parser/dist/stream.js
+var EventSourceParserStream = class extends TransformStream {
+  constructor({ onError, onRetry, onComment } = {}) {
+    let parser;
+    super({
+      start(controller) {
+        parser = createParser({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          },
+          onError(error51) {
+            onError === "terminate" ? controller.error(error51) : typeof onError == "function" && onError(error51);
+          },
+          onRetry,
+          onComment
+        });
+      },
+      transform(chunk) {
+        parser.feed(chunk);
+      }
+    });
+  }
+};
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/streamableHttp.js
+var DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS = {
+  initialReconnectionDelay: 1e3,
+  maxReconnectionDelay: 3e4,
+  reconnectionDelayGrowFactor: 1.5,
+  maxRetries: 2
+};
+var StreamableHTTPError = class extends Error {
+  constructor(code, message) {
+    super(`Streamable HTTP error: ${message}`);
+    this.code = code;
+  }
+};
+var StreamableHTTPClientTransport = class {
+  constructor(url2, opts) {
+    this._hasCompletedAuthFlow = false;
+    this._url = url2;
+    this._resourceMetadataUrl = void 0;
+    this._scope = void 0;
+    this._requestInit = opts?.requestInit;
+    this._authProvider = opts?.authProvider;
+    this._fetch = opts?.fetch;
+    this._fetchWithInit = createFetchWithInit(opts?.fetch, opts?.requestInit);
+    this._sessionId = opts?.sessionId;
+    this._reconnectionOptions = opts?.reconnectionOptions ?? DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS;
+  }
+  async _authThenStart() {
+    if (!this._authProvider) {
+      throw new UnauthorizedError("No auth provider");
+    }
+    let result;
+    try {
+      result = await auth(this._authProvider, {
+        serverUrl: this._url,
+        resourceMetadataUrl: this._resourceMetadataUrl,
+        scope: this._scope,
+        fetchFn: this._fetchWithInit
+      });
+    } catch (error51) {
+      this.onerror?.(error51);
+      throw error51;
+    }
+    if (result !== "AUTHORIZED") {
+      throw new UnauthorizedError();
+    }
+    return await this._startOrAuthSse({ resumptionToken: void 0 });
+  }
+  async _commonHeaders() {
+    const headers = {};
+    if (this._authProvider) {
+      const tokens = await this._authProvider.tokens();
+      if (tokens) {
+        headers["Authorization"] = `Bearer ${tokens.access_token}`;
+      }
+    }
+    if (this._sessionId) {
+      headers["mcp-session-id"] = this._sessionId;
+    }
+    if (this._protocolVersion) {
+      headers["mcp-protocol-version"] = this._protocolVersion;
+    }
+    const extraHeaders = normalizeHeaders(this._requestInit?.headers);
+    return new Headers({
+      ...headers,
+      ...extraHeaders
+    });
+  }
+  async _startOrAuthSse(options) {
+    const { resumptionToken } = options;
+    try {
+      const headers = await this._commonHeaders();
+      headers.set("Accept", "text/event-stream");
+      if (resumptionToken) {
+        headers.set("last-event-id", resumptionToken);
+      }
+      const response = await (this._fetch ?? fetch)(this._url, {
+        method: "GET",
+        headers,
+        signal: this._abortController?.signal
+      });
+      if (!response.ok) {
+        await response.body?.cancel();
+        if (response.status === 401 && this._authProvider) {
+          return await this._authThenStart();
+        }
+        if (response.status === 405) {
+          return;
+        }
+        throw new StreamableHTTPError(response.status, `Failed to open SSE stream: ${response.statusText}`);
+      }
+      this._handleSseStream(response.body, options, true);
+    } catch (error51) {
+      this.onerror?.(error51);
+      throw error51;
+    }
+  }
+  /**
+   * Calculates the next reconnection delay using  backoff algorithm
+   *
+   * @param attempt Current reconnection attempt count for the specific stream
+   * @returns Time to wait in milliseconds before next reconnection attempt
+   */
+  _getNextReconnectionDelay(attempt) {
+    if (this._serverRetryMs !== void 0) {
+      return this._serverRetryMs;
+    }
+    const initialDelay = this._reconnectionOptions.initialReconnectionDelay;
+    const growFactor = this._reconnectionOptions.reconnectionDelayGrowFactor;
+    const maxDelay = this._reconnectionOptions.maxReconnectionDelay;
+    return Math.min(initialDelay * Math.pow(growFactor, attempt), maxDelay);
+  }
+  /**
+   * Schedule a reconnection attempt using server-provided retry interval or backoff
+   *
+   * @param lastEventId The ID of the last received event for resumability
+   * @param attemptCount Current reconnection attempt count for this specific stream
+   */
+  _scheduleReconnection(options, attemptCount = 0) {
+    const maxRetries = this._reconnectionOptions.maxRetries;
+    if (attemptCount >= maxRetries) {
+      this.onerror?.(new Error(`Maximum reconnection attempts (${maxRetries}) exceeded.`));
+      return;
+    }
+    const delay = this._getNextReconnectionDelay(attemptCount);
+    this._reconnectionTimeout = setTimeout(() => {
+      this._startOrAuthSse(options).catch((error51) => {
+        this.onerror?.(new Error(`Failed to reconnect SSE stream: ${error51 instanceof Error ? error51.message : String(error51)}`));
+        this._scheduleReconnection(options, attemptCount + 1);
+      });
+    }, delay);
+  }
+  _handleSseStream(stream, options, isReconnectable) {
+    if (!stream) {
+      return;
+    }
+    const { onresumptiontoken, replayMessageId } = options;
+    let lastEventId;
+    let hasPrimingEvent = false;
+    let receivedResponse = false;
+    const processStream = async () => {
+      try {
+        const reader = stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream({
+          onRetry: (retryMs) => {
+            this._serverRetryMs = retryMs;
+          }
+        })).getReader();
+        while (true) {
+          const { value: event, done } = await reader.read();
+          if (done) {
+            break;
+          }
+          if (event.id) {
+            lastEventId = event.id;
+            hasPrimingEvent = true;
+            onresumptiontoken?.(event.id);
+          }
+          if (!event.data) {
+            continue;
+          }
+          if (!event.event || event.event === "message") {
+            try {
+              const message = JSONRPCMessageSchema.parse(JSON.parse(event.data));
+              if (isJSONRPCResultResponse(message)) {
+                receivedResponse = true;
+                if (replayMessageId !== void 0) {
+                  message.id = replayMessageId;
+                }
+              }
+              this.onmessage?.(message);
+            } catch (error51) {
+              this.onerror?.(error51);
+            }
+          }
+        }
+        const canResume = isReconnectable || hasPrimingEvent;
+        const needsReconnect = canResume && !receivedResponse;
+        if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
+          this._scheduleReconnection({
+            resumptionToken: lastEventId,
+            onresumptiontoken,
+            replayMessageId
+          }, 0);
+        }
+      } catch (error51) {
+        this.onerror?.(new Error(`SSE stream disconnected: ${error51}`));
+        const canResume = isReconnectable || hasPrimingEvent;
+        const needsReconnect = canResume && !receivedResponse;
+        if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
+          try {
+            this._scheduleReconnection({
+              resumptionToken: lastEventId,
+              onresumptiontoken,
+              replayMessageId
+            }, 0);
+          } catch (error52) {
+            this.onerror?.(new Error(`Failed to reconnect: ${error52 instanceof Error ? error52.message : String(error52)}`));
+          }
+        }
+      }
+    };
+    processStream();
+  }
+  async start() {
+    if (this._abortController) {
+      throw new Error("StreamableHTTPClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+    }
+    this._abortController = new AbortController();
+  }
+  /**
+   * Call this method after the user has finished authorizing via their user agent and is redirected back to the MCP client application. This will exchange the authorization code for an access token, enabling the next connection attempt to successfully auth.
+   */
+  async finishAuth(authorizationCode) {
+    if (!this._authProvider) {
+      throw new UnauthorizedError("No auth provider");
+    }
+    const result = await auth(this._authProvider, {
+      serverUrl: this._url,
+      authorizationCode,
+      resourceMetadataUrl: this._resourceMetadataUrl,
+      scope: this._scope,
+      fetchFn: this._fetchWithInit
+    });
+    if (result !== "AUTHORIZED") {
+      throw new UnauthorizedError("Failed to authorize");
+    }
+  }
+  async close() {
+    if (this._reconnectionTimeout) {
+      clearTimeout(this._reconnectionTimeout);
+      this._reconnectionTimeout = void 0;
+    }
+    this._abortController?.abort();
+    this.onclose?.();
+  }
+  async send(message, options) {
+    try {
+      const { resumptionToken, onresumptiontoken } = options || {};
+      if (resumptionToken) {
+        this._startOrAuthSse({ resumptionToken, replayMessageId: isJSONRPCRequest(message) ? message.id : void 0 }).catch((err) => this.onerror?.(err));
+        return;
+      }
+      const headers = await this._commonHeaders();
+      headers.set("content-type", "application/json");
+      headers.set("accept", "application/json, text/event-stream");
+      const init = {
+        ...this._requestInit,
+        method: "POST",
+        headers,
+        body: JSON.stringify(message),
+        signal: this._abortController?.signal
+      };
+      const response = await (this._fetch ?? fetch)(this._url, init);
+      const sessionId = response.headers.get("mcp-session-id");
+      if (sessionId) {
+        this._sessionId = sessionId;
+      }
+      if (!response.ok) {
+        const text = await response.text().catch(() => null);
+        if (response.status === 401 && this._authProvider) {
+          if (this._hasCompletedAuthFlow) {
+            throw new StreamableHTTPError(401, "Server returned 401 after successful authentication");
+          }
+          const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
+          this._resourceMetadataUrl = resourceMetadataUrl;
+          this._scope = scope;
+          const result = await auth(this._authProvider, {
+            serverUrl: this._url,
+            resourceMetadataUrl: this._resourceMetadataUrl,
+            scope: this._scope,
+            fetchFn: this._fetchWithInit
+          });
+          if (result !== "AUTHORIZED") {
+            throw new UnauthorizedError();
+          }
+          this._hasCompletedAuthFlow = true;
+          return this.send(message);
+        }
+        if (response.status === 403 && this._authProvider) {
+          const { resourceMetadataUrl, scope, error: error51 } = extractWWWAuthenticateParams(response);
+          if (error51 === "insufficient_scope") {
+            const wwwAuthHeader = response.headers.get("WWW-Authenticate");
+            if (this._lastUpscopingHeader === wwwAuthHeader) {
+              throw new StreamableHTTPError(403, "Server returned 403 after trying upscoping");
+            }
+            if (scope) {
+              this._scope = scope;
+            }
+            if (resourceMetadataUrl) {
+              this._resourceMetadataUrl = resourceMetadataUrl;
+            }
+            this._lastUpscopingHeader = wwwAuthHeader ?? void 0;
+            const result = await auth(this._authProvider, {
+              serverUrl: this._url,
+              resourceMetadataUrl: this._resourceMetadataUrl,
+              scope: this._scope,
+              fetchFn: this._fetch
+            });
+            if (result !== "AUTHORIZED") {
+              throw new UnauthorizedError();
+            }
+            return this.send(message);
+          }
+        }
+        throw new StreamableHTTPError(response.status, `Error POSTing to endpoint: ${text}`);
+      }
+      this._hasCompletedAuthFlow = false;
+      this._lastUpscopingHeader = void 0;
+      if (response.status === 202) {
+        await response.body?.cancel();
+        if (isInitializedNotification(message)) {
+          this._startOrAuthSse({ resumptionToken: void 0 }).catch((err) => this.onerror?.(err));
+        }
+        return;
+      }
+      const messages = Array.isArray(message) ? message : [message];
+      const hasRequests = messages.filter((msg) => "method" in msg && "id" in msg && msg.id !== void 0).length > 0;
+      const contentType = response.headers.get("content-type");
+      if (hasRequests) {
+        if (contentType?.includes("text/event-stream")) {
+          this._handleSseStream(response.body, { onresumptiontoken }, false);
+        } else if (contentType?.includes("application/json")) {
+          const data = await response.json();
+          const responseMessages = Array.isArray(data) ? data.map((msg) => JSONRPCMessageSchema.parse(msg)) : [JSONRPCMessageSchema.parse(data)];
+          for (const msg of responseMessages) {
+            this.onmessage?.(msg);
+          }
+        } else {
+          await response.body?.cancel();
+          throw new StreamableHTTPError(-1, `Unexpected content type: ${contentType}`);
+        }
+      } else {
+        await response.body?.cancel();
+      }
+    } catch (error51) {
+      this.onerror?.(error51);
+      throw error51;
+    }
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  /**
+   * Terminates the current session by sending a DELETE request to the server.
+   *
+   * Clients that no longer need a particular session
+   * (e.g., because the user is leaving the client application) SHOULD send an
+   * HTTP DELETE to the MCP endpoint with the Mcp-Session-Id header to explicitly
+   * terminate the session.
+   *
+   * The server MAY respond with HTTP 405 Method Not Allowed, indicating that
+   * the server does not allow clients to terminate sessions.
+   */
+  async terminateSession() {
+    if (!this._sessionId) {
+      return;
+    }
+    try {
+      const headers = await this._commonHeaders();
+      const init = {
+        ...this._requestInit,
+        method: "DELETE",
+        headers,
+        signal: this._abortController?.signal
+      };
+      const response = await (this._fetch ?? fetch)(this._url, init);
+      await response.body?.cancel();
+      if (!response.ok && response.status !== 405) {
+        throw new StreamableHTTPError(response.status, `Failed to terminate session: ${response.statusText}`);
+      }
+      this._sessionId = void 0;
+    } catch (error51) {
+      this.onerror?.(error51);
+      throw error51;
+    }
+  }
+  setProtocolVersion(version2) {
+    this._protocolVersion = version2;
+  }
+  get protocolVersion() {
+    return this._protocolVersion;
+  }
+  /**
+   * Resume an SSE stream from a previous event ID.
+   * Opens a GET SSE connection with Last-Event-ID header to replay missed events.
+   *
+   * @param lastEventId The event ID to resume from
+   * @param options Optional callback to receive new resumption tokens
+   */
+  async resumeStream(lastEventId, options) {
+    await this._startOrAuthSse({
+      resumptionToken: lastEventId,
+      onresumptiontoken: options?.onresumptiontoken
+    });
+  }
+};
+
 // src/mcp_server.ts
-var import_promises4 = require("node:fs/promises");
+var import_promises5 = require("node:fs/promises");
 var import_node_os3 = require("node:os");
-var import_node_path4 = require("node:path");
+var import_node_path5 = require("node:path");
 
 // src/constants.ts
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 1933;
 var DEFAULT_ACCOUNT = "local";
 var DEFAULT_AGENT_ID = "threadnote";
 
+// src/index_repair.ts
+var import_promises3 = require("node:fs/promises");
+var import_node_path2 = require("node:path");
+
 // src/manifest.ts
 var import_promises2 = require("node:fs/promises");
 
@@ -33688,15 +35824,11 @@ async function maybeRun(dryRun, executable, args, options = {}) {
 }
 async function runCommand(executable, args, options = {}) {
   return new Promise((resolvePromise, rejectPromise) => {
-    const child = (0, import_node_child_process.spawn)(executable, args, { cwd: options.cwd });
-    const stdoutChunks = [];
-    const stderrChunks = [];
     const maxOutputBytes = options.maxOutputBytes ?? defaultCommandMaxOutputBytes();
-    let stdoutBytes = 0;
-    let stderrBytes = 0;
     let finished = false;
-    let failureResult;
     let killTimer;
+    let killEscalationTimer;
+    let failureMessage;
     let sentTerminationSignal = false;
     const timeoutMs = options.timeoutMs ?? defaultCommandTimeoutMs();
     const finish = (result) => {
@@ -33707,22 +35839,47 @@ async function runCommand(executable, args, options = {}) {
       if (killTimer) {
         clearTimeout(killTimer);
       }
+      if (killEscalationTimer) {
+        clearTimeout(killEscalationTimer);
+      }
       if (result.exitCode !== 0 && options.allowFailure !== true) {
         rejectPromise(new Error(`${formatShellCommand(executable, args)} failed: ${result.stderr || result.stdout}`));
         return;
       }
       resolvePromise(result);
     };
+    const child = (0, import_node_child_process.execFile)(
+      executable,
+      [...args],
+      {
+        cwd: options.cwd,
+        encoding: "utf8",
+        maxBuffer: maxOutputBytes
+      },
+      (err, stdout2, stderr) => {
+        finish(
+          commandResultFromExecFileCallback({
+            args,
+            err,
+            executable,
+            failureMessage,
+            maxOutputBytes,
+            stderr,
+            stdout: stdout2
+          })
+        );
+      }
+    );
     const failAndKill = (message) => {
-      if (failureResult) {
+      if (failureMessage) {
         return;
       }
-      failureResult = { exitCode: 124, stderr: message, stdout: stdoutChunks.join("") };
+      failureMessage = message;
       if (!sentTerminationSignal) {
         sentTerminationSignal = true;
         child.kill("SIGTERM");
       }
-      setTimeout(() => {
+      killEscalationTimer = setTimeout(() => {
         if (!finished) {
           child.kill("SIGKILL");
         }
@@ -33734,54 +35891,20 @@ async function runCommand(executable, args, options = {}) {
       }, timeoutMs);
       killTimer.unref?.();
     }
-    child.stdout.on("data", (chunk) => {
-      if (failureResult) {
-        return;
-      }
-      const text = String(chunk);
-      stdoutBytes += Buffer.byteLength(text);
-      if (stdoutBytes + stderrBytes > maxOutputBytes) {
-        failAndKill(`${formatShellCommand(executable, args)} exceeded output limit of ${maxOutputBytes} bytes`);
-        return;
-      }
-      stdoutChunks.push(text);
-    });
-    child.stderr.on("data", (chunk) => {
-      if (failureResult) {
-        return;
-      }
-      const text = String(chunk);
-      stderrBytes += Buffer.byteLength(text);
-      if (stdoutBytes + stderrBytes > maxOutputBytes) {
-        failAndKill(`${formatShellCommand(executable, args)} exceeded output limit of ${maxOutputBytes} bytes`);
-        return;
-      }
-      stderrChunks.push(text);
-    });
-    child.on("error", (err) => {
-      if (finished) {
-        return;
-      }
-      if (killTimer) {
-        clearTimeout(killTimer);
-      }
-      if (options.allowFailure === true) {
-        finish({ exitCode: 127, stderr: errorMessage(err), stdout: "" });
-      } else {
-        finished = true;
-        rejectPromise(err);
-      }
-    });
-    child.on("close", (code) => {
-      const result = failureResult ?? {
-        exitCode: code ?? 1,
-        stderr: stderrChunks.join(""),
-        stdout: stdoutChunks.join("")
-      };
-      finish(result);
-    });
   });
 }
+function commandResultFromExecFileCallback(params) {
+  if (params.failureMessage) {
+    return { exitCode: 124, stderr: params.failureMessage, stdout: params.stdout };
+  }
+  if (!params.err) {
+    return { exitCode: 0, stderr: params.stderr, stdout: params.stdout };
+  }
+  const error51 = params.err;
+  const exitCode = typeof error51.code === "number" ? error51.code : error51.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" ? 124 : 127;
+  const stderr = error51.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" ? `${formatShellCommand(params.executable, params.args)} exceeded output limit of ${params.maxOutputBytes} bytes` : params.stderr || errorMessage(error51);
+  return { exitCode, stderr, stdout: params.stdout };
+}
 function defaultCommandTimeoutMs() {
   return positiveIntegerFromEnv("THREADNOTE_COMMAND_TIMEOUT_MS") ?? 10 * 60 * 1e3;
 }
@@ -33808,6 +35931,13 @@ async function sleep(ms) {
     setTimeout(resolvePromise, ms);
   });
 }
+async function ensureDirectory(path, dryRun) {
+  if (dryRun) {
+    console.log(`Would create directory: ${path}`);
+    return;
+  }
+  await (0, import_promises.mkdir)(path, { recursive: true });
+}
 async function exists(path) {
   try {
     await (0, import_promises.access)(path);
@@ -33830,6 +35960,13 @@ async function readFileIfExists(path) {
     return void 0;
   }
 }
+function parsePort(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
+    throw new Error(`Invalid port: ${value}`);
+  }
+  return parsed;
+}
 function expandPath(path) {
   if (path === "~") {
     return (0, import_node_os.homedir)();
@@ -33893,6 +36030,9 @@ function uniqueUsefulWorkspaceTerms(values) {
   }
   return terms;
 }
+function toPosixPath(path) {
+  return path.split(import_node_path.sep).join("/");
+}
 function trimTrailingSlash(value) {
   return value.endsWith("/") ? value.slice(0, -1) : value;
 }
@@ -34043,8 +36183,262 @@ function readStringArray(object3, key) {
   return value;
 }
 
+// src/runtime.ts
+function withIdentity(config2, args) {
+  return [...args, "--account", config2.account, "--user", config2.user, "--agent-id", config2.agentId];
+}
+
+// src/index_repair.ts
+var AUTO_REPAIR_STATE_FILE = "index-auto-repair.json";
+var AUTO_REPAIR_TTL_MS = 6 * 60 * 60 * 1e3;
+var MAX_SCAN_DEPTH = 5;
+var MAX_REPAIR_TARGETS = 4;
+async function repairStaleRecallIndex(config2, ov, options = {}) {
+  options.onProgress?.({ type: "scan-start" });
+  const targets = await findStaleRecallIndexTargets(config2, options);
+  const repairTargets = targets.slice(0, options.maxTargets ?? MAX_REPAIR_TARGETS);
+  options.onProgress?.({
+    repairTargetCount: repairTargets.length,
+    totalTargets: targets.length,
+    type: "scan-complete"
+  });
+  if (targets.length === 0) {
+    return { repairedUris: [], skippedRecentUris: [], warnings: [] };
+  }
+  const state = options.dryRun === true ? { entries: {}, version: 1 } : await readAutoRepairState(config2);
+  const now = Date.now();
+  const repairedUris = [];
+  const skippedRecentUris = [];
+  const warnings = [];
+  for (const [targetIndex, target] of repairTargets.entries()) {
+    const progressBase = { index: targetIndex + 1, target, total: repairTargets.length };
+    const previous = state.entries[target.uri];
+    if (previous?.signature === target.signature && now - Date.parse(previous.repairedAt) < AUTO_REPAIR_TTL_MS && options.dryRun !== true && options.ignoreBackoff !== true) {
+      options.onProgress?.({ ...progressBase, type: "repair-skip-recent" });
+      skippedRecentUris.push(target.uri);
+      continue;
+    }
+    if (options.dryRun === true) {
+      options.onProgress?.({ ...progressBase, type: "repair-dry-run" });
+      repairedUris.push(target.uri);
+      continue;
+    }
+    options.onProgress?.({ ...progressBase, type: "repair-start" });
+    const result = await runCommand(
+      ov,
+      withIdentity(config2, ["reindex", target.uri, "--mode", "semantic_and_vectors", "--wait", "true"]),
+      { allowFailure: true }
+    );
+    if (result.exitCode === 0) {
+      repairedUris.push(target.uri);
+      state.entries[target.uri] = { repairedAt: new Date(now).toISOString(), signature: target.signature };
+    } else {
+      warnings.push(indexRepairWarning(target.uri, result));
+      await options.onRepairFailure?.(target, result);
+    }
+  }
+  if (options.dryRun !== true && repairedUris.length > 0) {
+    await writeAutoRepairState(config2, state);
+  }
+  return { repairedUris, skippedRecentUris, warnings };
+}
+async function findStaleRecallIndexTargets(config2, options = {}) {
+  const roots = await scanRoots(config2, options);
+  const byUri = /* @__PURE__ */ new Map();
+  for (const root of roots) {
+    if (!await exists(root.path)) {
+      continue;
+    }
+    const sidecars = await staleSidecars(root.path, root.uri);
+    if (options.collapseToRoots === true) {
+      for (const sidecar of sidecars) {
+        const uri = collapseStaleSidecarUri(root.uri, sidecar.relativePath, options.collapseDepth);
+        const current = byUri.get(uri) ?? { parts: [], staleCount: 0, uri };
+        current.parts.push(`${sidecar.relativePath}
+${sidecar.content}`);
+        current.staleCount += 1;
+        byUri.set(uri, current);
+      }
+      continue;
+    }
+    for (const sidecar of sidecars) {
+      const current = byUri.get(sidecar.uri) ?? { parts: [], staleCount: 0, uri: sidecar.uri };
+      current.parts.push(`${sidecar.relativePath}
+${sidecar.content}`);
+      current.staleCount += 1;
+      byUri.set(sidecar.uri, current);
+    }
+  }
+  return [...byUri.values()].map((target) => ({
+    signature: sha256([target.uri, ...target.parts.sort()].join("\n---\n")),
+    staleCount: target.staleCount,
+    uri: target.uri
+  }));
+}
+function collapseStaleSidecarUri(rootUri, relativePath, depth = 0) {
+  const normalizedRootUri = trimLocalRootUri(rootUri);
+  if (depth <= 0) {
+    return normalizedRootUri;
+  }
+  const parentParts = relativePath.split("/").slice(0, -1);
+  const collapsedParts = parentParts.slice(0, depth);
+  return collapsedParts.length === 0 ? normalizedRootUri : `${normalizedRootUri}/${collapsedParts.join("/")}`;
+}
+function formatRecallIndexRepairMessages(result, options = {}) {
+  const messages = [];
+  const maxUris = options.maxUris ?? result.repairedUris.length;
+  for (const uri of result.repairedUris.slice(0, maxUris)) {
+    messages.push(
+      `${options.dryRun === true ? "Would auto-reindex stale recall scope" : "Auto-reindexed stale recall scope"}: ${uri}`
+    );
+  }
+  const hiddenUriCount = result.repairedUris.length - maxUris;
+  if (hiddenUriCount > 0) {
+    messages.push(
+      options.dryRun === true ? `Would auto-reindex ${hiddenUriCount} more stale recall scope(s).` : `Auto-reindexed ${hiddenUriCount} more stale recall scope(s).`
+    );
+  }
+  for (const warning2 of result.warnings) {
+    messages.push(`Auto-index repair warning: ${warning2}`);
+  }
+  return messages;
+}
+function filterStaleRecallSummaryRows(output) {
+  return output.split(/\r?\n/).filter((line) => !isStaleRecallSummaryRow(line)).join("\n").trim();
+}
+function isStaleRecallSummaryRow(line) {
+  return /viking:\/\/\S+\/\.(?:abstract|overview)\.md\b/.test(line) && isStaleSummary(line);
+}
+async function scanRoots(config2, options) {
+  const accountRoot = (0, import_node_path2.join)(config2.agentContextHome, "data", "viking", config2.account);
+  const roots = [
+    {
+      path: (0, import_node_path2.join)(accountRoot, "user", uriSegment(config2.user), "memories"),
+      uri: `viking://user/${uriSegment(config2.user)}/memories`
+    }
+  ];
+  const query = options.query;
+  if (query) {
+    const project = await inferProjectFromQuery(config2.manifestPath, query);
+    const projectPath = project?.uri.startsWith("viking://resources/") ? (0, import_node_path2.join)(accountRoot, "resources", ...project.uri.slice("viking://resources/".length).split("/")) : void 0;
+    if (project && projectPath) {
+      roots.push({ path: projectPath, uri: project.uri });
+    }
+  }
+  if (options.includeManifestResources === true) {
+    roots.push(...await manifestResourceRoots(config2, accountRoot));
+  }
+  const scanAgentSkills = options.includeAgentSkills === true || (query ? /\bskills?\b/.test(query.toLowerCase()) : false);
+  if (scanAgentSkills) {
+    roots.push({ path: (0, import_node_path2.join)(accountRoot, "resources", "agent-skills"), uri: "viking://resources/agent-skills" });
+  }
+  return dedupeRoots(roots);
+}
+async function manifestResourceRoots(config2, accountRoot) {
+  try {
+    const manifest = await readSeedManifest(config2.manifestPath);
+    return manifest.projects.filter((project) => project.uri.startsWith("viking://resources/")).map((project) => ({
+      path: (0, import_node_path2.join)(accountRoot, "resources", ...project.uri.slice("viking://resources/".length).split("/")),
+      uri: project.uri
+    }));
+  } catch (_err) {
+    return [];
+  }
+}
+function dedupeRoots(roots) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const root of roots) {
+    if (seen.has(root.uri)) {
+      continue;
+    }
+    seen.add(root.uri);
+    deduped.push(root);
+  }
+  return deduped;
+}
+async function staleSidecars(rootPath, rootUri) {
+  const results = [];
+  async function visit(path, depth) {
+    let entries;
+    try {
+      entries = await (0, import_promises3.readdir)(path, { withFileTypes: true });
+    } catch (_err) {
+      return;
+    }
+    for (const entry of entries) {
+      const childPath = (0, import_node_path2.join)(path, entry.name);
+      if (entry.isFile() && isSummarySidecar(entry.name)) {
+        let content;
+        try {
+          content = await (0, import_promises3.readFile)(childPath, "utf8");
+        } catch (_err) {
+          continue;
+        }
+        if (!isStaleSummary(content)) {
+          continue;
+        }
+        const parentPath = (0, import_node_path2.dirname)(childPath);
+        const parentRelative = toPosixPath((0, import_node_path2.relative)(rootPath, parentPath));
+        const relativePath = toPosixPath((0, import_node_path2.relative)(rootPath, childPath));
+        results.push({
+          content: content.trim(),
+          relativePath,
+          uri: parentRelative ? `${trimLocalRootUri(rootUri)}/${parentRelative}` : trimLocalRootUri(rootUri)
+        });
+      } else if (entry.isDirectory() && depth < MAX_SCAN_DEPTH) {
+        await visit(childPath, depth + 1);
+      }
+    }
+  }
+  await visit(rootPath, 0);
+  return results;
+}
+function isSummarySidecar(name) {
+  return name === ".abstract.md" || name === ".overview.md";
+}
+function isStaleSummary(content) {
+  return content.includes("[Directory overview is not ready]") || content.includes("[Directory abstract is not ready]");
+}
+function trimLocalRootUri(uri) {
+  return uri.endsWith("/") ? uri.slice(0, -1) : uri;
+}
+async function readAutoRepairState(config2) {
+  const raw = await readFileIfExists(autoRepairStatePath(config2));
+  if (!raw) {
+    return { entries: {}, version: 1 };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isJsonObject(parsed) || parsed.version !== 1 || !isJsonObject(parsed.entries)) {
+      return { entries: {}, version: 1 };
+    }
+    const entries = {};
+    for (const [uri, entry] of Object.entries(parsed.entries)) {
+      if (isJsonObject(entry) && typeof entry.signature === "string" && typeof entry.repairedAt === "string") {
+        entries[uri] = { repairedAt: entry.repairedAt, signature: entry.signature };
+      }
+    }
+    return { entries, version: 1 };
+  } catch (_err) {
+    return { entries: {}, version: 1 };
+  }
+}
+async function writeAutoRepairState(config2, state) {
+  const path = autoRepairStatePath(config2);
+  await ensureDirectory((0, import_node_path2.dirname)(path), false);
+  await (0, import_promises3.writeFile)(path, `${JSON.stringify(state, void 0, 2)}
+`, { encoding: "utf8", mode: 384 });
+}
+function autoRepairStatePath(config2) {
+  return (0, import_node_path2.join)(config2.agentContextHome, AUTO_REPAIR_STATE_FILE);
+}
+function indexRepairWarning(uri, result) {
+  return `${uri}: ${result.stderr.trim() || result.stdout.trim() || "reindex failed"}`;
+}
+
 // src/memory_hygiene.ts
-var import_node_path2 = require("node:path");
+var import_node_path3 = require("node:path");
 var HYGIENE_SOURCES_HEADING = "## Threadnote Hygiene Sources";
 var STALE_HANDOFF_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
 function parseMemoryDocument(uri, content) {
@@ -34327,7 +36721,7 @@ function branchFromBody(body) {
   return branch?.split(/\s+/)[0]?.replace(/[.,;:]+$/g, "");
 }
 function topicFromUri(uri) {
-  const name = (0, import_node_path2.basename)(uri).replace(/\.md$/, "");
+  const name = (0, import_node_path3.basename)(uri).replace(/\.md$/, "");
   return name.startsWith("threadnote-") ? void 0 : name;
 }
 function parseProjectFromUri(uri) {
@@ -34357,7 +36751,7 @@ function preferredKeepRecord(records, topic) {
 }
 function isStableRecord(record2, topic) {
   const recordTopic = topic ?? topicForRecord(record2);
-  return recordTopic !== void 0 && (0, import_node_path2.basename)(record2.uri) === `${uriSegment(recordTopic)}.md`;
+  return recordTopic !== void 0 && (0, import_node_path3.basename)(record2.uri) === `${uriSegment(recordTopic)}.md`;
 }
 function sortedNewestFirst(records) {
   return [...records].sort((left, right) => {
@@ -34469,16 +36863,9 @@ function formatPlanSection(title, lines) {
 }
 
 // src/share.ts
-var import_promises3 = require("node:fs/promises");
+var import_promises4 = require("node:fs/promises");
 var import_node_os2 = require("node:os");
-var import_node_path3 = require("node:path");
-
-// src/runtime.ts
-function withIdentity(config2, args) {
-  return [...args, "--account", config2.account, "--user", config2.user, "--agent-id", config2.agentId];
-}
-
-// src/share.ts
+var import_node_path4 = require("node:path");
 var TEAMS_FILE_VERSION = 1;
 var SHARED_SEGMENT = "shared";
 var SHAREABLE_MEMORY_KIND_DIRS = ["durable"];
@@ -34585,7 +36972,7 @@ function autoShareState(config2) {
   return state;
 }
 function pendingReindexesPath(config2) {
-  return (0, import_node_path3.join)(config2.agentContextHome, "share", "auto-sync-pending-reindexes.json");
+  return (0, import_node_path4.join)(config2.agentContextHome, "share", "auto-sync-pending-reindexes.json");
 }
 async function loadPendingReindexes(config2, state) {
   const raw = await readFileIfExists(pendingReindexesPath(config2));
@@ -34622,18 +37009,18 @@ async function loadPendingReindexes(config2, state) {
 async function writePendingReindexes(config2, state) {
   const path = pendingReindexesPath(config2);
   if (state.pendingReindexes.size === 0) {
-    await (0, import_promises3.rm)(path, { force: true });
+    await (0, import_promises4.rm)(path, { force: true });
     return;
   }
   const contents = {
     teams: Object.fromEntries(state.pendingReindexes),
     version: 1
   };
-  await (0, import_promises3.mkdir)((0, import_node_path3.dirname)(path), { recursive: true });
+  await (0, import_promises4.mkdir)((0, import_node_path4.dirname)(path), { recursive: true });
   const tempPath = `${path}.${process.pid}.tmp`;
-  await (0, import_promises3.writeFile)(tempPath, `${JSON.stringify(contents, void 0, 2)}
+  await (0, import_promises4.writeFile)(tempPath, `${JSON.stringify(contents, void 0, 2)}
 `, { encoding: "utf8", mode: 384 });
-  await (0, import_promises3.rename)(tempPath, path);
+  await (0, import_promises4.rename)(tempPath, path);
 }
 async function refreshShareUpdateState(config2, options) {
   const state = autoShareState(config2);
@@ -34729,7 +37116,7 @@ async function runShareSyncQuiet(config2, state, options) {
   const beforeRev = await gitOutput(worktree, ["rev-parse", "HEAD"], false);
   const pullResult = await runCommand(git, ["-C", worktree, "rebase", "@{u}"], { allowFailure: true });
   if (pullResult.exitCode !== 0) {
-    if (await exists((0, import_node_path3.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path3.join)(team.config.gitdir, "rebase-apply"))) {
+    if (await exists((0, import_node_path4.join)(team.config.gitdir, "rebase-merge")) || await exists((0, import_node_path4.join)(team.config.gitdir, "rebase-apply"))) {
       throw new Error(
         `Automatic share sync hit git conflicts in ${worktree}. Resolve them in-place, run \`git -C ${worktree} rebase --continue\` (or --abort), then rerun recall/read.`
       );
@@ -34814,10 +37201,10 @@ function normalizeTeamName(input) {
   return candidate;
 }
 function teamsFilePath(config2) {
-  return (0, import_node_path3.join)(config2.agentContextHome, "share", "teams.json");
+  return (0, import_node_path4.join)(config2.agentContextHome, "share", "teams.json");
 }
 function teamWorktreePath(config2, team) {
-  return (0, import_node_path3.join)(
+  return (0, import_node_path4.join)(
     config2.agentContextHome,
     "data",
     "viking",
@@ -34830,7 +37217,7 @@ function teamWorktreePath(config2, team) {
   );
 }
 function teamGitdirPath(config2, team) {
-  return (0, import_node_path3.join)(config2.agentContextHome, "share", "teams", `${team}.gitdir`);
+  return (0, import_node_path4.join)(config2.agentContextHome, "share", "teams", `${team}.gitdir`);
 }
 async function readTeamsFile(config2) {
   const path = teamsFilePath(config2);
@@ -34886,7 +37273,7 @@ async function resolveTeam(config2, requested) {
   return { config: found, name: wantName };
 }
 function workfileToVikingUri(config2, team, filePath) {
-  const rel = (0, import_node_path3.relative)(team.worktree, filePath).split(import_node_path3.sep).join("/");
+  const rel = (0, import_node_path4.relative)(team.worktree, filePath).split(import_node_path4.sep).join("/");
   return `viking://user/${uriSegment(config2.user)}/memories/${SHARED_SEGMENT}/${team.name}/${rel}`;
 }
 function isInSharedNamespace(config2, uri) {
@@ -35011,13 +37398,14 @@ async function writeMemoryFile(config2, ov, uri, content, initialMode, dryRun, o
     }
     return;
   }
-  const stagingDir = await (0, import_promises3.mkdtemp)((0, import_node_path3.join)((0, import_node_os2.tmpdir)(), "threadnote-share-"));
-  const tempPath = (0, import_node_path3.join)(stagingDir, "body.txt");
+  const stagingDir = await (0, import_promises4.mkdtemp)((0, import_node_path4.join)((0, import_node_os2.tmpdir)(), "threadnote-share-"));
+  const tempPath = (0, import_node_path4.join)(stagingDir, "body.txt");
   try {
-    await (0, import_promises3.writeFile)(tempPath, content, { encoding: "utf8", mode: 384 });
+    await (0, import_promises4.writeFile)(tempPath, content, { encoding: "utf8", mode: 384 });
     await writeOvFileWithRetry(config2, ov, uri, tempPath, initialMode, options);
+    await refreshMemoryIndex(config2, ov, uri, options);
   } finally {
-    await (0, import_promises3.rm)(stagingDir, { force: true, recursive: true });
+    await (0, import_promises4.rm)(stagingDir, { force: true, recursive: true });
   }
 }
 var BUSY_RETRY_BACKOFF_MS = [2e3, 5e3, 1e4, 2e4, 3e4];
@@ -35072,6 +37460,27 @@ async function writeOvFileWithRetry(config2, ov, uri, fromFile, initialMode, opt
     }
   }
 }
+async function refreshMemoryIndex(config2, ov, uri, options = {}) {
+  const result = await runCommand(
+    ov,
+    withIdentity(config2, ["reindex", uri, "--mode", "semantic_and_vectors", "--wait", "true"]),
+    { allowFailure: true }
+  );
+  if (result.exitCode === 0) {
+    if (options.quiet !== true && result.stdout.trim()) {
+      console.log(result.stdout.trim());
+    }
+    if (options.quiet !== true && result.stderr.trim()) {
+      console.error(result.stderr.trim());
+    }
+    return;
+  }
+  if (options.quiet !== true) {
+    console.error(
+      `Memory stored, but index refresh failed for ${uri}: ${result.stderr.trim() || result.stdout.trim()}`
+    );
+  }
+}
 async function waitForOvQueue(ov, config2, options = {}) {
   const result = await runCommand(ov, withIdentity(config2, ["wait", "--timeout", "120"]), { allowFailure: true });
   if (options.quiet !== true && result.stdout.trim()) {
@@ -35092,7 +37501,7 @@ ${stdout2}`.toLowerCase();
   return output.includes("resource is busy") || output.includes("resource is being processed");
 }
 async function ingestSingleFile(ov, config2, uri, filePath, initialMode, options = {}) {
-  const content = await (0, import_promises3.readFile)(filePath, "utf8");
+  const content = await (0, import_promises4.readFile)(filePath, "utf8");
   await writeMemoryFile(config2, ov, uri, content, initialMode, false, options);
 }
 async function removeMemoryUri(config2, ov, uri, dryRun, options = {}) {
@@ -35157,8 +37566,8 @@ async function listChangedFiles(worktree, beforeRev, afterRev) {
       const oldRel = entries[index + 1];
       const newRel = entries[index + 2];
       if (oldRel && newRel) {
-        changes.push({ path: (0, import_node_path3.join)(worktree, oldRel), relativePath: oldRel, status: "removed" });
-        changes.push({ path: (0, import_node_path3.join)(worktree, newRel), relativePath: newRel, status: "added" });
+        changes.push({ path: (0, import_node_path4.join)(worktree, oldRel), relativePath: oldRel, status: "removed" });
+        changes.push({ path: (0, import_node_path4.join)(worktree, newRel), relativePath: newRel, status: "added" });
       }
       index += 3;
       continue;
@@ -35166,7 +37575,7 @@ async function listChangedFiles(worktree, beforeRev, afterRev) {
     const rel = entries[index + 1];
     if (rel) {
       const status = head === "A" ? "added" : head === "D" ? "removed" : "modified";
-      changes.push({ path: (0, import_node_path3.join)(worktree, rel), relativePath: rel, status });
+      changes.push({ path: (0, import_node_path4.join)(worktree, rel), relativePath: rel, status });
     }
     index += 2;
   }
@@ -35267,11 +37676,14 @@ async function main() {
   process.stderr.write("Threadnote local MCP adapter running\n");
 }
 function getRuntimeConfig() {
+  const host = process.env.THREADNOTE_HOST ?? DEFAULT_HOST;
+  const port = parsePort(process.env.THREADNOTE_PORT ?? String(DEFAULT_PORT));
   return {
     account: process.env.THREADNOTE_ACCOUNT ?? DEFAULT_ACCOUNT,
     agentContextHome: expandPath(process.env.THREADNOTE_HOME ?? "~/.openviking"),
     agentId: process.env.THREADNOTE_AGENT_ID ?? DEFAULT_AGENT_ID,
     manifestPath: expandPath(process.env.THREADNOTE_MANIFEST ?? "~/.openviking/seed-manifest.yaml"),
+    openVikingMcpUrl: process.env.THREADNOTE_OPENVIKING_MCP_URL ?? `http://${host}:${port}/mcp`,
     user: process.env.THREADNOTE_USER ?? process.env.USER ?? "unknown"
   };
 }
@@ -35318,29 +37730,16 @@ function registerTools(server, config2) {
       annotations: { readOnlyHint: false, destructiveHint: true },
       description: "Remove a viking:// URI from OpenViking.",
       inputSchema: {
+        recursive: external_exports.boolean().optional().describe("Remove a directory recursively"),
         uri: external_exports.string().optional().describe("Required viking:// URI to remove")
       }
     },
-    async ({ uri }) => {
+    async ({ recursive, uri }) => {
       const checkedUri = requiredVikingUri(uri, "forget", "viking://agent/threadnote/memories/example.md");
       if (!checkedUri.ok) {
         return checkedUri.error;
       }
-      try {
-        const ov = await requiredOpenVikingCli2();
-        const removed = await removeVikingResourceWithRetry(ov, config2, checkedUri.value);
-        return {
-          content: [
-            {
-              type: "text",
-              text: removed ? `Removed: ${checkedUri.value}` : `Resource is still being processed; retry later: ${checkedUri.value}`
-            }
-          ],
-          isError: !removed
-        };
-      } catch (err) {
-        return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
-      }
+      return runOpenVikingRemoveTool(config2, checkedUri.value, recursive === true);
     }
   );
   server.registerTool(
@@ -35349,31 +37748,26 @@ function registerTools(server, config2) {
       annotations: { readOnlyHint: false, destructiveHint: false },
       description: "Add a local file or directory to OpenViking as a resource.",
       inputSchema: {
+        description: external_exports.string().optional().describe("Optional import reason/description"),
+        path: external_exports.string().optional().describe("Local source file/directory or URL; native OpenViking MCP name"),
         sourcePath: external_exports.string().optional().describe("Required local source file or directory"),
-        to: external_exports.string().optional().describe("Required destination viking:// URI"),
-        wait: external_exports.boolean().optional().describe("Wait for processing to finish")
+        source_path: external_exports.string().optional().describe("Compatibility alias for path"),
+        tempFileId: external_exports.string().optional().describe("Native progressive upload temp file id"),
+        temp_file_id: external_exports.string().optional().describe("Native progressive upload temp file id"),
+        to: external_exports.string().optional().describe("Optional destination viking:// URI"),
+        wait: external_exports.boolean().optional().describe("Wait for processing to finish"),
+        watchInterval: external_exports.number().int().min(0).optional().describe("Watch interval in minutes"),
+        watch_interval: external_exports.number().int().min(0).optional().describe("Watch interval in minutes")
       }
     },
-    async ({ sourcePath, to, wait }) => {
-      const checkedSourcePath = requiredText(sourcePath, "add_resource", "sourcePath", {
-        sourcePath: "/path/to/README.md",
-        to: "viking://resource/my-repo/README.md"
-      });
-      if (!checkedSourcePath.ok) {
-        return checkedSourcePath.error;
-      }
-      const checkedTo = requiredVikingUri(to, "add_resource", "viking://resource/my-repo/README.md");
-      if (!checkedTo.ok) {
-        return checkedTo.error;
-      }
-      return runOpenVikingTool(config2, [
-        "add-resource",
-        checkedSourcePath.value,
-        "--to",
-        checkedTo.value,
-        ...wait === false ? [] : ["--wait"]
-      ]);
-    }
+    async (args) => runOpenVikingAddResourceTool(config2, "add_resource", {
+      description: args.description,
+      path: args.sourcePath ?? args.path ?? args.source_path,
+      tempFileId: args.tempFileId ?? args.temp_file_id,
+      to: args.to,
+      wait: args.wait,
+      watchInterval: args.watchInterval ?? args.watch_interval
+    })
   );
   server.registerTool(
     "grep",
@@ -35381,11 +37775,15 @@ function registerTools(server, config2) {
       annotations: { readOnlyHint: true, destructiveHint: false },
       description: "Run exact text search in OpenViking.",
       inputSchema: {
+        caseInsensitive: external_exports.boolean().optional().describe("Case-insensitive search"),
+        case_insensitive: external_exports.boolean().optional().describe("Case-insensitive search"),
+        nodeLimit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum result count"),
+        node_limit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum result count"),
         pattern: external_exports.string().optional().describe("Required text or regex pattern"),
         uri: external_exports.string().optional().describe("Optional viking:// subtree")
       }
     },
-    async ({ pattern, uri }) => {
+    async ({ caseInsensitive, case_insensitive, nodeLimit, node_limit, pattern, uri }) => {
       const checkedPattern = requiredText(pattern, "grep", "pattern", { pattern: "unity-ui-ccc" });
       if (!checkedPattern.ok) {
         return checkedPattern.error;
@@ -35394,11 +37792,12 @@ function registerTools(server, config2) {
       if (!checkedUri.ok) {
         return checkedUri.error;
       }
-      return runOpenVikingTool(config2, [
-        "grep",
-        checkedPattern.value,
-        ...checkedUri.value ? ["--uri", checkedUri.value] : []
-      ]);
+      return runOpenVikingMcpTool(config2, "grep", {
+        case_insensitive: caseInsensitive ?? case_insensitive,
+        node_limit: nodeLimit ?? node_limit,
+        pattern: checkedPattern.value,
+        uri: checkedUri.value
+      });
     }
   );
   server.registerTool(
@@ -35407,11 +37806,13 @@ function registerTools(server, config2) {
       annotations: { readOnlyHint: true, destructiveHint: false },
       description: "Run glob file search in OpenViking.",
       inputSchema: {
+        nodeLimit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum result count"),
+        node_limit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum result count"),
         pattern: external_exports.string().optional().describe("Required glob pattern"),
         uri: external_exports.string().optional().describe("Optional viking:// subtree")
       }
     },
-    async ({ pattern, uri }) => {
+    async ({ nodeLimit, node_limit, pattern, uri }) => {
       const checkedPattern = requiredText(pattern, "glob", "pattern", { pattern: "**/AGENTS.md" });
       if (!checkedPattern.ok) {
         return checkedPattern.error;
@@ -35420,11 +37821,11 @@ function registerTools(server, config2) {
       if (!checkedUri.ok) {
         return checkedUri.error;
       }
-      return runOpenVikingTool(config2, [
-        "glob",
-        checkedPattern.value,
-        ...checkedUri.value ? ["--uri", checkedUri.value] : []
-      ]);
+      return runOpenVikingMcpTool(config2, "glob", {
+        node_limit: nodeLimit ?? node_limit,
+        pattern: checkedPattern.value,
+        uri: checkedUri.value
+      });
     }
   );
   server.registerTool(
@@ -35434,8 +37835,9 @@ function registerTools(server, config2) {
       description: "Check OpenViking server health through the CLI.",
       inputSchema: {}
     },
-    async () => runOpenVikingTool(config2, ["health"])
+    async () => runOpenVikingMcpTool(config2, "health", {})
   );
+  registerOpenVikingParityTools(server, config2);
   server.registerTool(
     "share_publish",
     {
@@ -35465,6 +37867,341 @@ function registerTools(server, config2) {
     }
   );
 }
+function registerOpenVikingParityTools(server, config2) {
+  server.registerTool(
+    "ov_search",
+    {
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      description: "Raw OpenViking MCP search parity. Unlike search/recall_context, this does not enrich the query.",
+      inputSchema: {
+        limit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum result count"),
+        minScore: external_exports.number().min(0).max(1).optional().describe("Minimum score threshold"),
+        min_score: external_exports.number().min(0).max(1).optional().describe("Minimum score threshold"),
+        peerId: external_exports.string().optional().describe("Optional native peer id"),
+        peer_id: external_exports.string().optional().describe("Optional native peer id"),
+        query: external_exports.string().optional().describe("Required search query"),
+        sessionId: external_exports.string().optional().describe("Optional native session id"),
+        session_id: external_exports.string().optional().describe("Optional native session id"),
+        targetUri: external_exports.string().optional().describe("Optional target viking:// subtree"),
+        target_uri: external_exports.string().optional().describe("Optional target viking:// subtree"),
+        uri: external_exports.string().optional().describe("Compatibility alias for target_uri")
+      }
+    },
+    async ({ limit, minScore, min_score, query, sessionId, session_id, targetUri, target_uri, uri }) => {
+      const checkedQuery = requiredText(query, "ov_search", "query", { query: "current repo release notes" });
+      if (!checkedQuery.ok) {
+        return checkedQuery.error;
+      }
+      const checkedUri = optionalVikingUri(targetUri ?? target_uri ?? uri, "ov_search");
+      if (!checkedUri.ok) {
+        return checkedUri.error;
+      }
+      const normalizedSessionId = (sessionId ?? session_id)?.trim();
+      return runOpenVikingMcpTool(config2, "search", {
+        limit,
+        min_score: minScore ?? min_score,
+        query: checkedQuery.value,
+        session_id: normalizedSessionId || void 0,
+        target_uri: checkedUri.value
+      });
+    }
+  );
+  server.registerTool(
+    "ov_read",
+    {
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      description: "Raw OpenViking MCP read parity. Reads one or more viking:// URIs without Threadnote shared-memory sync.",
+      inputSchema: {
+        uri: external_exports.string().optional().describe("Single viking:// URI"),
+        uris: external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]).optional().describe("Single viking:// URI or array of URIs")
+      }
+    },
+    async ({ uri, uris }) => {
+      const checkedUris = requiredVikingUriList(
+        uris ?? uri,
+        "ov_read",
+        "viking://resources/repos/threadnote/README.md"
+      );
+      if (!checkedUris.ok) {
+        return checkedUris.error;
+      }
+      return runOpenVikingReadTool(config2, checkedUris.value);
+    }
+  );
+  server.registerTool(
+    "ov_list",
+    {
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      description: "Raw OpenViking MCP list parity.",
+      inputSchema: {
+        all: external_exports.boolean().optional().describe("Show hidden files like .abstract.md and .overview.md"),
+        nodeLimit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum node count"),
+        node_limit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum node count"),
+        recursive: external_exports.boolean().optional().describe("List recursively"),
+        simple: external_exports.boolean().optional().describe("Only return paths"),
+        uri: external_exports.string().optional().describe("Optional viking:// directory URI; defaults to viking://")
+      }
+    },
+    async ({ recursive, uri }) => {
+      const checkedUri = optionalVikingUri(uri, "ov_list");
+      if (!checkedUri.ok) {
+        return checkedUri.error;
+      }
+      return runOpenVikingMcpTool(config2, "list", {
+        recursive,
+        uri: checkedUri.value ?? "viking://"
+      });
+    }
+  );
+  registerOpenVikingStoreTool(server, config2, "ov_store");
+  registerOpenVikingStoreTool(server, config2, "ov_remember");
+  server.registerTool(
+    "ov_add_resource",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false },
+      description: "Raw OpenViking MCP add_resource parity.",
+      inputSchema: {
+        description: external_exports.string().optional().describe("Optional import reason/description"),
+        path: external_exports.string().optional().describe("Local source file/directory or URL"),
+        sourcePath: external_exports.string().optional().describe("Compatibility alias for path"),
+        source_path: external_exports.string().optional().describe("Compatibility alias for path"),
+        tempFileId: external_exports.string().optional().describe("Native progressive upload temp file id"),
+        temp_file_id: external_exports.string().optional().describe("Native progressive upload temp file id"),
+        to: external_exports.string().optional().describe("Optional destination viking:// URI"),
+        wait: external_exports.boolean().optional().describe("Wait for processing to finish"),
+        watchInterval: external_exports.number().int().min(0).optional().describe("Watch interval in minutes"),
+        watch_interval: external_exports.number().int().min(0).optional().describe("Watch interval in minutes")
+      }
+    },
+    async (args) => runOpenVikingAddResourceTool(config2, "ov_add_resource", {
+      description: args.description,
+      path: args.path ?? args.sourcePath ?? args.source_path,
+      tempFileId: args.tempFileId ?? args.temp_file_id,
+      to: args.to,
+      wait: args.wait,
+      watchInterval: args.watchInterval ?? args.watch_interval
+    })
+  );
+  server.registerTool(
+    "ov_list_watches",
+    {
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      description: "Raw OpenViking MCP list_watches parity.",
+      inputSchema: {
+        activeOnly: external_exports.boolean().optional().describe("Only show active watch tasks"),
+        active_only: external_exports.boolean().optional().describe("Only show active watch tasks")
+      }
+    },
+    async ({ activeOnly, active_only }) => runOpenVikingMcpTool(config2, "list_watches", { active_only: activeOnly ?? active_only })
+  );
+  server.registerTool(
+    "ov_cancel_watch",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      description: "Raw OpenViking MCP cancel_watch parity. Accepts to_uri, toUri, or uri.",
+      inputSchema: {
+        toUri: external_exports.string().optional().describe("Watch target viking:// URI"),
+        to_uri: external_exports.string().optional().describe("Watch target viking:// URI"),
+        uri: external_exports.string().optional().describe("Compatibility alias for to_uri")
+      }
+    },
+    async ({ toUri, to_uri, uri }) => {
+      const checkedUri = requiredVikingUri(
+        toUri ?? to_uri ?? uri,
+        "ov_cancel_watch",
+        "viking://resources/repos/threadnote"
+      );
+      if (!checkedUri.ok) {
+        return checkedUri.error;
+      }
+      return runOpenVikingMcpTool(config2, "cancel_watch", { to_uri: checkedUri.value });
+    }
+  );
+  server.registerTool(
+    "ov_grep",
+    {
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      description: "Raw OpenViking MCP grep parity.",
+      inputSchema: {
+        caseInsensitive: external_exports.boolean().optional().describe("Case-insensitive search"),
+        case_insensitive: external_exports.boolean().optional().describe("Case-insensitive search"),
+        nodeLimit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum result count"),
+        node_limit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum result count"),
+        pattern: external_exports.string().optional().describe("Required regex pattern"),
+        uri: external_exports.string().optional().describe("Optional viking:// subtree")
+      }
+    },
+    async ({ caseInsensitive, case_insensitive, nodeLimit, node_limit, pattern, uri }) => {
+      const checkedPattern = requiredText(pattern, "ov_grep", "pattern", { pattern: "threadnote" });
+      if (!checkedPattern.ok) {
+        return checkedPattern.error;
+      }
+      const checkedUri = optionalVikingUri(uri, "ov_grep");
+      if (!checkedUri.ok) {
+        return checkedUri.error;
+      }
+      return runOpenVikingMcpTool(config2, "grep", {
+        case_insensitive: caseInsensitive ?? case_insensitive,
+        node_limit: nodeLimit ?? node_limit,
+        pattern: checkedPattern.value,
+        uri: checkedUri.value
+      });
+    }
+  );
+  server.registerTool(
+    "ov_glob",
+    {
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      description: "Raw OpenViking MCP glob parity.",
+      inputSchema: {
+        nodeLimit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum result count"),
+        node_limit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum result count"),
+        pattern: external_exports.string().optional().describe("Required glob pattern"),
+        uri: external_exports.string().optional().describe("Optional viking:// subtree")
+      }
+    },
+    async ({ nodeLimit, node_limit, pattern, uri }) => {
+      const checkedPattern = requiredText(pattern, "ov_glob", "pattern", { pattern: "**/AGENTS.md" });
+      if (!checkedPattern.ok) {
+        return checkedPattern.error;
+      }
+      const checkedUri = optionalVikingUri(uri, "ov_glob");
+      if (!checkedUri.ok) {
+        return checkedUri.error;
+      }
+      return runOpenVikingMcpTool(config2, "glob", {
+        node_limit: nodeLimit ?? node_limit,
+        pattern: checkedPattern.value,
+        uri: checkedUri.value
+      });
+    }
+  );
+  server.registerTool(
+    "ov_forget",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      description: "Raw OpenViking MCP forget parity.",
+      inputSchema: {
+        recursive: external_exports.boolean().optional().describe("Remove a directory recursively"),
+        uri: external_exports.string().optional().describe("Required viking:// URI to remove")
+      }
+    },
+    async ({ recursive, uri }) => {
+      const checkedUri = requiredVikingUri(uri, "ov_forget", "viking://resources/repos/threadnote/tmp");
+      if (!checkedUri.ok) {
+        return checkedUri.error;
+      }
+      return runOpenVikingRemoveTool(config2, checkedUri.value, recursive === true);
+    }
+  );
+  server.registerTool(
+    "ov_code_outline",
+    {
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      description: "Raw OpenViking MCP code_outline parity. Requires a viking:// file URI.",
+      inputSchema: {
+        uri: external_exports.string().optional().describe("Required viking:// file URI")
+      }
+    },
+    async ({ uri }) => {
+      const checkedUri = requiredVikingUri(
+        uri,
+        "ov_code_outline",
+        "viking://resources/repos/threadnote/src/mcp_server.ts"
+      );
+      if (!checkedUri.ok) {
+        return checkedUri.error;
+      }
+      return runOpenVikingMcpTool(config2, "code_outline", { uri: checkedUri.value });
+    }
+  );
+  server.registerTool(
+    "ov_code_search",
+    {
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      description: "Raw OpenViking MCP code_search parity. Requires a query and viking:// directory URI.",
+      inputSchema: {
+        query: external_exports.string().optional().describe("Required symbol-name substring"),
+        uri: external_exports.string().optional().describe("Required viking:// directory URI")
+      }
+    },
+    async ({ query, uri }) => {
+      const checkedQuery = requiredText(query, "ov_code_search", "query", { query: "registerTools" });
+      if (!checkedQuery.ok) {
+        return checkedQuery.error;
+      }
+      const checkedUri = requiredVikingUri(uri, "ov_code_search", "viking://resources/repos/threadnote/src");
+      if (!checkedUri.ok) {
+        return checkedUri.error;
+      }
+      return runOpenVikingMcpTool(config2, "code_search", {
+        query: checkedQuery.value,
+        uri: checkedUri.value
+      });
+    }
+  );
+  server.registerTool(
+    "ov_code_expand",
+    {
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      description: "Raw OpenViking MCP code_expand parity. Requires a viking:// file URI and symbol.",
+      inputSchema: {
+        symbol: external_exports.string().optional().describe("Required symbol name, e.g. bar or Foo.bar"),
+        uri: external_exports.string().optional().describe("Required viking:// file URI")
+      }
+    },
+    async ({ symbol: symbol2, uri }) => {
+      const checkedUri = requiredVikingUri(
+        uri,
+        "ov_code_expand",
+        "viking://resources/repos/threadnote/src/mcp_server.ts"
+      );
+      if (!checkedUri.ok) {
+        return checkedUri.error;
+      }
+      const checkedSymbol = requiredText(symbol2, "ov_code_expand", "symbol", { symbol: "registerTools" });
+      if (!checkedSymbol.ok) {
+        return checkedSymbol.error;
+      }
+      return runOpenVikingMcpTool(config2, "code_expand", { symbol: checkedSymbol.value, uri: checkedUri.value });
+    }
+  );
+  server.registerTool(
+    "ov_health",
+    {
+      annotations: { readOnlyHint: true, destructiveHint: false },
+      description: "Raw OpenViking MCP health parity.",
+      inputSchema: {}
+    },
+    async () => runOpenVikingMcpTool(config2, "health", {})
+  );
+}
+function registerOpenVikingStoreTool(server, config2, name) {
+  server.registerTool(
+    name,
+    {
+      annotations: { readOnlyHint: false, destructiveHint: true },
+      description: `Raw OpenViking MCP ${name === "ov_remember" ? "remember" : "store"} parity. Stores message(s) through ov add-memory.`,
+      inputSchema: {
+        content: external_exports.string().optional().describe("Compatibility shortcut for a single user message"),
+        messages: external_exports.array(external_exports.object({ content: external_exports.string(), role: external_exports.string() })).optional().describe("Native messages array of {role, content}"),
+        text: external_exports.string().optional().describe("Compatibility shortcut for a single user message")
+      }
+    },
+    async ({ content, messages, text }) => {
+      if (messages && messages.length > 0) {
+        return runOpenVikingMcpTool(config2, "remember", { messages });
+      }
+      const checkedContent = requiredText(content ?? text, name, "content", { content: "Remember this note" });
+      if (!checkedContent.ok) {
+        return checkedContent.error;
+      }
+      return runOpenVikingMcpTool(config2, "remember", {
+        messages: [{ content: checkedContent.value, role: "user" }]
+      });
+    }
+  );
+}
 function registerSearchTool(server, config2, name, description) {
   server.registerTool(
     name,
@@ -35516,14 +38253,20 @@ async function runRecallTool(config2, params) {
     cwd: params.callerCwd,
     includeProcessCwd: false
   });
+  let indexRepairMessages;
+  try {
+    const ov = await requiredOpenVikingCli2();
+    const indexRepair = await repairStaleRecallIndex(config2, ov, { query: projectQuery });
+    indexRepairMessages = formatRecallIndexRepairMessages(indexRepair);
+  } catch (err) {
+    indexRepairMessages = [`Auto-index repair warning: ${errorMessage(err)}`];
+  }
   const contextualParams = { ...params, query };
-  const baseArgs = [
-    "search",
+  const semanticResult = await runOpenVikingMcpTool(config2, "search", {
+    limit: params.nodeLimit,
     query,
-    ...params.pinnedUri ? ["--uri", params.pinnedUri] : [],
-    ...params.nodeLimit ? ["--node-limit", String(params.nodeLimit)] : []
-  ];
-  const semanticResult = await runOpenVikingTool(config2, baseArgs);
+    target_uri: params.pinnedUri
+  });
   if (semanticResult.isError === true) {
     return semanticResult;
   }
@@ -35532,8 +38275,13 @@ async function runRecallTool(config2, params) {
     return semanticResult;
   }
   const sections = [];
-  if (firstContent.text) {
-    sections.push(firstContent.text);
+  const semanticText = filterStaleRecallSummaryRows(firstContent.text);
+  const filteredSemanticText = semanticText !== firstContent.text.trim();
+  if (semanticText) {
+    sections.push(semanticText);
+  }
+  if (indexRepairMessages.length > 0) {
+    sections.push(indexRepairMessages.join("\n"));
   }
   const seededSection = await seededResourcesSection(config2, contextualParams, projectQuery);
   if (seededSection) {
@@ -35554,7 +38302,7 @@ ${exactMatches}`);
   for (const warning2 of syncWarnings) {
     sections.push(`Auto-sync warning: ${warning2}`);
   }
-  if (sections.length <= 1) {
+  if (sections.length <= 1 && !filteredSemanticText) {
     return semanticResult;
   }
   return { ...semanticResult, content: [{ type: "text", text: sections.join("\n\n") }] };
@@ -35580,19 +38328,15 @@ async function seededResourcesSection(config2, params, projectQuery) {
   if (!projectResourceUri.startsWith("viking://")) {
     return void 0;
   }
-  const ov = await requiredOpenVikingCli2();
-  const args = [
-    "search",
-    params.query,
-    "--uri",
-    projectResourceUri,
-    ...params.nodeLimit ? ["--node-limit", String(params.nodeLimit)] : []
-  ];
-  const result = await runCommand(ov, withIdentity2(config2, args), { allowFailure: true });
-  if (result.exitCode !== 0) {
+  const result = await runOpenVikingMcpTool(config2, "search", {
+    limit: params.nodeLimit,
+    query: params.query,
+    target_uri: projectResourceUri
+  });
+  if (result.isError === true) {
     return void 0;
   }
-  const body = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
+  const body = filterStaleRecallSummaryRows(textFromCallToolResult(result));
   if (!body) {
     return void 0;
   }
@@ -35604,16 +38348,13 @@ async function exactMemoryMatchesText(config2, query, includeArchived) {
   if (terms.length === 0) {
     return void 0;
   }
-  const ov = await requiredOpenVikingCli2();
   const scopes = exactMemoryScopes(config2, includeArchived);
   const outputs = [];
   for (const term of terms) {
     for (const scope of scopes) {
-      const result = await runCommand(ov, withIdentity2(config2, ["grep", term, "--uri", scope, "--node-limit", "5"]), {
-        allowFailure: true
-      });
-      const output = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
-      if (result.exitCode === 0 && grepOutputHasMatches(output)) {
+      const result = await runOpenVikingMcpTool(config2, "grep", { node_limit: 5, pattern: term, uri: scope });
+      const output = textFromCallToolResult(result);
+      if (result.isError !== true && grepOutputHasMatches(output)) {
         outputs.push(output);
       }
     }
@@ -35625,15 +38366,16 @@ function registerReadTool(server, config2, name, description) {
     name,
     {
       annotations: { readOnlyHint: true, destructiveHint: false },
-      description: `${description} Required: pass JSON arguments with uri.`,
+      description: `${description} Required: pass JSON arguments with uri, or native OpenViking uris.`,
       inputSchema: {
-        uri: external_exports.string().optional().describe("Required viking:// file URI")
+        uri: external_exports.string().optional().describe("Required viking:// file URI"),
+        uris: external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]).optional().describe("Native OpenViking MCP read input: a single viking:// URI or array of URIs")
       }
     },
-    async ({ uri }) => {
-      const checkedUri = requiredVikingUri(uri, name, "viking://agent/threadnote/memories/.abstract.md");
-      if (!checkedUri.ok) {
-        return checkedUri.error;
+    async ({ uri, uris }) => {
+      const checkedUris = requiredVikingUriList(uris ?? uri, name, "viking://agent/threadnote/memories/.abstract.md");
+      if (!checkedUris.ok) {
+        return checkedUris.error;
       }
       let syncedTeams = [];
       const syncWarnings = [];
@@ -35644,7 +38386,7 @@ function registerReadTool(server, config2, name, description) {
       } catch (err) {
         syncWarnings.push(errorMessage(err));
       }
-      const result = await runOpenVikingTool(config2, ["read", checkedUri.value]);
+      const result = await runOpenVikingReadTool(config2, checkedUris.value);
       if (result.isError === true || syncedTeams.length === 0 && syncWarnings.length === 0) {
         return result;
       }
@@ -35670,22 +38412,19 @@ function registerListTool(server, config2, name, description) {
         all: external_exports.boolean().optional().describe("Show hidden files like .abstract.md and .overview.md"),
         recursive: external_exports.boolean().optional().describe("List recursively"),
         simple: external_exports.boolean().optional().describe("Only return paths"),
-        nodeLimit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum node count")
+        nodeLimit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum node count"),
+        node_limit: external_exports.number().int().positive().max(1e3).optional().describe("Maximum node count")
       }
     },
-    async ({ all, nodeLimit, recursive, simple, uri }) => {
+    async ({ recursive, uri }) => {
       const checkedUri = optionalVikingUri(uri, name);
       if (!checkedUri.ok) {
         return checkedUri.error;
       }
-      return runOpenVikingTool(config2, [
-        "ls",
-        checkedUri.value ?? "viking://",
-        ...all === true ? ["--all"] : [],
-        ...recursive === true ? ["--recursive"] : [],
-        ...simple === true ? ["--simple"] : [],
-        ...nodeLimit ? ["--node-limit", String(nodeLimit)] : []
-      ]);
+      return runOpenVikingMcpTool(config2, "list", {
+        recursive,
+        uri: checkedUri.value ?? "viking://"
+      });
     }
   );
 }
@@ -35751,9 +38490,8 @@ function registerArchiveTool(server, config2, name, description) {
         return checkedUri.error;
       }
       try {
-        const ov = await requiredOpenVikingCli2();
-        const readResult = await runCommand(ov, withIdentity2(config2, ["read", checkedUri.value]));
-        const original = readResult.stdout.trim();
+        const readResult = await runOpenVikingReadTool(config2, [checkedUri.value]);
+        const original = textFromCallToolResult(readResult);
         if (!original) {
           return {
             content: [{ type: "text", text: `Could not read ${checkedUri.value} before archiving.` }],
@@ -35776,7 +38514,7 @@ function registerArchiveTool(server, config2, name, description) {
         if (archiveResult.isError === true) {
           return archiveResult;
         }
-        const removedOriginal = await removeVikingResourceWithRetry(ov, config2, checkedUri.value);
+        const removedOriginal = await forgetVikingResourceWithRetry(config2, checkedUri.value);
         const [content] = archiveResult.content;
         const text = content?.type === "text" ? content.text : "Archived memory stored.";
         return {
@@ -35842,7 +38580,7 @@ function registerCompactTool(server, config2) {
           appliedMessages.push(`Updated kept memory: ${action.uri}`);
         }
         for (const action of plan.archives) {
-          const archiveResult = await archiveMemoryForCompact(config2, ov, action);
+          const archiveResult = await archiveMemoryForCompact(config2, action);
           if (archiveResult.isError === true) {
             return archiveResult;
           }
@@ -35852,7 +38590,7 @@ function registerCompactTool(server, config2) {
           }
         }
         for (const action of plan.forgets) {
-          const removed = await removeVikingResourceWithRetry(ov, config2, action.uri);
+          const removed = await forgetVikingResourceWithRetry(config2, action.uri);
           appliedMessages.push(
             removed ? `Forgot exact duplicate: ${action.uri}` : `Exact duplicate is still processing; retry later with forget: ${action.uri}`
           );
@@ -35871,9 +38609,9 @@ function registerCompactTool(server, config2) {
     }
   );
 }
-async function archiveMemoryForCompact(config2, ov, action) {
-  const readResult = await runCommand(ov, withIdentity2(config2, ["read", action.uri]));
-  const original = readResult.stdout.trim();
+async function archiveMemoryForCompact(config2, action) {
+  const readResult = await runOpenVikingReadTool(config2, [action.uri]);
+  const original = textFromCallToolResult(readResult);
   if (!original) {
     return { content: [{ type: "text", text: `Could not read ${action.uri} before archiving.` }], isError: true };
   }
@@ -35892,7 +38630,7 @@ async function archiveMemoryForCompact(config2, ov, action) {
   if (archiveResult.isError === true) {
     return archiveResult;
   }
-  const removedOriginal = await removeVikingResourceWithRetry(ov, config2, action.uri);
+  const removedOriginal = await forgetVikingResourceWithRetry(config2, action.uri);
   const [content] = archiveResult.content;
   const text = content?.type === "text" ? content.text : "Archived memory stored.";
   return {
@@ -35914,7 +38652,7 @@ async function scopedCompactRecords(config2, options) {
     const uriDirectory = memoryUriDirectoryForCompact(config2, kind, options.project);
     let entries;
     try {
-      entries = await (0, import_promises4.readdir)(directory, { withFileTypes: true });
+      entries = await (0, import_promises5.readdir)(directory, { withFileTypes: true });
     } catch (_err) {
       continue;
     }
@@ -35922,7 +38660,7 @@ async function scopedCompactRecords(config2, options) {
       if (!entry.isFile() || entry.name.startsWith(".") || !entry.name.endsWith(".md")) {
         continue;
       }
-      const content = await readTextIfExists((0, import_node_path4.join)(directory, entry.name));
+      const content = await readTextIfExists((0, import_node_path5.join)(directory, entry.name));
       if (!content) {
         continue;
       }
@@ -35957,11 +38695,11 @@ function localMemoryDirectoryForCompact(config2, kind, project) {
   const projectSegment = uriSegment2(project);
   switch (kind) {
     case "durable":
-      return (0, import_node_path4.join)(root, "durable", "projects", projectSegment);
+      return (0, import_node_path5.join)(root, "durable", "projects", projectSegment);
     case "handoff":
-      return (0, import_node_path4.join)(root, "handoffs", "active", projectSegment);
+      return (0, import_node_path5.join)(root, "handoffs", "active", projectSegment);
     case "incident":
-      return (0, import_node_path4.join)(root, "incidents", "active", projectSegment);
+      return (0, import_node_path5.join)(root, "incidents", "active", projectSegment);
   }
 }
 function memoryUriDirectoryForCompact(config2, kind, project) {
@@ -35981,18 +38719,18 @@ function localMemoryPathForUri(config2, uri) {
   if (!uri.startsWith(prefix) || uri.includes("/shared/")) {
     return void 0;
   }
-  const relative2 = uri.slice(prefix.length);
-  if (relative2.includes("..") || relative2.startsWith("/")) {
+  const relative3 = uri.slice(prefix.length);
+  if (relative3.includes("..") || relative3.startsWith("/")) {
     return void 0;
   }
-  return (0, import_node_path4.join)(localUserMemoriesRoot(config2), ...relative2.split("/"));
+  return (0, import_node_path5.join)(localUserMemoriesRoot(config2), ...relative3.split("/"));
 }
 function localUserMemoriesRoot(config2) {
-  return (0, import_node_path4.join)(config2.agentContextHome, "data", "viking", config2.account, "user", uriSegment2(config2.user), "memories");
+  return (0, import_node_path5.join)(config2.agentContextHome, "data", "viking", config2.account, "user", uriSegment2(config2.user), "memories");
 }
 async function readTextIfExists(path) {
   try {
-    return await (0, import_promises4.readFile)(path, "utf8");
+    return await (0, import_promises5.readFile)(path, "utf8");
   } catch (_err) {
     return void 0;
   }
@@ -36065,8 +38803,8 @@ async function vikingResourceExists2(ov, config2, uri) {
   const stat2 = await runCommand(ov, withIdentity2(config2, ["stat", uri]), { allowFailure: true });
   return stat2.exitCode === 0;
 }
-async function removeVikingResourceWithRetry(ov, config2, uri) {
-  const args = withIdentity2(config2, ["rm", uri]);
+async function removeVikingResourceWithRetry(ov, config2, uri, recursive = false) {
+  const args = withIdentity2(config2, ["rm", uri, ...recursive ? ["--recursive"] : []]);
   for (let attempt = 0; attempt < 4; attempt += 1) {
     const result = await runCommand(ov, args, { allowFailure: true });
     if (result.exitCode === 0) {
@@ -36082,6 +38820,23 @@ async function removeVikingResourceWithRetry(ov, config2, uri) {
   }
   return false;
 }
+async function runOpenVikingRemoveTool(config2, uri, recursive) {
+  try {
+    const ov = await requiredOpenVikingCli2();
+    const removed = await removeVikingResourceWithRetry(ov, config2, uri, recursive);
+    return {
+      content: [
+        {
+          type: "text",
+          text: removed ? `Removed: ${uri}` : `Resource is still being processed; retry later: ${uri}`
+        }
+      ],
+      isError: !removed
+    };
+  } catch (err) {
+    return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
+  }
+}
 function isResourceBusy(stderr, stdout2) {
   const output = `${stderr}
 ${stdout2}`.toLowerCase();
@@ -36223,19 +38978,161 @@ function optionalVikingUri(value, toolName) {
     ok: false
   };
 }
+function requiredVikingUriList(value, toolName, exampleUri) {
+  const rawValues = Array.isArray(value) ? value : value === void 0 ? [] : [value];
+  const uris = rawValues.map((uri) => uri.trim()).filter(Boolean);
+  if (uris.length === 0) {
+    return {
+      error: argumentError(
+        [
+          `Threadnote MCP tool "${toolName}" needs a non-empty "uri" or "uris" argument.`,
+          "Pass JSON arguments to the tool call.",
+          `Example: ${toolName}(${JSON.stringify({ uris: [exampleUri] })})`
+        ].join("\n")
+      ),
+      ok: false
+    };
+  }
+  const invalid = uris.find((uri) => !uri.startsWith("viking://"));
+  if (invalid) {
+    return {
+      error: argumentError(`Threadnote MCP tool "${toolName}" needs viking:// URI values. Received: ${invalid}`),
+      ok: false
+    };
+  }
+  return { ok: true, value: uris };
+}
 function argumentError(text) {
   return { content: [{ type: "text", text }], isError: true };
 }
-async function runOpenVikingTool(config2, args) {
+async function runOpenVikingAddResourceTool(config2, toolName, params) {
+  const tempFileId = params.tempFileId?.trim();
+  const source = params.path?.trim();
+  if (!source && !tempFileId) {
+    return argumentError(
+      [
+        `Threadnote MCP tool "${toolName}" needs a non-empty "path" argument.`,
+        "Pass JSON arguments to the tool call.",
+        `Example: ${toolName}(${JSON.stringify({ path: "/path/to/README.md", to: "viking://resources/my-repo/README.md" })})`
+      ].join("\n")
+    );
+  }
+  if (tempFileId) {
+    const checkedTo2 = optionalVikingUri(params.to, toolName);
+    if (!checkedTo2.ok) {
+      return checkedTo2.error;
+    }
+    return runOpenVikingMcpTool(config2, "add_resource", {
+      description: params.description,
+      temp_file_id: tempFileId,
+      to: checkedTo2.value,
+      watch_interval: params.watchInterval
+    });
+  }
+  const checkedTo = optionalVikingUri(params.to, toolName);
+  if (!checkedTo.ok) {
+    return checkedTo.error;
+  }
+  const description = params.description?.trim();
+  return runOpenVikingMcpTool(config2, "add_resource", {
+    description,
+    path: source,
+    to: checkedTo.value,
+    watch_interval: params.watchInterval
+  });
+}
+async function runOpenVikingReadTool(config2, uris) {
+  const result = await runOpenVikingMcpTool(config2, "read", { uris });
+  if (result.isError !== true && !nativeReadMissedAnyUri(result, uris)) {
+    return result;
+  }
+  return runOpenVikingReadToolWithCliFallback(config2, uris);
+}
+function nativeReadMissedAnyUri(result, uris) {
+  const text = textFromCallToolResult(result);
+  return uris.some((uri) => text.includes(`(nothing found at ${uri})`));
+}
+async function runOpenVikingReadToolWithCliFallback(config2, uris) {
+  const outputs = [];
+  for (const uri of uris) {
+    const nativeResult = await runOpenVikingMcpTool(config2, "read", { uris: [uri] });
+    const nativeText = textFromCallToolResult(nativeResult);
+    let text = nativeText;
+    if (nativeResult.isError === true || nativeText.includes(`(nothing found at ${uri})`)) {
+      const cliResult = await runOpenVikingCliReadTool(config2, uri);
+      if (cliResult.isError === true) {
+        return cliResult;
+      }
+      text = textFromCallToolResult(cliResult);
+    }
+    outputs.push(uris.length === 1 ? text : `=== ${uri} ===
+${text}`);
+  }
+  return { content: [{ type: "text", text: outputs.filter(Boolean).join("\n\n") || "OK" }] };
+}
+async function runOpenVikingCliReadTool(config2, uri) {
   try {
     const ov = await requiredOpenVikingCli2();
-    const result = await runCommand(ov, withIdentity2(config2, args));
+    const result = await runCommand(ov, withIdentity2(config2, ["read", uri]));
     const text = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
     return { content: [{ type: "text", text: text || "OK" }] };
   } catch (err) {
     return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
   }
 }
+async function runOpenVikingMcpTool(config2, toolName, args) {
+  const client = new Client({ name: "threadnote-openviking-proxy", version: "1.1.0" });
+  try {
+    const transport = new StreamableHTTPClientTransport(new URL(config2.openVikingMcpUrl), {
+      requestInit: {
+        headers: {
+          "X-OpenViking-Account": config2.account,
+          "X-OpenViking-Agent": config2.agentId,
+          "X-OpenViking-User": config2.user
+        }
+      }
+    });
+    await client.connect(transport);
+    const result = await client.callTool({ arguments: stripUndefinedValues(args), name: toolName }, void 0, {
+      timeout: 3e4
+    });
+    return normalizeCallToolResult(result);
+  } catch (err) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `OpenViking native MCP tool "${toolName}" failed at ${config2.openVikingMcpUrl}: ${errorMessage(err)}`
+        }
+      ],
+      isError: true
+    };
+  } finally {
+    await client.close().catch(() => void 0);
+  }
+}
+function stripUndefinedValues(values) {
+  return Object.fromEntries(
+    Object.entries(values).filter((entry) => entry[1] !== void 0)
+  );
+}
+function normalizeCallToolResult(result) {
+  const maybeResult = result;
+  if (Array.isArray(maybeResult.content)) {
+    return {
+      content: maybeResult.content,
+      isError: maybeResult.isError
+    };
+  }
+  return { content: [{ type: "text", text: JSON.stringify(result) }] };
+}
+function textFromCallToolResult(result) {
+  return result.content.map((content) => content.type === "text" ? content.text : "").join("\n").trim();
+}
+async function forgetVikingResourceWithRetry(config2, uri) {
+  const ov = await requiredOpenVikingCli2();
+  return removeVikingResourceWithRetry(ov, config2, uri);
+}
 async function runSharePublishTool(config2, sourceUri, options) {
   try {
     if (isInSharedNamespace(config2, sourceUri)) {
@@ -36243,19 +39140,20 @@ async function runSharePublishTool(config2, sourceUri, options) {
     }
     const resolved = await resolveTeam(config2, options.team);
     const ov = await requiredOpenVikingCli2();
-    const readResult = await runCommand(ov, withIdentity2(config2, ["read", sourceUri]), { allowFailure: true });
-    if (readResult.exitCode !== 0 || !readResult.stdout.trim()) {
+    const readResult = await runOpenVikingReadTool(config2, [sourceUri]);
+    const sourceText = textFromCallToolResult(readResult);
+    if (readResult.isError === true || !sourceText) {
       return {
         content: [
           {
             type: "text",
-            text: `Could not read ${sourceUri}: ${readResult.stderr.trim() || readResult.stdout.trim() || "unknown error"}`
+            text: `Could not read ${sourceUri}: ${sourceText || "unknown error"}`
           }
         ],
         isError: true
       };
     }
-    const stripped = stripPersonalProvenance(readResult.stdout);
+    const stripped = stripPersonalProvenance(sourceText);
     const scrub = applyScrubber(stripped, { redact: options.redact === true });
     const targetUri = sharedUriFor(config2, sourceUri, resolved.name);
     if (options.preview === true) {
@@ -36297,7 +39195,7 @@ async function runSharePublishTool(config2, sourceUri, options) {
       push: options.push
     });
     try {
-      await removeMemoryUri(config2, ov, sourceUri, false, { quiet: true });
+      await forgetVikingResourceWithRetry(config2, sourceUri);
     } catch (sourceErr) {
       return {
         content: [
@@ -36327,7 +39225,7 @@ function withIdentity2(config2, args) {
   return [...args, "--account", config2.account, "--user", config2.user, "--agent-id", config2.agentId];
 }
 async function requiredOpenVikingCli2() {
-  const command2 = process.env.THREADNOTE_OV ?? await findExecutable(["ov", "openviking"]) ?? await firstExistingPath([(0, import_node_path4.join)((0, import_node_os3.homedir)(), ".local", "bin", "ov"), (0, import_node_path4.join)((0, import_node_os3.homedir)(), ".local", "bin", "openviking")]);
+  const command2 = process.env.THREADNOTE_OV ?? await findExecutable(["ov", "openviking"]) ?? await firstExistingPath([(0, import_node_path5.join)((0, import_node_os3.homedir)(), ".local", "bin", "ov"), (0, import_node_path5.join)((0, import_node_os3.homedir)(), ".local", "bin", "openviking")]);
   if (!command2) {
     throw new Error("Neither ov nor openviking was found. Run threadnote install first.");
   }
@@ -36336,8 +39234,8 @@ async function requiredOpenVikingCli2() {
 async function firstExistingPath(paths) {
   for (const path of paths) {
     try {
-      await (0, import_promises4.access)(path);
-      return await (0, import_promises4.realpath)(path);
+      await (0, import_promises5.access)(path);
+      return await (0, import_promises5.realpath)(path);
     } catch (_err) {
       continue;
     }