obsidian-mcp-server 3.1.0 → 3.1.2

package/dist/mcp-server/tools/definitions/index.d.ts

@@ -1,12 +1,683 @@
 /**
- * @fileoverview Tool registration barrel. The command-palette pair
- * (`obsidian_list_commands` + `obsidian_execute_command`) is exported
- * separately so callers can decide whether to register them based on the
- * `OBSIDIAN_ENABLE_COMMANDS` flag — keeping this module free of eager
- * config reads.
+ * @fileoverview Tool registration barrel. Tools are split into read-only and
+ * write groups so the entry point can wrap the write set with `disabledTool()`
+ * when `OBSIDIAN_READ_ONLY=true`. The command-palette pair is exported
+ * separately so the entry point wraps it with `disabledTool()` when either
+ * `OBSIDIAN_ENABLE_COMMANDS=false` or `OBSIDIAN_READ_ONLY=true` — keeping this
+ * module free of eager config reads.
  * @module mcp-server/tools/definitions/index
  */
-/** Tools registered unconditionally on every server. */
+/** Read-only tools — always registered, even with `OBSIDIAN_READ_ONLY=true`. */
+export declare const readToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    format: import("zod").ZodEnum<{
+        content: "content";
+        section: "section";
+        full: "full";
+        "document-map": "document-map";
+    }>;
+    target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"path">;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"periodic">;
+        period: import("zod").ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "type">;
+    section: import("zod").ZodOptional<import("zod").ZodObject<{
+        type: import("zod").ZodEnum<{
+            heading: "heading";
+            block: "block";
+            frontmatter: "frontmatter";
+        }>;
+        target: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    result: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        format: import("zod").ZodLiteral<"content">;
+        path: import("zod").ZodString;
+        content: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        format: import("zod").ZodLiteral<"full">;
+        path: import("zod").ZodString;
+        content: import("zod").ZodString;
+        frontmatter: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+        tags: import("zod").ZodArray<import("zod").ZodString>;
+        stat: import("zod").ZodObject<{
+            ctime: import("zod").ZodNumber;
+            mtime: import("zod").ZodNumber;
+            size: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        format: import("zod").ZodLiteral<"document-map">;
+        path: import("zod").ZodString;
+        headings: import("zod").ZodArray<import("zod").ZodString>;
+        blocks: import("zod").ZodArray<import("zod").ZodString>;
+        frontmatterFields: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        format: import("zod").ZodLiteral<"section">;
+        path: import("zod").ZodString;
+        section: import("zod").ZodObject<{
+            type: import("zod").ZodEnum<{
+                heading: "heading";
+                block: "block";
+                frontmatter: "frontmatter";
+            }>;
+            target: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        valueText: import("zod").ZodOptional<import("zod").ZodString>;
+        valueJson: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strip>], "format">;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "section_required";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`format` is \"section\" but no `section` locator was provided.";
+    readonly recovery: "Pass `section: { type, target }` (e.g. `{ type: \"heading\", target: \"Intro\" }`), or use `format: \"full\"` / `\"document-map\"` instead.";
+}, {
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The target path is outside OBSIDIAN_READ_PATHS (and OBSIDIAN_WRITE_PATHS, since write paths imply read access).";
+    readonly recovery: "Use a path inside the configured read scope. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "The vault path does not resolve to an existing note.";
+    readonly recovery: "Verify the path with obsidian_list_notes or use obsidian_search_notes to locate the note.";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Create the periodic note first or pass an explicit path target.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    path: import("zod").ZodOptional<import("zod").ZodString>;
+    extension: import("zod").ZodOptional<import("zod").ZodString>;
+    nameRegex: import("zod").ZodOptional<import("zod").ZodString>;
+    depth: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    entries: import("zod").ZodArray<import("zod").ZodObject<{
+        path: import("zod").ZodString;
+        type: import("zod").ZodEnum<{
+            file: "file";
+            directory: "directory";
+        }>;
+        truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>>;
+    totals: import("zod").ZodObject<{
+        entries: import("zod").ZodNumber;
+        files: import("zod").ZodNumber;
+        directories: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+    appliedFilters: import("zod").ZodObject<{
+        extension: import("zod").ZodOptional<import("zod").ZodString>;
+        nameRegex: import("zod").ZodOptional<import("zod").ZodString>;
+        depth: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+    excluded: import("zod").ZodOptional<import("zod").ZodObject<{
+        reason: import("zod").ZodLiteral<"entry_cap">;
+        cap: import("zod").ZodNumber;
+        hint: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "regex_invalid";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "The supplied `nameRegex` is not a valid ECMAScript regex.";
+    readonly recovery: "Test the pattern (e.g. `^Project.*\\.md$`) in a JS regex tester, or omit nameRegex to disable filtering.";
+}, {
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The supplied `path` is outside OBSIDIAN_READ_PATHS (root listings always pass; specific subdirectories must be readable).";
+    readonly recovery: "List a directory inside the configured read scope, or omit `path` to list from the vault root. The error data echoes the active scope.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "The supplied `path` does not exist in the vault. Sub-directories that disappear mid-walk are silently skipped — only the root path surfaces this error.";
+    readonly recovery: "List a parent directory to find the correct casing or check the spelling.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    tags: import("zod").ZodArray<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        count: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    failIfMissing: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    newLeaf: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    opened: import("zod").ZodBoolean;
+    createdIfMissing: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The target path is outside OBSIDIAN_READ_PATHS (and OBSIDIAN_WRITE_PATHS, since write paths imply read access).";
+    readonly recovery: "Use a path inside the configured read scope. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "`failIfMissing: true` (default) and the path does not exist in the vault. Pass `failIfMissing: false` to allow Obsidian to create the file on open.";
+    readonly recovery: "Verify the path with obsidian_list_notes or pass failIfMissing false to create on open.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    mode: import("zod").ZodEnum<{
+        text: "text";
+        dataview: "dataview";
+        jsonlogic: "jsonlogic";
+    }>;
+    query: import("zod").ZodOptional<import("zod").ZodString>;
+    logic: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    contextLength: import("zod").ZodOptional<import("zod").ZodNumber>;
+    pathPrefix: import("zod").ZodOptional<import("zod").ZodString>;
+    maxMatchesPerHit: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    result: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        mode: import("zod").ZodLiteral<"text">;
+        hits: import("zod").ZodArray<import("zod").ZodObject<{
+            filename: import("zod").ZodString;
+            score: import("zod").ZodOptional<import("zod").ZodNumber>;
+            matches: import("zod").ZodArray<import("zod").ZodObject<{
+                context: import("zod").ZodString;
+                match: import("zod").ZodObject<{
+                    start: import("zod").ZodNumber;
+                    end: import("zod").ZodNumber;
+                }, import("zod/v4/core").$strip>;
+            }, import("zod/v4/core").$strip>>;
+            totalMatches: import("zod").ZodOptional<import("zod").ZodNumber>;
+            truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>>;
+        excluded: import("zod").ZodOptional<import("zod").ZodObject<{
+            count: import("zod").ZodNumber;
+            hint: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        mode: import("zod").ZodLiteral<"dataview">;
+        hits: import("zod").ZodArray<import("zod").ZodObject<{
+            filename: import("zod").ZodString;
+            result: import("zod").ZodUnknown;
+        }, import("zod/v4/core").$strip>>;
+        excluded: import("zod").ZodOptional<import("zod").ZodObject<{
+            count: import("zod").ZodNumber;
+            hint: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        mode: import("zod").ZodLiteral<"jsonlogic">;
+        hits: import("zod").ZodArray<import("zod").ZodObject<{
+            filename: import("zod").ZodString;
+            result: import("zod").ZodUnknown;
+        }, import("zod/v4/core").$strip>>;
+        excluded: import("zod").ZodOptional<import("zod").ZodObject<{
+            count: import("zod").ZodNumber;
+            hint: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>], "mode">;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_prefix_invalid_mode";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`pathPrefix` was provided in a non-text mode (only `text` supports prefix filtering).";
+    readonly recovery: "Drop pathPrefix or switch mode to text for prefix filtering.";
+}, {
+    readonly reason: "query_required";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`query` is missing for `text` or `dataview` mode (required for both).";
+    readonly recovery: "Pass `query` — search terms for text mode (e.g. \"TODO\"), or DQL like \"TABLE WHERE file.mtime > date(today)\" for dataview mode.";
+}, {
+    readonly reason: "logic_required";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`logic` is missing for `jsonlogic` mode.";
+    readonly recovery: "Pass a JSONLogic tree as `logic`, e.g. `{\"glob\": [{\"var\": \"path\"}, \"Projects/*.md\"]}`.";
+}]>)[];
+/** Write tools — wrapped with `disabledTool()` when `OBSIDIAN_READ_ONLY=true`. */
+export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"path">;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"periodic">;
+        period: import("zod").ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "type">;
+    content: import("zod").ZodString;
+    section: import("zod").ZodOptional<import("zod").ZodObject<{
+        type: import("zod").ZodEnum<{
+            heading: "heading";
+            block: "block";
+            frontmatter: "frontmatter";
+        }>;
+        target: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    contentType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        markdown: "markdown";
+        json: "json";
+    }>>;
+    createTargetIfMissing: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    sectionTargeted: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
+    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"path">;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"periodic">;
+        period: import("zod").ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "type">;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    deleted: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
+    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}, {
+    readonly reason: "cancelled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.InvalidRequest;
+    readonly when: "User declined the deletion via interactive elicitation.";
+    readonly recovery: "Re-run the tool when the user is ready to confirm deletion.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "The vault path does not resolve to an existing note.";
+    readonly recovery: "Verify the path with obsidian_list_notes or use obsidian_search_notes to locate the note.";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Pass an explicit path target — periodic notes must already exist.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    operation: import("zod").ZodEnum<{
+        set: "set";
+        delete: "delete";
+        get: "get";
+    }>;
+    target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"path">;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"periodic">;
+        period: import("zod").ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "type">;
+    key: import("zod").ZodString;
+    value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    result: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"get">;
+        path: import("zod").ZodString;
+        key: import("zod").ZodString;
+        exists: import("zod").ZodBoolean;
+        value: import("zod").ZodUnknown;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"set">;
+        path: import("zod").ZodString;
+        key: import("zod").ZodString;
+        frontmatter: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"delete">;
+        path: import("zod").ZodString;
+        key: import("zod").ZodString;
+        frontmatter: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strip>], "operation">;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "`get` requires the path to be readable; `set`/`delete` require it to be inside OBSIDIAN_WRITE_PATHS, with OBSIDIAN_READ_ONLY=false.";
+    readonly recovery: "Use a path inside the configured scope, or unset OBSIDIAN_READ_ONLY for writes. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}, {
+    readonly reason: "value_required";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`operation` is \"set\" but no `value` was supplied.";
+    readonly recovery: "Pass `value` as any JSON-typed value: string, number, boolean, array, or object (e.g. `\"draft\"`, `42`, `true`, `[\"a\",\"b\"]`).";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "The vault path does not resolve to an existing note.";
+    readonly recovery: "Verify the path with obsidian_list_notes or use obsidian_search_notes to locate the note.";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Create the periodic note first or pass an explicit path target.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"path">;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"periodic">;
+        period: import("zod").ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "type">;
+    operation: import("zod").ZodEnum<{
+        list: "list";
+        add: "add";
+        remove: "remove";
+    }>;
+    tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    location: import("zod").ZodDefault<import("zod").ZodEnum<{
+        frontmatter: "frontmatter";
+        inline: "inline";
+        both: "both";
+    }>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    result: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"list">;
+        path: import("zod").ZodString;
+        tags: import("zod").ZodObject<{
+            frontmatter: import("zod").ZodArray<import("zod").ZodString>;
+            inline: import("zod").ZodArray<import("zod").ZodString>;
+            all: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"add">;
+        path: import("zod").ZodString;
+        applied: import("zod").ZodArray<import("zod").ZodString>;
+        skipped: import("zod").ZodArray<import("zod").ZodString>;
+        tags: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"remove">;
+        path: import("zod").ZodString;
+        applied: import("zod").ZodArray<import("zod").ZodString>;
+        skipped: import("zod").ZodArray<import("zod").ZodString>;
+        tags: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "operation">;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "`list` requires the path to be readable; `add`/`remove` require it to be inside OBSIDIAN_WRITE_PATHS, with OBSIDIAN_READ_ONLY=false.";
+    readonly recovery: "Use a path inside the configured scope, or unset OBSIDIAN_READ_ONLY for writes. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}, {
+    readonly reason: "tags_required";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`operation` is \"add\" or \"remove\" but `tags` was empty or omitted.";
+    readonly recovery: "Pass a non-empty `tags` array (without `#`), e.g. `[\"draft\", \"wip\"]`.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "The vault path does not resolve to an existing note.";
+    readonly recovery: "Verify the path with obsidian_list_notes or use obsidian_search_notes to locate the note.";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Create the periodic note first or pass an explicit path target.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"path">;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"periodic">;
+        period: import("zod").ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "type">;
+    section: import("zod").ZodObject<{
+        type: import("zod").ZodEnum<{
+            heading: "heading";
+            block: "block";
+            frontmatter: "frontmatter";
+        }>;
+        target: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>;
+    operation: import("zod").ZodEnum<{
+        replace: "replace";
+        append: "append";
+        prepend: "prepend";
+    }>;
+    content: import("zod").ZodString;
+    contentType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        markdown: "markdown";
+        json: "json";
+    }>>;
+    patchOptions: import("zod").ZodOptional<import("zod").ZodObject<{
+        createTargetIfMissing: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        applyIfContentPreexists: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        trimTargetWhitespace: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    section: import("zod").ZodObject<{
+        type: import("zod").ZodEnum<{
+            heading: "heading";
+            block: "block";
+            frontmatter: "frontmatter";
+        }>;
+        target: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>;
+    operation: import("zod").ZodEnum<{
+        replace: "replace";
+        append: "append";
+        prepend: "prepend";
+    }>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
+    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "The vault path does not resolve to an existing note.";
+    readonly recovery: "Verify the path with obsidian_list_notes or use obsidian_search_notes to locate the note.";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Create the periodic note first or pass an explicit path target.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+}, {
+    readonly reason: "section_target_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "The named heading/block/frontmatter field does not exist in the note. Use `obsidian_get_note` with `format: \"document-map\"` to discover available targets.";
+    readonly recovery: "Call obsidian_get_note with format document-map to discover the available targets.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"path">;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"periodic">;
+        period: import("zod").ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "type">;
+    replacements: import("zod").ZodArray<import("zod").ZodObject<{
+        search: import("zod").ZodString;
+        replace: import("zod").ZodString;
+        useRegex: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        caseSensitive: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        wholeWord: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        flexibleWhitespace: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        replaceAll: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    totalReplacements: import("zod").ZodNumber;
+    perReplacement: import("zod").ZodArray<import("zod").ZodObject<{
+        search: import("zod").ZodString;
+        count: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes. (The pre-read also requires the path to be readable.)";
+    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}, {
+    readonly reason: "regex_invalid";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "A `useRegex: true` replacement supplied a `search` pattern that is not a valid ECMAScript regex.";
+    readonly recovery: "Test the pattern in a JS regex tester, or set useRegex to false to match `search` as a literal string.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "The vault path does not resolve to an existing note.";
+    readonly recovery: "Verify the path with obsidian_list_notes or use obsidian_search_notes to locate the note.";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Create the periodic note first or pass an explicit path target.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"path">;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"periodic">;
+        period: import("zod").ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "type">;
+    content: import("zod").ZodString;
+    section: import("zod").ZodOptional<import("zod").ZodObject<{
+        type: import("zod").ZodEnum<{
+            heading: "heading";
+            block: "block";
+            frontmatter: "frontmatter";
+        }>;
+        target: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    contentType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        markdown: "markdown";
+        json: "json";
+    }>>;
+    overwrite: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    sectionTargeted: import("zod").ZodBoolean;
+    created: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "file_exists";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Conflict;
+    readonly when: "Whole-file write was attempted against an existing note and `overwrite` was not set to `true`.";
+    readonly recovery: "Retry with overwrite true or use obsidian_patch_note for in-place edits.";
+}, {
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
+    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}]>)[];
+/** Combined base set — preserves the previous registration order. */
 export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         type: import("zod").ZodLiteral<"path">;
@@ -41,7 +712,12 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     path: import("zod").ZodString;
     sectionTargeted: import("zod").ZodBoolean;
-}, import("zod/v4/core").$strip>, undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
+    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         type: import("zod").ZodLiteral<"path">;
         path: import("zod").ZodString;
@@ -62,21 +738,35 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     path: import("zod").ZodString;
     deleted: import("zod").ZodBoolean;
 }, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
+    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}, {
     readonly reason: "cancelled";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.InvalidRequest;
     readonly when: "User declined the deletion via interactive elicitation.";
+    readonly recovery: "Re-run the tool when the user is ready to confirm deletion.";
 }, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "The vault path does not resolve to an existing note.";
+    readonly recovery: "Verify the path with obsidian_list_notes or use obsidian_search_notes to locate the note.";
 }, {
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Pass an explicit path target — periodic notes must already exist.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     format: import("zod").ZodEnum<{
         content: "content";
@@ -148,18 +838,32 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "section_required";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "`format` is \"section\" but no `section` locator was provided.";
+    readonly recovery: "Pass `section: { type, target }` (e.g. `{ type: \"heading\", target: \"Intro\" }`), or use `format: \"full\"` / `\"document-map\"` instead.";
+}, {
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The target path is outside OBSIDIAN_READ_PATHS (and OBSIDIAN_WRITE_PATHS, since write paths imply read access).";
+    readonly recovery: "Use a path inside the configured read scope. The error data echoes the active scope; check the server startup banner for the active configuration.";
 }, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "The vault path does not resolve to an existing note.";
+    readonly recovery: "Verify the path with obsidian_list_notes or use obsidian_search_notes to locate the note.";
 }, {
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Create the periodic note first or pass an explicit path target.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     path: import("zod").ZodOptional<import("zod").ZodString>;
     extension: import("zod").ZodOptional<import("zod").ZodString>;
@@ -194,10 +898,17 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "regex_invalid";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "The supplied `nameRegex` is not a valid ECMAScript regex.";
+    readonly recovery: "Test the pattern (e.g. `^Project.*\\.md$`) in a JS regex tester, or omit nameRegex to disable filtering.";
+}, {
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The supplied `path` is outside OBSIDIAN_READ_PATHS (root listings always pass; specific subdirectories must be readable).";
+    readonly recovery: "List a directory inside the configured read scope, or omit `path` to list from the vault root. The error data echoes the active scope.";
 }, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "The supplied `path` does not exist in the vault. Sub-directories that disappear mid-walk are silently skipped — only the root path surfaces this error.";
+    readonly recovery: "List a parent directory to find the correct casing or check the spelling.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     tags: import("zod").ZodArray<import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -246,21 +957,35 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
         frontmatter: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
     }, import("zod/v4/core").$strip>], "operation">;
 }, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "`get` requires the path to be readable; `set`/`delete` require it to be inside OBSIDIAN_WRITE_PATHS, with OBSIDIAN_READ_ONLY=false.";
