mcp-scraper 0.5.0 → 0.7.0

package/dist/{chunk-BL7BBSYF.js → chunk-RUGJE5EB.js}

@@ -1,6 +1,6 @@
 import {
   LedgerOperation
-} from "./chunk-APJO2XV5.js";
+} from "./chunk-HL33CGJF.js";
 import {
   sanitizeVendorName
 } from "./chunk-M2S27J6Z.js";
@@ -127,4 +127,4 @@ export {
   failExtractJob,
   settleExtractJob
 };
-//# sourceMappingURL=chunk-BL7BBSYF.js.map
+//# sourceMappingURL=chunk-RUGJE5EB.js.map

package/dist/{chunk-J4T5OSCF.js → chunk-YGRZU7IR.js}

@@ -17,10 +17,10 @@ import {
 } from "./chunk-XGIPATLV.js";
 import {
   PACKAGE_VERSION
-} from "./chunk-3RTPEQJC.js";
+} from "./chunk-EGWJ74EX.js";
 import {
   MC_PER_CREDIT
-} from "./chunk-APJO2XV5.js";
+} from "./chunk-HL33CGJF.js";
 import {
   sanitizeVendorName
 } from "./chunk-M2S27J6Z.js";
@@ -199,7 +199,7 @@ Multi-step orchestrations \u2014 prefer these over hand-chaining primitives when
   read it back for full detail rather than expecting the whole payload inline.
 
 ## Memory
