obsidian-mcp-server 3.1.6 → 3.1.8

package/CLAUDE.md

@@ -1,7 +1,7 @@
 # Agent Protocol
 
 **Server:** obsidian-mcp-server
-**Version:** 3.1.6
+**Version:** 3.1.8
 **Framework:** [@cyanheads/mcp-ts-core](https://www.npmjs.com/package/@cyanheads/mcp-ts-core) `^0.8.20`
 **Engines:** Bun ≥1.3.11, Node ≥24.0.0
 

package/README.md

@@ -7,7 +7,7 @@
 
 <div align="center">
 
-[![npm](https://img.shields.io/npm/v/obsidian-mcp-server?style=flat-square&logo=npm&logoColor=white)](https://www.npmjs.com/package/obsidian-mcp-server) [![Version](https://img.shields.io/badge/Version-3.1.6-blue.svg?style=flat-square)](./CHANGELOG.md) [![Framework](https://img.shields.io/badge/Built%20on-@cyanheads/mcp--ts--core-259?style=flat-square)](https://www.npmjs.com/package/@cyanheads/mcp-ts-core) [![MCP SDK](https://img.shields.io/badge/MCP%20SDK-^1.29.0-green.svg?style=flat-square)](https://modelcontextprotocol.io/)
+[![npm](https://img.shields.io/npm/v/obsidian-mcp-server?style=flat-square&logo=npm&logoColor=white)](https://www.npmjs.com/package/obsidian-mcp-server) [![Version](https://img.shields.io/badge/Version-3.1.8-blue.svg?style=flat-square)](./CHANGELOG.md) [![Framework](https://img.shields.io/badge/Built%20on-@cyanheads/mcp--ts--core-259?style=flat-square)](https://www.npmjs.com/package/@cyanheads/mcp-ts-core) [![MCP SDK](https://img.shields.io/badge/MCP%20SDK-^1.29.0-green.svg?style=flat-square)](https://modelcontextprotocol.io/)
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-orange.svg?style=flat-square)](./LICENSE) [![TypeScript](https://img.shields.io/badge/TypeScript-^6.0.3-3178C6.svg?style=flat-square)](https://www.typescriptlang.org/) [![Bun](https://img.shields.io/badge/Bun-v1.3.11-blueviolet.svg?style=flat-square)](https://bun.sh/)
 
@@ -21,13 +21,13 @@ Fourteen tools grouped by shape — readers fetch notes and metadata, writers cr
 
 | Tool Name | Description |
 |:----------|:------------|
-| `obsidian_get_note` | Read a note as raw content, full structured form (content + frontmatter + tags + stat), structural document map, or a single section. |
+| `obsidian_get_note` | Read a note as raw content, full structured form (content + frontmatter + tags + stat, with optional outgoing links), structural document map, or a single section. |
 | `obsidian_list_notes` | List notes and subdirectories at a vault path with a recursive walk (default depth 2 — structural overview; max 20) bounded by a 1000-entry cap. Optional `extension` and `nameRegex` filters apply across the tree; regex-filtered directories are skipped without recursing into them. Returns flat `entries[]` plus a box-drawing tree in the rendered output; per-directory `truncated: true` flags where the depth limit cut off recursion. |
 | `obsidian_list_tags` | List every tag found across the vault with usage counts, including hierarchical parents. |
 | `obsidian_list_commands` | List Obsidian command-palette commands available for execution. **Opt-in via `OBSIDIAN_ENABLE_COMMANDS=true`** (paired with `obsidian_execute_command`). |
-| `obsidian_search_notes` | Search the vault by text, Dataview DQL, or JSONLogic — capped at 100 hits with overflow indicator. |
+| `obsidian_search_notes` | Search the vault by text, Dataview DQL, or JSONLogic. Text-mode matches return surrounding context windows (`contextLength`) — capped at 100 hits with overflow indicator. |
 | `obsidian_write_note` | Create a note, replace a single section in place, or — with `overwrite: true` — clobber an existing file. Refuses whole-file writes against an existing path by default. |
-| `obsidian_append_to_note` | Append content to a note, or to a specific heading/block/frontmatter section. |
+| `obsidian_append_to_note` | Append content to a note. Without `section` it creates the file if missing — your content becomes the entire file. With `section`, appends to that heading/block/frontmatter (PATCH; the file must exist). |
 | `obsidian_patch_note` | Surgical `append` / `prepend` / `replace` against a heading, block reference, or frontmatter field. |
 | `obsidian_replace_in_note` | Body-wide search-replace inside a single note. Literal or regex matching, with `wholeWord`, `flexibleWhitespace`, `caseSensitive`, `replaceAll`, and `$1`/`$&` capture groups. |
 | `obsidian_manage_frontmatter` | Atomic `get` / `set` / `delete` on a single frontmatter key. |
@@ -41,7 +41,7 @@ Fourteen tools grouped by shape — readers fetch notes and metadata, writers cr
 Read a note in one of four projections, addressed by vault path, the active file, or a periodic note (`daily`, `weekly`, `monthly`, `quarterly`, `yearly`).
 
 - `format: "content"` — raw markdown body
-- `format: "full"` — content, frontmatter, tags, and file metadata
+- `format: "full"` — content, frontmatter, tags, and file metadata; pass `includeLinks: true` to also parse outgoing wiki and markdown link references from the body (vault-internal only — external URLs are filtered)
 - `format: "document-map"` — catalog of headings, block references, and frontmatter fields
 - `format: "section"` — single heading/block/frontmatter section value (requires `section`); heading sections include the full subtree under that heading
 
@@ -53,7 +53,7 @@ Pair the document-map projection with `obsidian_patch_note` to discover edit tar
 
 Three search modes selected by `mode`:
 
-- `text` — substring match with surrounding context windows; optional `pathPrefix` filter (text mode only — passing `pathPrefix` in `dataview` or `jsonlogic` mode is rejected with `path_prefix_invalid_mode`)
+- `text` — substring match with surrounding context windows. `contextLength` controls characters of context per side of each match (default 100; bump it for more context per hit). Optional `pathPrefix` filter (text mode only — passing `pathPrefix` in `dataview` or `jsonlogic` mode is rejected with `path_prefix_invalid_mode`).
 - `dataview` — Dataview DQL (`TABLE …`) for path/date/metadata queries; `file.mtime`, `file.path`, etc. are queryable
 - `jsonlogic` — JSONLogic tree evaluated against `path`, `content`, `frontmatter.<key>`, `tags`, and `stat.{ctime,mtime,size}`; custom `glob` and `regexp` operators
 
@@ -68,7 +68,18 @@ Create or surgically replace, with a protective default against accidental whole
 - Without `section` — full-file `PUT`. **Refuses to clobber an existing file** unless `overwrite: true` is set. The `file_exists` (`Conflict`) error suggests `obsidian_patch_note` / `obsidian_append_to_note` / `obsidian_replace_in_note` for in-place edits.
 - With `section` — `PATCH`-with-replace against the named heading/block/frontmatter field, leaving the rest of the file untouched. The `overwrite` flag is ignored in section mode.
 
-The output reports `created: true` when the call brought a new file into existence; `false` when it replaced an existing one or targeted a section.
+The output reports `created: true` when the call brought a new file into existence; `false` when it replaced an existing one or targeted a section. Every mutating tool also returns `previousSizeInBytes` and `currentSizeInBytes` so an agent can spot accidental clobbers, unexpected upstream behavior, or a typo path that landed at the wrong file.
+
+---
+
+### `obsidian_append_to_note`
+
+A combined upsert + section-append primitive that mirrors the upstream Local REST API behavior:
+
+- Without `section` — `POST` to `/vault/{path}`. Appends when the file exists, **creates the file with your content as the entire body when it doesn't.** The output's `created: true` flags the second branch so the agent can notice when a typo path or a not-yet-created daily note silently turned into a brand-new file.
+- With `section` — `PATCH`-with-append against the named heading, block reference, or frontmatter field. The file must exist (PATCH preflight throws `note_missing` otherwise). Pass `createTargetIfMissing: true` to bring the section itself into existence inside an existing file. Block-reference targets concatenate adjacent to the block line without a separator — include a leading newline in `content` if you want one.
+
+`previousSizeInBytes` is `0` on the upsert-create branch and the actual file size otherwise; `currentSizeInBytes` is the post-write size read from the upstream after the operation. Compare deltas against `Buffer.byteLength(content)` to detect auto-newline injection or concurrent writers.
 
 ---
 
@@ -114,7 +125,7 @@ Add, remove, or list tags on a note. Reconciles both representations:
 
 ### `obsidian_delete_note`
 
-Permanently delete a note. When the client supports `elicit`, the server requests human confirmation before issuing the `DELETE`. Without elicitation, the `destructiveHint` annotation surfaces the operation in the host's approval flow.
+Permanently delete a note. When the client supports `elicit`, the server requests human confirmation before issuing the `DELETE` and the prompt includes the file's byte size — destructive blast radius visible before the user confirms. Without elicitation, the `destructiveHint` annotation surfaces the operation in the host's approval flow. The output reports `previousSizeInBytes` (size at the moment of deletion) and `currentSizeInBytes: 0`.
 
 ---
 
@@ -122,7 +133,7 @@ Permanently delete a note. When the client supports `elicit`, the server request
 
 Dispatch an Obsidian command-palette command by ID (discoverable via `obsidian_list_commands`). Behavior is command-dependent — some commands open UI, others delete files or close the vault.
 
-**Off by default.** Both `obsidian_execute_command` and its discovery partner `obsidian_list_commands` register only when the operator sets `OBSIDIAN_ENABLE_COMMANDS=true`; both are omitted from the surface otherwise.
+**Off by default.** When `OBSIDIAN_ENABLE_COMMANDS` is unset, both `obsidian_execute_command` and its discovery partner `obsidian_list_commands` are wrapped with `disabledTool()` — absent from `tools/list` (the LLM can't invoke them) but still visible in the operator-facing manifest with a hint to enable them.
 
 ---
 
@@ -141,7 +152,7 @@ Three optional env vars gate which vault paths each tool can target. **Default u
 
 **Write paths are implicitly readable** — you can't sanely edit what you can't see. So a read passes when the target matches `READ_PATHS` *or* `WRITE_PATHS`.
 
-**`OBSIDIAN_READ_ONLY=true` short-circuits before the path checks** — every write is denied regardless of `WRITE_PATHS`, and the command-palette pair is unregistered regardless of `OBSIDIAN_ENABLE_COMMANDS` (commands can mutate).
+**`OBSIDIAN_READ_ONLY=true` short-circuits before the path checks** — every write tool and the command-palette pair are wrapped with `disabledTool()` at startup (absent from `tools/list`), and any write that still reaches the service is denied at runtime regardless of `WRITE_PATHS`.
 
 Denies are typed `path_forbidden` (JSON-RPC code `Forbidden`) with the active scope echoed back in `data.recovery.hint` and `data.activeScope`, so the LLM can self-correct without inspecting server logs. Search results from `obsidian_search_notes` are filtered against `READ_PATHS` silently — surfacing a "we hid N hits" indicator would defeat the gate.
 
@@ -155,7 +166,7 @@ The startup banner logs the active scope so operators can verify their config at
 |:---|:---|:---|
 | Resource | `obsidian://vault/{+path}` | A note in the vault — content, frontmatter, tags, and file metadata. |
 | Resource | `obsidian://tags` | All tags found across the vault, with usage counts. |
-| Resource | `obsidian://status` | Server reachability, plugin version, and auth status of the Obsidian Local REST API. |
+| Resource | `obsidian://status` | Server reachability, auth status, plugin/Obsidian version info, and the plugin manifest. |
 
 All resource data is also reachable via tools — `obsidian_get_note` for `obsidian://vault/{+path}`, `obsidian_list_tags` for `obsidian://tags`. Resources exist for clients that prefer attaching a specific note or vault snapshot to a conversation.
 

package/changelog/3.1.x/3.1.7.md

@@ -0,0 +1,41 @@
+---
+summary: "Every mutating tool now reports `previousSizeInBytes` + `currentSizeInBytes`; `obsidian_append_to_note` gains the `created` upsert flag. Resolves [#48](https://github.com/cyanheads/obsidian-mcp-server/issues/48)."
+breaking: false
+security: false
+---
+
+# 3.1.7 — 2026-05-10
+
+`obsidian_append_to_note` is silently an upsert primitive — POST against a non-existent path creates the file and writes the body as its full content. This release rolls the response-transparency pattern from `obsidian_write_note` onto every mutating tool: each one now reports byte-size before and after the operation, and the upsert tools flag whether the write created the file. Agents get unambiguous evidence to spot typo paths, accidental whole-file clobbers, and concurrent-writer drift from the response alone.
+
+## Added
+
+- **`obsidian_append_to_note`** — `created: boolean` on the output. `true` flags the upsert branch where the agent's content became the entire file at a possibly unintended path; `format()` renders the same hint as `obsidian_write_note` when set. Always `false` for section appends (PATCH requires the file to exist).
+- **Every mutating tool** — `previousSizeInBytes` + `currentSizeInBytes` on the output. Server reports raw before/after; agent computes deltas and decides what discrepancies mean (auto-newline injection, concurrent writers, accidental shrinkage). No server-side integrity verdict.
+- **`ObsidianService.tryGetSize(ctx, target)`** — HEAD `/vault/{path}`, parses `Content-Length`, returns `null` on 404. Path-policy gated, retry-bypassed.
+- **`ObsidianService.getSize(ctx, target)`** — same as `tryGetSize` but throws `note_missing` on 404. Used for post-write verification reads.
+
+## Changed
+
+- **`obsidian_delete_note`** — elicitation prompt now includes the byte size of the file being deleted (`Permanently delete '<path>' (<N> bytes)?`).
+- **`obsidian_write_note`** overwrite check migrated from `noteExists` to `tryGetSize !== null`. Net wash on round trips, gain the `previousSizeInBytes` data for free on the same HEAD.
+- **`obsidian_append_to_note` description** — front-loads the create-if-missing behavior of the no-section branch (matches the wording pattern `obsidian_write_note` uses for `overwrite`).
+- **Source-of-truth rule for note byte sizes** documented on `tryGetSize`: prefer HEAD `Content-Length` or `Buffer.byteLength(deliveredContent)`, never `note.stat.size` from the JSON envelope (shares the upstream `getAbstractFileByPath` cache path with the rest of the envelope, so it can't act as an independent cross-check — see [coddingtonbear/obsidian-local-rest-api#237](https://github.com/coddingtonbear/obsidian-local-rest-api/issues/237)).
+- **`@biomejs/biome` `^2.4.14` → `^2.4.15`** (devDependency).
+
+## Removed
+
+- **`ObsidianService.noteExists`** — sole caller (`obsidian_write_note` overwrite guard) migrated to `tryGetSize`.
+
+## Per-tool source for `currentSizeInBytes`
+
+| Tool | Source | Extra round trips |
+|:---|:---|:---|
+| `obsidian_write_note` | Post-write HEAD (whole-file) / pre+post HEAD (section) | +1 / +2 |
+| `obsidian_append_to_note` | Post-write HEAD (whole-file) / pre+post HEAD (section) | +1 / +2 |
+| `obsidian_patch_note` | Pre+post HEAD | +2 |
+| `obsidian_delete_note` | Always 0 (file gone); pre-DELETE HEAD also feeds the elicit prompt | +1 |
+| `obsidian_replace_in_note` | `Buffer.byteLength` from existing GET; post-write HEAD only when matches found | 0 / +1 |
+| `obsidian_manage_frontmatter` (`set`) | `Buffer.byteLength(noteAfter.content)` from existing post-PATCH GET | +1 (pre-PATCH HEAD) |
+| `obsidian_manage_frontmatter` (`delete`) | `Buffer.byteLength` from existing GET; post-write HEAD only when content changed | 0 / +1 |
+| `obsidian_manage_tags` (`add` / `remove`) | `Buffer.byteLength` from existing pre/post GETs | 0 |

package/changelog/3.1.x/3.1.8.md

@@ -0,0 +1,27 @@
+---
+summary: "POST/PATCH bypass `withRetry` — prevents double-apply when a successful upstream write loses its response. Adds a 13-test regression suite covering the retry policy across every method."
+breaking: false
+security: false
+---
+
+# 3.1.8 — 2026-05-11
+
+`ObsidianService.#request` wrapped every call in `withRetry`. The framework's default `defaultIsTransient` predicate retries on 502/503/504/429 **and** raw network errors (`UND_ERR_SOCKET`, `ECONNRESET`, `ETIMEDOUT`, …) — fine for idempotent reads, but catastrophic for non-idempotent writes: an upstream that succeeded with a dropped response would double-apply on retry, duplicating an `append`, replaying a `patch` op, or re-running an arbitrary Obsidian command.
+
+## Fixed
+
+- **`ObsidianService.#request`** — POST/PATCH now bypass `withRetry` and propagate transient failures directly. Closes the data-corruption window on `obsidian_append_to_note`, `obsidian_patch_note` (`append`/`prepend`), `obsidian_execute_command`, `obsidian_open_in_ui`, and POST-mode `obsidian_search_notes`. Trade-off: those tools surface transient 5xx/network blips immediately rather than auto-retrying — agents must handle the first failure. Data integrity wins over single-call resilience for non-idempotent paths.
+
+## Added
+
+- **`RETRY_SAFE_METHODS`** — module-level `ReadonlySet<string>` of `{ GET, PUT, DELETE }`. Methods outside the set bypass the retry branch entirely.
+- **`tests/services/obsidian-service.test.ts`** — 13 regression tests under `ObsidianService retry policy`, grouped into three describes:
+  - **POST/PATCH never retry on transient failures** — `appendToNote` / `patchNote` / `executeCommand` / `openInUi` against 503/504 and raw network errors (`UND_ERR_SOCKET`, `ECONNRESET`).
+  - **GET/PUT/DELETE retry on transient failures** — `getNoteContent` / `writeNote` / `deleteNote` against 503 and `ECONNRESET`, asserting the second attempt succeeds.
+  - **Non-transient errors do not retry, regardless of method** — 404/400/500 surface immediately.
+  - Helper `queueReplies(path, method, n, reply)` queues N identical intercepts so the attempt counter ticks per fetch (a single intercept would let retries fall through to "no intercept" and silently mask the bug).
+
+## Changed
+
+- **`tests/helpers.ts`** — exported `PathMatcher`, `DispatchOpts`, `DynamicReply`, `ReplyFn` (previously file-internal) so the retry-policy suite can type its intercept callbacks without redeclaring them.
+- **`vitest` `^4.1.5` → `^4.1.6`** (devDependency).

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

@@ -284,6 +284,9 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     path: import("zod").ZodString;
     sectionTargeted: import("zod").ZodBoolean;
+    created: import("zod").ZodBoolean;
+    previousSizeInBytes: import("zod").ZodNumber;
+    currentSizeInBytes: import("zod").ZodNumber;
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
@@ -334,6 +337,8 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     path: import("zod").ZodString;
     deleted: import("zod").ZodBoolean;
+    previousSizeInBytes: import("zod").ZodNumber;
+    currentSizeInBytes: import("zod").ZodNumber;
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
@@ -400,11 +405,15 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
         path: import("zod").ZodString;
         key: import("zod").ZodString;
         frontmatter: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+        previousSizeInBytes: import("zod").ZodNumber;
+        currentSizeInBytes: import("zod").ZodNumber;
     }, 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>;
+        previousSizeInBytes: import("zod").ZodNumber;
+        currentSizeInBytes: import("zod").ZodNumber;
     }, import("zod/v4/core").$strip>], "operation">;
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "path_forbidden";
@@ -479,12 +488,16 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
         applied: import("zod").ZodArray<import("zod").ZodString>;
         skipped: import("zod").ZodArray<import("zod").ZodString>;
         tags: import("zod").ZodArray<import("zod").ZodString>;
+        previousSizeInBytes: import("zod").ZodNumber;
+        currentSizeInBytes: import("zod").ZodNumber;
     }, 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>;
+        previousSizeInBytes: import("zod").ZodNumber;
+        currentSizeInBytes: import("zod").ZodNumber;
     }, import("zod/v4/core").$strip>], "operation">;
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "path_forbidden";
@@ -571,6 +584,8 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
         append: "append";
         prepend: "prepend";
     }>;