+    readonly recovery: "Use a path inside the configured scope, or unset OBSIDIAN_READ_ONLY for writes. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}, {
     readonly reason: "value_required";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "`operation` is \"set\" but no `value` was supplied.";
+    readonly recovery: "Pass `value` as any JSON-typed value: string, number, boolean, array, or object (e.g. `\"draft\"`, `42`, `true`, `[\"a\",\"b\"]`).";
 }, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "The vault path does not resolve to an existing note.";
+    readonly recovery: "Verify the path with obsidian_list_notes or use obsidian_search_notes to locate the note.";
 }, {
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Create the periodic note first or pass an explicit path target.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         type: import("zod").ZodLiteral<"path">;
@@ -312,21 +1037,35 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
         tags: import("zod").ZodArray<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>], "operation">;
 }, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "`list` requires the path to be readable; `add`/`remove` require it to be inside OBSIDIAN_WRITE_PATHS, with OBSIDIAN_READ_ONLY=false.";
+    readonly recovery: "Use a path inside the configured scope, or unset OBSIDIAN_READ_ONLY for writes. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}, {
     readonly reason: "tags_required";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "`operation` is \"add\" or \"remove\" but `tags` was empty or omitted.";
+    readonly recovery: "Pass a non-empty `tags` array (without `#`), e.g. `[\"draft\", \"wip\"]`.";
 }, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "The vault path does not resolve to an existing note.";