-mcp-scraper also exposes 74 persistent per-user memory tools (notes, facts, vaults,
+mcp-scraper also exposes persistent per-user memory tools (notes, facts, vaults,
 scheduled actions, tables, channels) backed by memory.mcpscraper.dev. Every account starts with 13
 vaults \u2014 call **list-vaults** to see what exists before creating anything new. Pick the vault whose job
 matches the content: **Ideas** (unvalidated concepts), **Knowledge** (distilled lessons/how-tos),
@@ -209,11 +209,45 @@ matches the content: **Ideas** (unvalidated concepts), **Knowledge** (distilled
 **Improvement Log** (receipts of changes made and whether they worked), **Experiments** (hypothesis +
 measured result), **Sprint** (current cycle's scope), **Inspiration** (other people's work worth
 studying).
-Before writing, call **memory-suggest** to check whether something's already captured and to find the
-right vault's hub note to link. Use **memory-put** for narrative notes (prose, a title, a body); use
+For a normal new narrative note, call **prepare-memory-write** first. It queries the live vault contract,
+tag vocabulary, and natural neighbor vaults, and returns interlink candidates that must be read before
+acceptance. Compose every returned template section, then call **memory-capture**, which validates the
+note, registers canonical tags, writes it, and verifies readback. Reserve low-level **memory-put** for
+deliberate edits and migrations. Use
 **table-create**/**table-insert-rows**/**table-query** instead when the caller wants row-shaped data
 they'll filter/sort by exact value. **memory-search** is meaning-based over full content (embeds, slower);
 **memory-list** filters one vault by kind/tags (fast, exact).
+
+Treat every memory create or update as a graph operation. **prepare-memory-write** supplies the initial
+shortlist; use **memory-search** when it is weak or the topic is broad, and **memory-get** to read the best
+candidates in full. Add only links supported by the notes: same-
+vault targets go in props.related and natural [[path]] body links; cross-vault targets go in
+props.related_vault_notes as Vault Name::relative/path.md. Prefer existing People/Projects/system
+hubs and fewer strong links. Do not trust a background linker to repair a weak write.
+
+Use the target vault's template, not generic prose. Always set summary, specific reusable tags,
+source_type, source_ref, related, related_vault_notes, embed, embed_priority, and a valid
+status; include vault-specific props when relevant. Body patterns: Knowledge = Thesis / Explanation /
+Examples / Implications; Library = Source Identity / Preserved Material / Extraction Notes; People =
+Identity / Relationship / Known Context / Interaction History / Open Loops; Projects = Purpose / Current
+State / Architecture / Open Work / Decisions; Issues = Observation / Impact / Confirmation / Evidence /
+Resolution; Improvement Log = Improvement / Issue Link / Change Made / Verification / Result. Keep Tasks,
+Calendar, Communications, Ideas, Inspiration, Experiments, and Sprint aligned to their named purpose.
+Tags are live vocabulary, not improvised labels: **list-memory-tags** shows what exists and
+**resolve-memory-tags** returns reuse/create/omit. A new tag is justified only when the concept is central,
+reusable, and has no exact, alias, or near-equivalent. Use **memory-backlinks**,
+**memory-graph-universe**, and **memory-graph-path** to trace the linked universe across vaults.
+
+Scrape deposits are raw evidence and therefore go to **Library** through **library-ingest**, with the full
+Library template and source metadata. If the source contains durable applicable guidance, create a separate
+Knowledge companion through prepare-memory-write + memory-capture and link it to the Library source with
+derived_from; do not replace the raw source with the guide.
+
+For an update, call **memory-get** first and pass its revision as baseRevision. Preserve the existing
+title, source, capture time, content context, and props unless the request deliberately changes them.
+If a legacy backend does not return props, do not overwrite an existing linked note through that surface;
+report that link preservation cannot be proved. After the write, read it back and search a distinctive
+phrase to verify persistence and indexing.
 `.trim();
 }
 var SERVER_INSTRUCTIONS = serverInstructions(true);
@@ -6877,6 +6911,52 @@ var UnlinkShareSchema = {
     openWorldHint: false
   }
 };
+var memoryCaptureTool_notePropsSchema = z3.object({
+  status: z3.string().describe("Status enum value from the target vault contract."),
+  summary: z3.string().describe("Short retrieval-ready description."),
+  tags: z3.array(z3.string()).describe("AI-generated keyword tags, not vault names."),
+  pinned: z3.boolean().describe("Recall boost for important notes."),
+  source_type: z3.string().describe("Attribution kind: user, person, url, file, channel, thread, or note."),
+  source_ref: z3.string().describe("Attribution reference (URL, path, channel, thread, or source note)."),
+  related: z3.array(z3.string()).describe("Same-vault links (wiki [[ ]] targets)."),
+  related_vault_notes: z3.array(z3.string()).describe('Cross-vault references in "Vault Name::relative/path.md" form.'),
+  embed: z3.boolean().describe("Whether Smart RAG should index the note."),
+  embed_priority: z3.enum(["low", "normal", "high"]).describe("Embedding priority."),
+  embedding_summary: z3.string().describe("Optional retrieval-specific summary."),
+  type: z3.string().describe("Note type from the target vault contract (also used to route the note)."),
+  domain: z3.string().describe("Domain folder for Library/Knowledge (AI, SEO, Copywriting & Ads, Business, Spirituality)."),
+  folder: z3.string().describe("Explicit sub-folder within the vault; overrides routing-derived folder."),
+  parentMessageId: z3.string().describe("Channel messages only: the path of the top-level message this is a reply to. Absent on top-level messages.")
+}).partial().passthrough();
+var MemoryCaptureSchema = {
+  id: "memory-capture",
+  upstreamName: "memoryCaptureTool",
+  description: "Strict normal-create path for durable memory. Refuses incomplete notes, writes through memory-put, registers canonical tags, and reads the note back to verify persisted content and props. Call prepare-memory-write first. Reserve memory-put for low-level migrations or deliberate edits.",
+  input: {
+    vault: z3.string(),
+    folder: z3.string().optional(),
+    path: z3.string().min(1),
+    title: z3.string().min(1),
+    content: z3.string().min(1),
+    props: memoryCaptureTool_notePropsSchema,
+    baseRevision: z3.number().optional(),
+    tagDecisions: z3.array(z3.object({ tag: z3.string().min(1), central: z3.boolean(), reusable: z3.boolean(), description: z3.string().optional() })).max(8).optional().describe("Required justification for any tag that does not already exist. Existing exact/alias/near tags are canonicalized automatically; a new tag is accepted only when its matching decision has central=true and reusable=true.")
+  },
+  output: {
+    ok: z3.boolean(),
+    valid: z3.boolean().optional(),
+    errors: z3.array(z3.string()).optional(),
+    warnings: z3.array(z3.string()).optional(),
+    tagResolutions: z3.array(z3.object({ candidate: z3.string(), action: z3.enum(["reuse", "create", "omit"]), tag: z3.string().optional(), reason: z3.string() })).optional(),
+    note: z3.object({ path: z3.string(), title: z3.string(), updatedAt: z3.string(), revision: z3.number() }).optional(),
+    indexed: z3.number().optional(),
+    verified: z3.object({ contentBytes: z3.number(), propsPersisted: z3.boolean(), revision: z3.number() }).optional(),
+    conflict: z3.boolean().optional(),
+    code: z3.string().optional(),
+    error: z3.string().optional()
+  },
+  annotations: { title: "Capture Governed Memory", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+};
 var MemoryQuestionsSchema = {
   id: "memory-questions",
   upstreamName: "memoryQuestionsTool",
@@ -6906,6 +6986,67 @@ var MemoryQuestionsSchema = {
     openWorldHint: true
   }
 };
+var PrepareMemoryWriteSchema = {
+  id: "prepare-memory-write",
+  upstreamName: "prepareMemoryWriteTool",
+  description: "Mandatory planning pass for a normal new memory. Routes the note, returns the live template and natural vault relationships, resolves proposed tags against the registry, and shortlists interlink opportunities that must be read/reviewed before capture.",
+  input: {
+    title: z3.string().min(1),
+    content: z3.string().min(1),
+    source: z3.string().optional(),
+    type: z3.string().optional(),
+    vault: z3.string().optional(),
+    tagCandidates: z3.array(z3.object({ tag: z3.string().min(1), central: z3.boolean().optional(), reusable: z3.boolean().optional(), description: z3.string().optional() })).max(20).optional(),
+    maxLinks: z3.number().int().min(1).max(20).optional()
+  },
+  output: {
+    ok: z3.boolean(),
+    route: z3.record(z3.unknown()).optional(),
+    contract: z3.record(z3.unknown()).optional(),
+    tagResolutions: z3.array(z3.record(z3.unknown())).optional(),
+    linkOpportunities: z3.array(z3.record(z3.unknown())).optional(),
+    instructions: z3.array(z3.string()).optional(),
+    error: z3.string().optional()
+  },
+  annotations: { title: "Prepare Memory Write", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
+var validateMemoryWriteTool_notePropsSchema = z3.object({
+  status: z3.string().describe("Status enum value from the target vault contract."),
+  summary: z3.string().describe("Short retrieval-ready description."),
+  tags: z3.array(z3.string()).describe("AI-generated keyword tags, not vault names."),
+  pinned: z3.boolean().describe("Recall boost for important notes."),
+  source_type: z3.string().describe("Attribution kind: user, person, url, file, channel, thread, or note."),
+  source_ref: z3.string().describe("Attribution reference (URL, path, channel, thread, or source note)."),
+  related: z3.array(z3.string()).describe("Same-vault links (wiki [[ ]] targets)."),
+  related_vault_notes: z3.array(z3.string()).describe('Cross-vault references in "Vault Name::relative/path.md" form.'),
+  embed: z3.boolean().describe("Whether Smart RAG should index the note."),
+  embed_priority: z3.enum(["low", "normal", "high"]).describe("Embedding priority."),
+  embedding_summary: z3.string().describe("Optional retrieval-specific summary."),
+  type: z3.string().describe("Note type from the target vault contract (also used to route the note)."),
+  domain: z3.string().describe("Domain folder for Library/Knowledge (AI, SEO, Copywriting & Ads, Business, Spirituality)."),
+  folder: z3.string().describe("Explicit sub-folder within the vault; overrides routing-derived folder."),
+  parentMessageId: z3.string().describe("Channel messages only: the path of the top-level message this is a reply to. Absent on top-level messages.")
+}).partial().passthrough();
+var ValidateMemoryWriteSchema = {
+  id: "validate-memory-write",
+  upstreamName: "validateMemoryWriteTool",
+  description: "Validate a proposed governed note without writing it. Checks template completeness, vault status/type, canonical tag count, attribution, Obsidian link primitives, and retrieval metadata.",
+  input: {
+    vault: z3.string(),
+    title: z3.string(),
+    content: z3.string(),
+    props: validateMemoryWriteTool_notePropsSchema
+  },
+  output: {
+    ok: z3.boolean(),
+    valid: z3.boolean().optional(),
+    errors: z3.array(z3.string()).optional(),
+    warnings: z3.array(z3.string()).optional(),
+    normalizedTags: z3.array(z3.string()).optional(),
+    error: z3.string().optional()
+  },
+  annotations: { title: "Validate Memory Write", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
 var CreateChannelSchema = {
   id: "create-channel",
   upstreamName: "createChannelTool",
@@ -7246,18 +7387,78 @@ var RecordFactSchema = {
     openWorldHint: false
   }
 };
+var NoteBacklinksSchema = {
+  id: "memory-backlinks",
+  upstreamName: "noteBacklinksTool",
+  description: "Return every resolved incoming link to a note across all accessible vaults, including typed metadata links and Obsidian wiki links.",
+  input: {
+    note: z3.string().min(1),
+    vault: z3.string().optional()
+  },
+  output: {
+    ok: z3.boolean(),
+    nodes: z3.array(z3.object({ id: z3.string(), vault: z3.string(), path: z3.string(), title: z3.string(), resolved: z3.boolean() })).optional(),
+    edges: z3.array(z3.object({ source: z3.string(), target: z3.string(), type: z3.string(), evidence: z3.string(), sourceField: z3.string(), resolved: z3.boolean() })).optional(),
+    error: z3.string().optional()
+  },
+  annotations: { title: "Memory Backlinks", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
+var GraphPathSchema = {
+  id: "memory-graph-path",
+  upstreamName: "graphPathTool",
+  description: "Find the shortest navigable connection between two memory notes across vault boundaries. Returns an empty graph when no path exists within maxDepth.",
+  input: {
+    from: z3.string().min(1),
+    to: z3.string().min(1),
+    fromVault: z3.string().optional(),
+    toVault: z3.string().optional(),
+    maxDepth: z3.number().int().min(1).max(12).optional()
+  },
+  output: {
+    ok: z3.boolean(),
+    nodes: z3.array(z3.object({ id: z3.string(), vault: z3.string(), path: z3.string(), title: z3.string(), resolved: z3.boolean() })).optional(),
+    edges: z3.array(z3.object({ source: z3.string(), target: z3.string(), type: z3.string(), evidence: z3.string(), sourceField: z3.string(), resolved: z3.boolean() })).optional(),
+    error: z3.string().optional()
+  },
+  annotations: { title: "Memory Graph Path", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
+var GraphUniverseSchema = {
+  id: "memory-graph-universe",
+  upstreamName: "graphUniverseTool",
+  description: "Traverse the interlinked memory universe around one note in every direction, like an Obsidian local graph. Returns nodes and typed edges to a bounded depth.",
+  input: {
+    note: z3.string().min(1),
+    vault: z3.string().optional(),
+    depth: z3.number().int().min(0).max(6).optional(),
+    maxNodes: z3.number().int().min(1).max(500).optional()
+  },
+  output: {
+    ok: z3.boolean(),
+    root: z3.string().optional(),
+    depth: z3.number().optional(),
+    truncated: z3.boolean().optional(),
+    nodes: z3.array(z3.object({ id: z3.string(), vault: z3.string(), path: z3.string(), title: z3.string(), resolved: z3.boolean() })).optional(),
+    edges: z3.array(z3.object({ source: z3.string(), target: z3.string(), type: z3.string(), evidence: z3.string(), sourceField: z3.string(), resolved: z3.boolean() })).optional(),
+    error: z3.string().optional()
+  },
+  annotations: { title: "Memory Graph Universe", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
 var LibraryIngestSchema = {
   id: "library-ingest",
   upstreamName: "libraryIngestTool",
   description: "Deposit a scrape, transcript, or generated output into the tenant Library vault for later semantic recall. Content is embedded for per-tenant search and best-effort mirrored to a local vault when configured. Requires write scope on the target vault.",
   input: {
     vault: z3.string().optional().describe(
-      'Vault to deposit into. Optional; defaults to the session active vault, then the first entitled vault, then "Library".'
+      "Vault to deposit into. Optional and normally omitted: raw scrapes always default to Library. Override only for a deliberate nonstandard migration."
     ),
     title: z3.string().min(1).describe("Short human-readable title for the item; used to build the stored path. Must be non-empty."),
     content: z3.string().min(1).describe("The full captured text (scrape/transcript/output) to store and index. Must be non-empty."),
     source: z3.string().min(1).describe("Provenance of the content, e.g. a URL or tool name. Must be non-empty."),
     capturedAt: z3.string().optional().describe("ISO-8601 capture timestamp. Optional; defaults to now. Also seeds the deterministic storage path."),
+    summary: z3.string().optional().describe("Retrieval-ready source summary. Optional; a provenance summary is generated when omitted."),
+    tags: z3.array(z3.string()).max(8).optional().describe("Reviewed canonical tags. Existing tags should be resolved first; when omitted, deterministic source/topic tags are generated."),
+    related: z3.array(z3.string()).optional().describe("Reviewed same-vault Library note paths."),
+    relatedVaultNotes: z3.array(z3.string()).optional().describe("Reviewed cross-vault references in Vault::path.md form."),
     localVaultPath: z3.string().optional().describe("Filesystem root to also mirror the item to. Optional; falls back to MEMORY_LOCAL_VAULT_ROOT env when set.")
   },
   output: {
@@ -7267,6 +7468,7 @@ var LibraryIngestSchema = {
     path: z3.string().optional().describe("Vault-relative path the item was stored at (under library/...)."),
     indexed: z3.number().optional().describe("Number of search chunks indexed (0 if embedding failed but the note still saved)."),
     dualWritten: z3.boolean().optional().describe("True if the item was also mirrored to the local filesystem vault."),
+    nextStep: z3.string().optional().describe("Recommended extraction action after the raw Library source is safe."),
     code: z3.string().optional().describe("Machine-readable denial code when ok is false: quota_exceeded or free_cost_cap."),
     error: z3.string().optional().describe("Human-readable failure reason when ok is false.")
   },
@@ -7344,10 +7546,27 @@ var ExportSchema = {
     openWorldHint: false
   }
 };
+var getTool_notePropsSchema = z3.object({
+  status: z3.string().describe("Status enum value from the target vault contract."),
+  summary: z3.string().describe("Short retrieval-ready description."),
+  tags: z3.array(z3.string()).describe("AI-generated keyword tags, not vault names."),
+  pinned: z3.boolean().describe("Recall boost for important notes."),
+  source_type: z3.string().describe("Attribution kind: user, person, url, file, channel, thread, or note."),
+  source_ref: z3.string().describe("Attribution reference (URL, path, channel, thread, or source note)."),
+  related: z3.array(z3.string()).describe("Same-vault links (wiki [[ ]] targets)."),
+  related_vault_notes: z3.array(z3.string()).describe('Cross-vault references in "Vault Name::relative/path.md" form.'),
+  embed: z3.boolean().describe("Whether Smart RAG should index the note."),
+  embed_priority: z3.enum(["low", "normal", "high"]).describe("Embedding priority."),
+  embedding_summary: z3.string().describe("Optional retrieval-specific summary."),
+  type: z3.string().describe("Note type from the target vault contract (also used to route the note)."),
+  domain: z3.string().describe("Domain folder for Library/Knowledge (AI, SEO, Copywriting & Ads, Business, Spirituality)."),
+  folder: z3.string().describe("Explicit sub-folder within the vault; overrides routing-derived folder."),
+  parentMessageId: z3.string().describe("Channel messages only: the path of the top-level message this is a reply to. Absent on top-level messages.")
+}).partial().passthrough();
 var GetSchema = {
   id: "memory-get",
   upstreamName: "getTool",
-  description: "Read a single note from a vault by its exact path, or by shareId for a note shared with you and accepted. Returns a revision number \u2014 pass it as baseRevision on a later memory-put/delete-note to detect a concurrent edit instead of silently overwriting it. Requires read scope.",
+  description: "Read a single note from a vault by its exact path, or by shareId for a note shared with you and accepted. Owned notes include their stored Obsidian props so edits can preserve links and template metadata. Returns a revision number \u2014 pass it as baseRevision on a later memory-put/delete-note to detect a concurrent edit instead of silently overwriting it. Requires read scope.",
   input: {
     vault: z3.string().optional().describe(
       "Vault to read from. Optional; defaults to the session active vault, then the first vault the caller is entitled to. Ignored when shareId is given."
@@ -7367,6 +7586,7 @@ var GetSchema = {
       capturedAt: z3.string().describe("ISO-8601 timestamp of when the note was first captured."),
       revision: z3.number().describe("Current revision number. Pass this as baseRevision when editing, so a concurrent edit by someone else is detected instead of silently overwritten."),
       updatedBy: z3.string().nullable().describe("Identity that made the last write, if known."),
+      props: getTool_notePropsSchema.optional().describe("Stored Obsidian metadata for an owned note, including links and vault-specific template fields. Omitted for secure or individually shared notes."),
       sharedBy: z3.string().optional().describe("Present only when read via shareId: the identity who owns and shared this note."),
       othersEditing: z3.array(z3.string()).optional().describe("Advisory only, not a lock: identities who read this same note within the last ~2 minutes and may be about to edit it. Worth a heads-up to the human before you write; the real safety net is still baseRevision on the write itself.")
     }).optional().describe("The full note. Present when ok is true."),
@@ -7414,7 +7634,7 @@ var ListSchema = {
     openWorldHint: false
   }
 };
-var notePropsSchema = z3.object({
+var putTool_notePropsSchema = z3.object({
   status: z3.string().describe("Status enum value from the target vault contract."),
   summary: z3.string().describe("Short retrieval-ready description."),
   tags: z3.array(z3.string()).describe("AI-generated keyword tags, not vault names."),
@@ -7430,7 +7650,7 @@ var notePropsSchema = z3.object({
   domain: z3.string().describe("Domain folder for Library/Knowledge (AI, SEO, Copywriting & Ads, Business, Spirituality)."),
   folder: z3.string().describe("Explicit sub-folder within the vault; overrides routing-derived folder."),
   parentMessageId: z3.string().describe("Channel messages only: the path of the top-level message this is a reply to. Absent on top-level messages.")
-}).partial();
+}).partial().passthrough();
 var PutSchema = {
   id: "memory-put",
   upstreamName: "putTool",
@@ -7443,7 +7663,7 @@ var PutSchema = {
     shareId: z3.string().optional().describe("Edit a note someone individually shared with you and you accepted (accept-share), by its shareId, instead of vault+path. Requires the share to grant edit permission, and baseRevision is mandatory (get the current revision first) since you are editing alongside the owner and possibly others."),
     title: z3.string().optional().describe("Optional human-readable title; defaults are derived from the path when omitted."),
     content: z3.string().min(1).describe("The full note body to store and index for semantic search. Must be non-empty."),
-    props: notePropsSchema.optional().describe("Obsidian note primitives (status, summary, tags, pinned, source_type, source_ref, related, related_vault_notes, embed, embed_priority, type, domain, folder). Stored on the note so it round-trips the vault shape; type/domain/folder also steer routing when no vault is given."),
+    props: putTool_notePropsSchema.optional().describe("Obsidian note primitives plus vault-specific template fields. On edits, supplied fields patch the stored props instead of replacing the whole object; pass an empty array to deliberately clear a link list. Type/domain/folder also steer routing when no vault is given."),
     baseRevision: z3.number().optional().describe("Revision the edit is based on (from a prior get/put). When provided, the write only applies if the note is still at this revision; otherwise it is rejected as a conflict instead of silently overwriting a concurrent edit. Omit for last-write-wins (fine for solo notes).")
   },
   output: {
@@ -8057,6 +8277,51 @@ var QueryTableSchema = {
     openWorldHint: false
   }
 };
+var ListTagsSchema = {
+  id: "list-memory-tags",
+  upstreamName: "listTagsTool",
+  description: "List the live canonical tag vocabulary, aliases, usage counts, and per-vault distribution. Use this before choosing tags so existing concepts are reused instead of fragmented.",
+  input: {
+    includeDeprecated: z3.boolean().optional()
+  },
+  output: {
+    ok: z3.boolean(),
+    tags: z3.array(z3.object({ tag: z3.string(), description: z3.string().nullable(), aliases: z3.array(z3.string()), status: z3.enum(["active", "deprecated"]), usageCount: z3.number(), vaultUsage: z3.record(z3.number()) })).optional(),
+    error: z3.string().optional()
+  },
+  annotations: { title: "List Memory Tags", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
+var ResolveTagsSchema = {
+  id: "resolve-memory-tags",
+  upstreamName: "resolveTagsTool",
+  description: "Resolve proposed concepts against the live tag vocabulary. Returns reuse, create, or omit. A new tag is allowed only when no equivalent exists and the caller marks the concept central and reusable.",
+  input: {
+    candidates: z3.array(z3.object({ tag: z3.string().min(1), central: z3.boolean().optional(), reusable: z3.boolean().optional(), description: z3.string().optional() })).min(1).max(20)
+  },
+  output: {
+    ok: z3.boolean(),
+    resolutions: z3.array(z3.object({ candidate: z3.string(), normalized: z3.string(), action: z3.enum(["reuse", "create", "omit"]), tag: z3.string().optional(), matchedBy: z3.enum(["exact", "alias", "near"]).optional(), score: z3.number().optional(), reason: z3.string() })).optional(),
+    error: z3.string().optional()
+  },
+  annotations: { title: "Resolve Memory Tags", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
+var UpsertTagSchema = {
+  id: "upsert-memory-tag",
+  upstreamName: "upsertTagTool",
+  description: "Define or curate one canonical tag, its meaning, aliases, and lifecycle. Use only after resolve-memory-tags returns create, or to merge/deprecate vocabulary intentionally. Requires write scope.",
+  input: {
+    tag: z3.string().min(1),
+    description: z3.string().optional(),
+    aliases: z3.array(z3.string()).optional(),
+    status: z3.enum(["active", "deprecated"]).optional()
+  },
+  output: {
+    ok: z3.boolean(),
+    tag: z3.object({ tag: z3.string(), description: z3.string().nullable(), aliases: z3.array(z3.string()), status: z3.enum(["active", "deprecated"]) }).optional(),
+    error: z3.string().optional()
+  },
+  annotations: { title: "Upsert Memory Tag", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
 var AddVaultSchema = {
   id: "add-vault",
   upstreamName: "addVaultTool",
@@ -8124,6 +8389,21 @@ var DeleteVaultSchema = {
     openWorldHint: false
   }
 };
+var GetVaultContractSchema = {
+  id: "get-vault-contract",
+  upstreamName: "getVaultContractTool",
+  description: "Read the machine-enforced purpose, template, statuses, types, natural neighbor vaults, and typed relationship guidance for one of the 13 governed Obsidian-style vaults. Call before composing a note when the correct shape is uncertain.",
+  input: {
+    vault: z3.string().describe("One governed vault: Ideas, Inspiration, Knowledge, Library, People, Communications, Calendar, Tasks, Projects, Issues, Improvement Log, Experiments, or Sprint.")
+  },
+  output: {
+    ok: z3.boolean(),
+    vault: z3.string().optional(),
+    contract: z3.record(z3.unknown()).optional(),
+    error: z3.string().optional()
+  },
+  annotations: { title: "Get Vault Contract", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
 var ListSharedWithMeSchema = {
   id: "list-shared-with-me",
   upstreamName: "listSharedWithMeTool",
@@ -8208,6 +8488,26 @@ var ProvisionDefaultsSchema = {
     openWorldHint: false
   }
 };
+var RouteMemorySchema = {
+  id: "route-memory",
+  upstreamName: "routeMemoryTool",
+  description: "Choose the correct governed vault and folder from content intent. Raw scraped/source material routes to Library; distilled applicable guidance routes to Knowledge. Returns the live vault contract so the result does not depend on prompt memory.",
+  input: {
+    title: z3.string().min(1),
+    content: z3.string().min(1),
+    type: z3.string().optional(),
+    source: z3.string().optional()
+  },
+  output: {
+    ok: z3.boolean(),
+    vault: z3.string().optional(),
+    folder: z3.string().optional(),
+    reason: z3.string().optional(),
+    contract: z3.record(z3.unknown()).optional(),
+    error: z3.string().optional()
+  },
+  annotations: { title: "Route Memory", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
 var VideoAnalyzeStartSchema = {
   id: "video-analyze-start",
   upstreamName: "videoAnalyzeStartTool",
@@ -8330,7 +8630,10 @@ var MEMORY_TOOL_SCHEMAS = [
   SwapVaultSchema,
   SwitchAccountSchema,
   UnlinkShareSchema,
+  MemoryCaptureSchema,
   MemoryQuestionsSchema,
+  PrepareMemoryWriteSchema,
+  ValidateMemoryWriteSchema,
   CreateChannelSchema,
   GetMessageNoteSchema,
   ListChannelMembersSchema,
@@ -8343,6 +8646,9 @@ var MEMORY_TOOL_SCHEMAS = [
   ReplyMessageSchema,
   FactHistorySchema,
   RecordFactSchema,
+  NoteBacklinksSchema,
+  GraphPathSchema,
+  GraphUniverseSchema,
   LibraryIngestSchema,
   DeleteNoteSchema,
   ExportSchema,
@@ -8372,12 +8678,17 @@ var MEMORY_TOOL_SCHEMAS = [
   InsertTableRowsSchema,
   ListTablesSchema,
   QueryTableSchema,
+  ListTagsSchema,
+  ResolveTagsSchema,
+  UpsertTagSchema,
   AddVaultSchema,
   CreateSecureVaultSchema,
   DeleteVaultSchema,
+  GetVaultContractSchema,
   ListSharedWithMeSchema,
   ListVaultsSchema,
   ProvisionDefaultsSchema,
+  RouteMemorySchema,
   VideoAnalyzeStartSchema,
   VideoAnalyzeStatusSchema,
   CreateWebhookSchema,
@@ -8456,4 +8767,4 @@ export {
   registerMemoryMcpTools,
   MemoryMcpToolExecutor
 };
-//# sourceMappingURL=chunk-J4T5OSCF.js.map
+//# sourceMappingURL=chunk-YGRZU7IR.js.map