+    previousSizeInBytes: import("zod").ZodNumber;
+    currentSizeInBytes: import("zod").ZodNumber;
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
@@ -634,6 +649,8 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
         search: import("zod").ZodString;
         count: import("zod").ZodNumber;
     }, import("zod/v4/core").$strip>>;
+    previousSizeInBytes: import("zod").ZodNumber;
+    currentSizeInBytes: import("zod").ZodNumber;
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
@@ -699,6 +716,8 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     path: import("zod").ZodString;
     sectionTargeted: import("zod").ZodBoolean;
     created: import("zod").ZodBoolean;
+    previousSizeInBytes: import("zod").ZodNumber;
+    currentSizeInBytes: import("zod").ZodNumber;
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "file_exists";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Conflict;
@@ -770,6 +789,9 @@ 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;
+    created: import("zod").ZodBoolean;
+    previousSizeInBytes: import("zod").ZodNumber;
+    currentSizeInBytes: import("zod").ZodNumber;
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
@@ -820,6 +842,8 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     path: import("zod").ZodString;
     deleted: import("zod").ZodBoolean;
+    previousSizeInBytes: import("zod").ZodNumber;
+    currentSizeInBytes: import("zod").ZodNumber;
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
@@ -1041,11 +1065,15 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
         path: import("zod").ZodString;
         key: import("zod").ZodString;
         frontmatter: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+        previousSizeInBytes: import("zod").ZodNumber;