+    readonly recovery: "Verify the path with obsidian_list_notes or use obsidian_search_notes to locate the note.";
 }, {
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Create the periodic note first or pass an explicit path target.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     path: import("zod").ZodString;
     failIfMissing: import("zod").ZodDefault<import("zod").ZodBoolean>;
@@ -336,9 +1075,15 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     opened: import("zod").ZodBoolean;
     createdIfMissing: import("zod").ZodBoolean;
 }, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The target path is outside OBSIDIAN_READ_PATHS (and OBSIDIAN_WRITE_PATHS, since write paths imply read access).";
+    readonly recovery: "Use a path inside the configured read scope. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "`failIfMissing: true` (default) and the path does not exist in the vault. Pass `failIfMissing: false` to allow Obsidian to create the file on open.";
+    readonly recovery: "Verify the path with obsidian_list_notes or pass failIfMissing false to create on open.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         type: import("zod").ZodLiteral<"path">;
@@ -365,9 +1110,9 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
         target: import("zod").ZodString;
     }, import("zod/v4/core").$strip>;
     operation: import("zod").ZodEnum<{
+        replace: "replace";
         append: "append";
         prepend: "prepend";
-        replace: "replace";
     }>;
     content: import("zod").ZodString;
     contentType: import("zod").ZodDefault<import("zod").ZodEnum<{
@@ -390,26 +1135,40 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
         target: import("zod").ZodString;
     }, import("zod/v4/core").$strip>;
     operation: import("zod").ZodEnum<{
+        replace: "replace";
         append: "append";
         prepend: "prepend";
-        replace: "replace";
     }>;
 }, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