+        currentSizeInBytes: import("zod").ZodNumber;
     }, 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>;
+        previousSizeInBytes: import("zod").ZodNumber;
+        currentSizeInBytes: import("zod").ZodNumber;
     }, import("zod/v4/core").$strip>], "operation">;
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "path_forbidden";
@@ -1120,12 +1148,16 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
         applied: import("zod").ZodArray<import("zod").ZodString>;
         skipped: import("zod").ZodArray<import("zod").ZodString>;
         tags: import("zod").ZodArray<import("zod").ZodString>;
+        previousSizeInBytes: import("zod").ZodNumber;
+        currentSizeInBytes: import("zod").ZodNumber;
     }, 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>;
+        previousSizeInBytes: import("zod").ZodNumber;
+        currentSizeInBytes: import("zod").ZodNumber;
     }, import("zod/v4/core").$strip>], "operation">;
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "path_forbidden";
@@ -1230,6 +1262,8 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
         append: "append";
         prepend: "prepend";
     }>;
+    previousSizeInBytes: import("zod").ZodNumber;
+    currentSizeInBytes: import("zod").ZodNumber;
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
@@ -1293,6 +1327,8 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
         search: import("zod").ZodString;
         count: import("zod").ZodNumber;
     }, import("zod/v4/core").$strip>>;
+    previousSizeInBytes: import("zod").ZodNumber;
+    currentSizeInBytes: import("zod").ZodNumber;
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
@@ -1425,6 +1461,8 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     path: import("zod").ZodString;
     sectionTargeted: import("zod").ZodBoolean;
     created: import("zod").ZodBoolean;
+    previousSizeInBytes: import("zod").ZodNumber;
+    currentSizeInBytes: import("zod").ZodNumber;
 }, import("zod/v4/core").$strip>, readonly [{
     readonly reason: "file_exists";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Conflict;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAiBH,gFAAgF;AAChF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAM/B,CAAC;AAEF,kFAAkF;AAClF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAQhC,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAoD,CAAC;AAErF,mHAAmH;AACnH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;+CAAiD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAiBH,gFAAgF;AAChF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAM/B,CAAC;AAEF,kFAAkF;AAClF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAQhC,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAoD,CAAC;AAErF,mHAAmH;AACnH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;+CAAiD,CAAC"}

package/dist/mcp-server/tools/definitions/obsidian-append-to-note.tool.d.ts

@@ -1,6 +1,9 @@
 /**
  * @fileoverview obsidian_append_to_note — append content to the end of a note,
  * or to the end of a heading/block/frontmatter section via PATCH-with-append.
+ * Whole-file appends are silently upserts (POST creates the file when the path
+ * does not exist), so the response surface flags `created` and `previousSize`
+ * for agent self-correction.
  * @module mcp-server/tools/definitions/obsidian-append-to-note.tool
  */
 import { z } from '@cyanheads/mcp-ts-core';
@@ -39,6 +42,9 @@ export declare const obsidianAppendToNote: import("@cyanheads/mcp-ts-core").Tool
 }, z.core.$strip>, z.ZodObject<{
     path: z.ZodString;
     sectionTargeted: z.ZodBoolean;
+    created: z.ZodBoolean;
+    previousSizeInBytes: z.ZodNumber;
+    currentSizeInBytes: z.ZodNumber;
 }, z.core.$strip>, readonly [{
     readonly reason: "path_forbidden";
     readonly code: JsonRpcErrorCode.Forbidden;

package/dist/mcp-server/tools/definitions/obsidian-append-to-note.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"obsidian-append-to-note.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/obsidian-append-to-note.tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAIjE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoG/B,CAAC"}
+{"version":3,"file":"obsidian-append-to-note.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/obsidian-append-to-note.tool.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAIjE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4I/B,CAAC"}

package/dist/mcp-server/tools/definitions/obsidian-append-to-note.tool.js

@@ -1,6 +1,9 @@
 /**
  * @fileoverview obsidian_append_to_note — append content to the end of a note,
  * or to the end of a heading/block/frontmatter section via PATCH-with-append.
+ * Whole-file appends are silently upserts (POST creates the file when the path
+ * does not exist), so the response surface flags `created` and `previousSize`
+ * for agent self-correction.
  * @module mcp-server/tools/definitions/obsidian-append-to-note.tool
  */
 import { tool, z } from '@cyanheads/mcp-ts-core';
@@ -8,7 +11,7 @@ import { JsonRpcErrorCode } from '@cyanheads/mcp-ts-core/errors';
 import { getObsidianService } from '../../../services/obsidian/obsidian-service.js';
 import { ContentTypeSchema, SectionSchema, TargetSchema } from './_shared/schemas.js';
 export const obsidianAppendToNote = tool('obsidian_append_to_note', {
-    description: 'Append content to a note. Without `section`, the body is appended to the end of the file. With `section`, the content is appended to the end of that heading/block/frontmatter; nested headings need `Parent::Child` syntax — use `obsidian_get_note` with `format: "document-map"` to discover available targets. For block-reference targets, content is concatenated adjacent to the block line without inserting a separator — include a leading newline in `content` if you want one. Set `createTargetIfMissing` to bring the target section into existence rather than failing when it does not exist.',
+    description: 'Append content to a note. **Without `section`: appends to the end of the file, or creates the file if it does not exist (your content becomes the full file).** With `section`: appends to the end of that heading/block/frontmatter; nested headings need `Parent::Child` syntax — use `obsidian_get_note` with `format: "document-map"` to discover available targets. For block-reference targets, content is concatenated adjacent to the block line without inserting a separator — include a leading newline in `content` if you want one. Set `createTargetIfMissing` to bring the target section into existence rather than failing when it does not exist.',
     annotations: { destructiveHint: true },
     input: z.object({
         target: TargetSchema.describe('Where the note lives.'),
@@ -24,7 +27,16 @@ export const obsidianAppendToNote = tool('obsidian_append_to_note', {
         path: z.string().describe('Resolved vault-relative path of the note.'),
         sectionTargeted: z
             .boolean()
-            .describe('True when the append went to a section; false for whole-file appends.'),
+            .describe('True when the append went to a heading/block/frontmatter section (PATCH); false for whole-file appends (POST).'),
+        created: z
+            .boolean()
+            .describe('True when the whole-file append created a new file. Always false for section appends — PATCH requires the file to exist. Best-effort under concurrent writers, racy between the existence check and the write.'),
+        previousSizeInBytes: z
+            .number()
+            .describe('Byte size of the note before the append. Zero when `created` is true.'),
+        currentSizeInBytes: z
+            .number()
+            .describe('Byte size of the note after the append, read from the upstream after the operation completed. Compare against `previousSizeInBytes` and your own content length to detect unexpected upstream behavior (e.g. auto-newline injection, concurrent writers).'),
     }),
     auth: ['tool:obsidian_append_to_note:write'],
     errors: [
@@ -67,9 +79,16 @@ export const obsidianAppendToNote = tool('obsidian_append_to_note', {
     ],
     async handler(input, ctx) {
         const svc = getObsidianService();
-        const { target } = input;
+        /**
+         * Resolve once and pin the rest of the flow to a path target so the
+         * presence probe and the write itself act on the same concrete file —
+         * avoids re-resolving `active` / `periodic` targets across calls.
+         */
+        const path = await svc.resolvePath(ctx, input.target);
+        const pathTarget = { type: 'path', path };
         if (input.section) {
-            await svc.patchNote(ctx, target, input.content, {
+            const previousSizeInBytes = await svc.getSize(ctx, pathTarget);
+            await svc.patchNote(ctx, pathTarget, input.content, {
                 operation: 'append',
                 targetType: input.section.type,
                 target: input.section.target,
@@ -77,21 +96,36 @@ export const obsidianAppendToNote = tool('obsidian_append_to_note', {
                 createTargetIfMissing: input.createTargetIfMissing,
                 contentType: input.contentType,
             });
-            const path = await svc.resolvePath(ctx, target);
-            return { path, sectionTargeted: true };
+            const currentSizeInBytes = await svc.getSize(ctx, pathTarget);
+            return {
+                path,
+                sectionTargeted: true,
+                created: false,
+                previousSizeInBytes,
+                currentSizeInBytes,
+            };
         }
-        await svc.appendToNote(ctx, target, input.content, input.contentType);
-        const path = await svc.resolvePath(ctx, target);
-        return { path, sectionTargeted: false };
+        const previousSizeInBytes = await svc.tryGetSize(ctx, pathTarget);
+        await svc.appendToNote(ctx, pathTarget, input.content, input.contentType);
+        const currentSizeInBytes = await svc.getSize(ctx, pathTarget);
+        return {
+            path,
+            sectionTargeted: false,
+            created: previousSizeInBytes === null,
+            previousSizeInBytes: previousSizeInBytes ?? 0,
+            currentSizeInBytes,
+        };
+    },
+    format: (result) => {
+        const action = result.created ? 'Created' : 'Appended to';
+        const lines = [`**${action} ${result.path}**`];
+        if (result.created) {
+            lines.push('*Note:* this file did not exist before — your content is now the entire file. If you expected to add to existing content, double-check the path.');
+        }
+        lines.push(`*Size:* ${result.previousSizeInBytes} → ${result.currentSizeInBytes} bytes`);
+        lines.push(`*Created:* ${result.created}`);
+        lines.push(`*Section targeted:* ${result.sectionTargeted}`);
+        return [{ type: 'text', text: lines.join('\n') }];
     },
-    format: (result) => [
-        {
-            type: 'text',
-            text: [
-                `**Appended to ${result.path}**`,
-                `*Section targeted:* ${result.sectionTargeted}`,
-            ].join('\n'),
-        },
-    ],
 });
 //# sourceMappingURL=obsidian-append-to-note.tool.js.map

package/dist/mcp-server/tools/definitions/obsidian-append-to-note.tool.js.map

@@ -1 +1 @@
-{"version":3,"file":"obsidian-append-to-note.tool.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/obsidian-append-to-note.tool.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"obsidian-append-to-note.tool.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/obsidian-append-to-note.tool.ts"],"names":[],"mappings":"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"}

package/dist/mcp-server/tools/definitions/obsidian-delete-note.tool.d.ts

@@ -26,6 +26,8 @@ export declare const obsidianDeleteNote: import("@cyanheads/mcp-ts-core").ToolDe
 }, z.core.$strip>, z.ZodObject<{
     path: z.ZodString;
     deleted: z.ZodBoolean;
+    previousSizeInBytes: z.ZodNumber;
+    currentSizeInBytes: z.ZodNumber;
 }, z.core.$strip>, readonly [{
     readonly reason: "path_forbidden";
     readonly code: JsonRpcErrorCode.Forbidden;

package/dist/mcp-server/tools/definitions/obsidian-delete-note.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"obsidian-delete-note.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/obsidian-delete-note.tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAIjE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsF7B,CAAC"}
+{"version":3,"file":"obsidian-delete-note.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/obsidian-delete-note.tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAIjE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqG7B,CAAC"}

package/dist/mcp-server/tools/definitions/obsidian-delete-note.tool.js

@@ -17,6 +17,12 @@ export const obsidianDeleteNote = tool('obsidian_delete_note', {
     output: z.object({
         path: z.string().describe('Resolved vault-relative path of the deleted note.'),
         deleted: z.boolean().describe('True when the file was removed.'),
+        previousSizeInBytes: z
+            .number()
+            .describe('Byte size of the note immediately before deletion. The destructive blast radius — useful for confirming the agent destroyed what it expected.'),
+        currentSizeInBytes: z
+            .number()
+            .describe('Always 0 after a successful delete — the file no longer exists.'),
     }),
     auth: ['tool:obsidian_delete_note:write'],
     errors: [
@@ -59,10 +65,16 @@ export const obsidianDeleteNote = tool('obsidian_delete_note', {
     ],
     async handler(input, ctx) {
         const svc = getObsidianService();
-        const { target } = input;
-        const path = await svc.resolvePath(ctx, target);
+        const path = await svc.resolvePath(ctx, input.target);
+        const pathTarget = { type: 'path', path };
+        /**
+         * Probe size before showing the elicitation prompt so the user sees how
+         * much they're about to destroy. Throws `note_missing` if the file is
+         * already gone — preempts a confusing post-elicit DELETE 404.
+         */
+        const previousSizeInBytes = await svc.getSize(ctx, pathTarget);
         if (ctx.elicit) {
-            const confirmed = await ctx.elicit(`Permanently delete '${path}'? This cannot be undone via the API; recovery would require Obsidian's local trash.`, z.object({
+            const confirmed = await ctx.elicit(`Permanently delete '${path}' (${previousSizeInBytes} bytes)? This cannot be undone via the API; recovery would require Obsidian's local trash.`, z.object({
                 confirm: z.boolean().describe('Set to true to delete the note. Any other value cancels.'),
             }));
             if (confirmed.action !== 'accept' || confirmed.content?.confirm !== true) {
@@ -72,13 +84,13 @@ export const obsidianDeleteNote = tool('obsidian_delete_note', {
                 });
             }
         }
-        await svc.deleteNote(ctx, target);
-        return { path, deleted: true };
+        await svc.deleteNote(ctx, pathTarget);
+        return { path, deleted: true, previousSizeInBytes, currentSizeInBytes: 0 };
     },
     format: (result) => [
         {
             type: 'text',
-            text: `**Deleted ${result.path}** (deleted: ${result.deleted})`,
+            text: `**Deleted ${result.path}** (size: ${result.previousSizeInBytes} → ${result.currentSizeInBytes} bytes)`,
         },
     ],
 });

package/dist/mcp-server/tools/definitions/obsidian-delete-note.tool.js.map

@@ -1 +1 @@
-{"version":3,"file":"obsidian-delete-note.tool.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/obsidian-delete-note.tool.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"obsidian-delete-note.tool.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/obsidian-delete-note.tool.ts"],"names":[],"mappings":"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"}

package/dist/mcp-server/tools/definitions/obsidian-manage-frontmatter.tool.d.ts

@@ -42,11 +42,15 @@ export declare const obsidianManageFrontmatter: import("@cyanheads/mcp-ts-core")
         path: z.ZodString;
         key: z.ZodString;
         frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        previousSizeInBytes: z.ZodNumber;
+        currentSizeInBytes: z.ZodNumber;
     }, z.core.$strip>, z.ZodObject<{
         operation: z.ZodLiteral<"delete">;
         path: z.ZodString;
         key: z.ZodString;
         frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        previousSizeInBytes: z.ZodNumber;
+        currentSizeInBytes: z.ZodNumber;
     }, z.core.$strip>], "operation">;
 }, z.core.$strip>, readonly [{
     readonly reason: "path_forbidden";

package/dist/mcp-server/tools/definitions/obsidian-manage-frontmatter.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"obsidian-manage-frontmatter.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/obsidian-manage-frontmatter.tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAKjE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4LpC,CAAC"}
+{"version":3,"file":"obsidian-manage-frontmatter.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/obsidian-manage-frontmatter.tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAKjE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkNpC,CAAC"}