+    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "The vault path does not resolve to an existing note.";
+    readonly recovery: "Verify the path with obsidian_list_notes or use obsidian_search_notes to locate the note.";
 }, {
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Create the periodic note first or pass an explicit path target.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
 }, {
     readonly reason: "section_target_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "The named heading/block/frontmatter field does not exist in the note. Use `obsidian_get_note` with `format: \"document-map\"` to discover available targets.";
+    readonly recovery: "Call obsidian_get_note with format document-map to discover the available targets.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         type: import("zod").ZodLiteral<"path">;
@@ -444,21 +1203,35 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
         count: import("zod").ZodNumber;
     }, import("zod/v4/core").$strip>>;
 }, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes. (The pre-read also requires the path to be readable.)";
+    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+}, {
     readonly reason: "regex_invalid";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "A `useRegex: true` replacement supplied a `search` pattern that is not a valid ECMAScript regex.";
+    readonly recovery: "Test the pattern in a JS regex tester, or set useRegex to false to match `search` as a literal string.";
 }, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "The vault path does not resolve to an existing note.";
+    readonly recovery: "Verify the path with obsidian_list_notes or use obsidian_search_notes to locate the note.";
 }, {
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Create the periodic note first or pass an explicit path target.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     mode: import("zod").ZodEnum<{
         text: "text";
@@ -515,14 +1288,17 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "path_prefix_invalid_mode";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "`pathPrefix` was provided in a non-text mode (only `text` supports prefix filtering).";
+    readonly recovery: "Drop pathPrefix or switch mode to text for prefix filtering.";
 }, {
     readonly reason: "query_required";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "`query` is missing for `text` or `dataview` mode (required for both).";
+    readonly recovery: "Pass `query` — search terms for text mode (e.g. \"TODO\"), or DQL like \"TABLE WHERE file.mtime > date(today)\" for dataview mode.";
 }, {
     readonly reason: "logic_required";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "`logic` is missing for `jsonlogic` mode.";
+    readonly recovery: "Pass a JSONLogic tree as `logic`, e.g. `{\"glob\": [{\"var\": \"path\"}, \"Projects/*.md\"]}`.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         type: import("zod").ZodLiteral<"path">;
@@ -562,8 +1338,14 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "file_exists";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Conflict;
     readonly when: "Whole-file write was attempted against an existing note and `overwrite` was not set to `true`.";
+    readonly recovery: "Retry with overwrite true or use obsidian_patch_note for in-place edits.";
+}, {
+    readonly reason: "path_forbidden";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
+    readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
+    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
 }]>)[];
-/** Command-palette tools — registered only when `OBSIDIAN_ENABLE_COMMANDS=true`. */
+/** Command-palette tools — opt-in via `OBSIDIAN_ENABLE_COMMANDS=true`; suppressed by `OBSIDIAN_READ_ONLY=true`. */
 export declare const commandToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     commandId: import("zod").ZodString;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
@@ -573,6 +1355,7 @@ export declare const commandToolDefinitions: (import("@cyanheads/mcp-ts-core").T
     readonly reason: "command_unknown";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "The supplied `commandId` is not registered in Obsidian. Use `obsidian_list_commands` to discover valid IDs.";
+    readonly recovery: "Call obsidian_list_commands to discover the registered command IDs.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     commands: import("zod").ZodArray<import("zod").ZodObject<{
         id: import("zod").ZodString;