mcp-scraper 0.5.0 → 0.6.0

package/dist/bin/api-server.cjs

@@ -17147,9 +17147,6 @@ async function memoryCall(toolName, args, userMemoryKey) {
     return { ok: false, error: err?.message ?? "memory call failed" };
   }
 }
-function personalVault(user) {
-  return `mcp-${user.id}`;
-}
 function memoryIdentity(user) {
   return user.email;
 }
@@ -27305,7 +27302,7 @@ var PACKAGE_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    PACKAGE_VERSION = "0.5.0";
+    PACKAGE_VERSION = "0.6.0";
   }
 });
 
@@ -27404,7 +27401,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),
@@ -27414,11 +27411,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;
@@ -31078,7 +31109,7 @@ var init_browser_agent_mcp_server = __esm({
 });
 
 // src/mcp/memory-tool-schemas.ts
-var import_zod35, AcceptShareSchema, ApproveSenderSchema, DeclineShareSchema, GetChatLinkSchema, InboxSettingsSchema, InviteAccountSchema, issueKeyTool_scopeShape, IssueKeySchema, ListApprovedSendersSchema, ListKeysSchema, NoteInboxSchema, RemoveApprovedSenderSchema, RevokeChatLinkSchema, RevokeKeySchema, RevokeShareSchema, SetAgentIdentitySchema, SetScopeSchema, ShareNoteSchema, ShareVaultSchema, SwapVaultSchema, SwitchAccountSchema, UnlinkShareSchema, MemoryQuestionsSchema, CreateChannelSchema, GetMessageNoteSchema, ListChannelMembersSchema, ListChannelMessagesSchema, MyMentionsSchema, PollChannelSchema, PostMessageSchema, ReactMessageSchema, RemoveChannelMemberSchema, ReplyMessageSchema, factHistoryTool_entryShape, FactHistorySchema, recordFactTool_factShape, RecordFactSchema, LibraryIngestSchema, DeleteNoteSchema, ExportSchema, GetSchema, ListSchema, notePropsSchema, PutSchema, SearchSchema, SuggestSchema, UploadSchema, TemporalRecallSchema, CreateScheduledActionSchema, DeleteScheduledActionSchema, GetScheduleLinkSchema, GetScheduleStatusSchema, ListScheduledActionsSchema, PauseScheduledActionSchema, ProposeScheduledActionSchema, ResumeScheduledActionSchema, RevokeScheduleLinkSchema, SetScheduleEntitlementSchema, CostUsageSchema, StorageUsageSchema, CreateTableSchema, deleteTableRowsTool_FilterSchema, DeleteTableRowsSchema, DescribeTableSchema, DropTableSchema, InsertTableRowsSchema, ListTablesSchema, queryTableTool_FilterSchema, QueryTableSchema, AddVaultSchema, CreateSecureVaultSchema, DeleteVaultSchema, ListSharedWithMeSchema, ListVaultsSchema, ProvisionDefaultsSchema, VideoAnalyzeStartSchema, VideoAnalyzeStatusSchema, CreateWebhookSchema, ListWebhooksSchema, RevokeWebhookSchema, MEMORY_TOOL_SCHEMAS;
+var import_zod35, AcceptShareSchema, ApproveSenderSchema, DeclineShareSchema, GetChatLinkSchema, InboxSettingsSchema, InviteAccountSchema, issueKeyTool_scopeShape, IssueKeySchema, ListApprovedSendersSchema, ListKeysSchema, NoteInboxSchema, RemoveApprovedSenderSchema, RevokeChatLinkSchema, RevokeKeySchema, RevokeShareSchema, SetAgentIdentitySchema, SetScopeSchema, ShareNoteSchema, ShareVaultSchema, SwapVaultSchema, SwitchAccountSchema, UnlinkShareSchema, memoryCaptureTool_notePropsSchema, MemoryCaptureSchema, MemoryQuestionsSchema, PrepareMemoryWriteSchema, validateMemoryWriteTool_notePropsSchema, ValidateMemoryWriteSchema, CreateChannelSchema, GetMessageNoteSchema, ListChannelMembersSchema, ListChannelMessagesSchema, MyMentionsSchema, PollChannelSchema, PostMessageSchema, ReactMessageSchema, RemoveChannelMemberSchema, ReplyMessageSchema, factHistoryTool_entryShape, FactHistorySchema, recordFactTool_factShape, RecordFactSchema, NoteBacklinksSchema, GraphPathSchema, GraphUniverseSchema, LibraryIngestSchema, DeleteNoteSchema, ExportSchema, getTool_notePropsSchema, GetSchema, ListSchema, putTool_notePropsSchema, PutSchema, SearchSchema, SuggestSchema, UploadSchema, TemporalRecallSchema, CreateScheduledActionSchema, DeleteScheduledActionSchema, GetScheduleLinkSchema, GetScheduleStatusSchema, ListScheduledActionsSchema, PauseScheduledActionSchema, ProposeScheduledActionSchema, ResumeScheduledActionSchema, RevokeScheduleLinkSchema, SetScheduleEntitlementSchema, CostUsageSchema, StorageUsageSchema, CreateTableSchema, deleteTableRowsTool_FilterSchema, DeleteTableRowsSchema, DescribeTableSchema, DropTableSchema, InsertTableRowsSchema, ListTablesSchema, queryTableTool_FilterSchema, QueryTableSchema, ListTagsSchema, ResolveTagsSchema, UpsertTagSchema, AddVaultSchema, CreateSecureVaultSchema, DeleteVaultSchema, GetVaultContractSchema, ListSharedWithMeSchema, ListVaultsSchema, ProvisionDefaultsSchema, RouteMemorySchema, VideoAnalyzeStartSchema, VideoAnalyzeStatusSchema, CreateWebhookSchema, ListWebhooksSchema, RevokeWebhookSchema, MEMORY_TOOL_SCHEMAS;
 var init_memory_tool_schemas = __esm({
   "src/mcp/memory-tool-schemas.ts"() {
     "use strict";
@@ -31587,6 +31618,52 @@ var init_memory_tool_schemas = __esm({
         openWorldHint: false
       }
     };
+    memoryCaptureTool_notePropsSchema = import_zod35.z.object({
+      status: import_zod35.z.string().describe("Status enum value from the target vault contract."),
+      summary: import_zod35.z.string().describe("Short retrieval-ready description."),
+      tags: import_zod35.z.array(import_zod35.z.string()).describe("AI-generated keyword tags, not vault names."),
+      pinned: import_zod35.z.boolean().describe("Recall boost for important notes."),
+      source_type: import_zod35.z.string().describe("Attribution kind: user, person, url, file, channel, thread, or note."),
+      source_ref: import_zod35.z.string().describe("Attribution reference (URL, path, channel, thread, or source note)."),
+      related: import_zod35.z.array(import_zod35.z.string()).describe("Same-vault links (wiki [[ ]] targets)."),
+      related_vault_notes: import_zod35.z.array(import_zod35.z.string()).describe('Cross-vault references in "Vault Name::relative/path.md" form.'),
+      embed: import_zod35.z.boolean().describe("Whether Smart RAG should index the note."),
+      embed_priority: import_zod35.z.enum(["low", "normal", "high"]).describe("Embedding priority."),
+      embedding_summary: import_zod35.z.string().describe("Optional retrieval-specific summary."),
+      type: import_zod35.z.string().describe("Note type from the target vault contract (also used to route the note)."),
+      domain: import_zod35.z.string().describe("Domain folder for Library/Knowledge (AI, SEO, Copywriting & Ads, Business, Spirituality)."),
+      folder: import_zod35.z.string().describe("Explicit sub-folder within the vault; overrides routing-derived folder."),
+      parentMessageId: import_zod35.z.string().describe("Channel messages only: the path of the top-level message this is a reply to. Absent on top-level messages.")
+    }).partial().passthrough();
+    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: import_zod35.z.string(),
+        folder: import_zod35.z.string().optional(),
+        path: import_zod35.z.string().min(1),
+        title: import_zod35.z.string().min(1),
+        content: import_zod35.z.string().min(1),
+        props: memoryCaptureTool_notePropsSchema,
+        baseRevision: import_zod35.z.number().optional(),
+        tagDecisions: import_zod35.z.array(import_zod35.z.object({ tag: import_zod35.z.string().min(1), central: import_zod35.z.boolean(), reusable: import_zod35.z.boolean(), description: import_zod35.z.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: import_zod35.z.boolean(),
+        valid: import_zod35.z.boolean().optional(),
+        errors: import_zod35.z.array(import_zod35.z.string()).optional(),
+        warnings: import_zod35.z.array(import_zod35.z.string()).optional(),
+        tagResolutions: import_zod35.z.array(import_zod35.z.object({ candidate: import_zod35.z.string(), action: import_zod35.z.enum(["reuse", "create", "omit"]), tag: import_zod35.z.string().optional(), reason: import_zod35.z.string() })).optional(),
+        note: import_zod35.z.object({ path: import_zod35.z.string(), title: import_zod35.z.string(), updatedAt: import_zod35.z.string(), revision: import_zod35.z.number() }).optional(),
+        indexed: import_zod35.z.number().optional(),
+        verified: import_zod35.z.object({ contentBytes: import_zod35.z.number(), propsPersisted: import_zod35.z.boolean(), revision: import_zod35.z.number() }).optional(),
+        conflict: import_zod35.z.boolean().optional(),
+        code: import_zod35.z.string().optional(),
+        error: import_zod35.z.string().optional()
+      },
+      annotations: { title: "Capture Governed Memory", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    };
     MemoryQuestionsSchema = {
       id: "memory-questions",
       upstreamName: "memoryQuestionsTool",
@@ -31616,6 +31693,67 @@ var init_memory_tool_schemas = __esm({
         openWorldHint: true
       }
     };
+    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: import_zod35.z.string().min(1),
+        content: import_zod35.z.string().min(1),
+        source: import_zod35.z.string().optional(),
+        type: import_zod35.z.string().optional(),
+        vault: import_zod35.z.string().optional(),
+        tagCandidates: import_zod35.z.array(import_zod35.z.object({ tag: import_zod35.z.string().min(1), central: import_zod35.z.boolean().optional(), reusable: import_zod35.z.boolean().optional(), description: import_zod35.z.string().optional() })).max(20).optional(),
+        maxLinks: import_zod35.z.number().int().min(1).max(20).optional()
+      },
+      output: {
+        ok: import_zod35.z.boolean(),
+        route: import_zod35.z.record(import_zod35.z.unknown()).optional(),
+        contract: import_zod35.z.record(import_zod35.z.unknown()).optional(),
+        tagResolutions: import_zod35.z.array(import_zod35.z.record(import_zod35.z.unknown())).optional(),
+        linkOpportunities: import_zod35.z.array(import_zod35.z.record(import_zod35.z.unknown())).optional(),
+        instructions: import_zod35.z.array(import_zod35.z.string()).optional(),
+        error: import_zod35.z.string().optional()
+      },
+      annotations: { title: "Prepare Memory Write", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    };
+    validateMemoryWriteTool_notePropsSchema = import_zod35.z.object({
+      status: import_zod35.z.string().describe("Status enum value from the target vault contract."),
+      summary: import_zod35.z.string().describe("Short retrieval-ready description."),
+      tags: import_zod35.z.array(import_zod35.z.string()).describe("AI-generated keyword tags, not vault names."),
+      pinned: import_zod35.z.boolean().describe("Recall boost for important notes."),
+      source_type: import_zod35.z.string().describe("Attribution kind: user, person, url, file, channel, thread, or note."),
+      source_ref: import_zod35.z.string().describe("Attribution reference (URL, path, channel, thread, or source note)."),
+      related: import_zod35.z.array(import_zod35.z.string()).describe("Same-vault links (wiki [[ ]] targets)."),
+      related_vault_notes: import_zod35.z.array(import_zod35.z.string()).describe('Cross-vault references in "Vault Name::relative/path.md" form.'),
+      embed: import_zod35.z.boolean().describe("Whether Smart RAG should index the note."),
+      embed_priority: import_zod35.z.enum(["low", "normal", "high"]).describe("Embedding priority."),
+      embedding_summary: import_zod35.z.string().describe("Optional retrieval-specific summary."),
+      type: import_zod35.z.string().describe("Note type from the target vault contract (also used to route the note)."),
+      domain: import_zod35.z.string().describe("Domain folder for Library/Knowledge (AI, SEO, Copywriting & Ads, Business, Spirituality)."),
+      folder: import_zod35.z.string().describe("Explicit sub-folder within the vault; overrides routing-derived folder."),
+      parentMessageId: import_zod35.z.string().describe("Channel messages only: the path of the top-level message this is a reply to. Absent on top-level messages.")
+    }).partial().passthrough();
+    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: import_zod35.z.string(),
+        title: import_zod35.z.string(),
+        content: import_zod35.z.string(),
+        props: validateMemoryWriteTool_notePropsSchema
+      },
+      output: {
+        ok: import_zod35.z.boolean(),
+        valid: import_zod35.z.boolean().optional(),
+        errors: import_zod35.z.array(import_zod35.z.string()).optional(),
+        warnings: import_zod35.z.array(import_zod35.z.string()).optional(),
+        normalizedTags: import_zod35.z.array(import_zod35.z.string()).optional(),
+        error: import_zod35.z.string().optional()
+      },
+      annotations: { title: "Validate Memory Write", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    };
     CreateChannelSchema = {
       id: "create-channel",
       upstreamName: "createChannelTool",
@@ -31956,18 +32094,78 @@ var init_memory_tool_schemas = __esm({
         openWorldHint: false
       }
     };
+    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: import_zod35.z.string().min(1),
+        vault: import_zod35.z.string().optional()
+      },
+      output: {
+        ok: import_zod35.z.boolean(),
+        nodes: import_zod35.z.array(import_zod35.z.object({ id: import_zod35.z.string(), vault: import_zod35.z.string(), path: import_zod35.z.string(), title: import_zod35.z.string(), resolved: import_zod35.z.boolean() })).optional(),
+        edges: import_zod35.z.array(import_zod35.z.object({ source: import_zod35.z.string(), target: import_zod35.z.string(), type: import_zod35.z.string(), evidence: import_zod35.z.string(), sourceField: import_zod35.z.string(), resolved: import_zod35.z.boolean() })).optional(),
+        error: import_zod35.z.string().optional()
+      },
+      annotations: { title: "Memory Backlinks", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    };
+    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: import_zod35.z.string().min(1),
+        to: import_zod35.z.string().min(1),
+        fromVault: import_zod35.z.string().optional(),
+        toVault: import_zod35.z.string().optional(),
+        maxDepth: import_zod35.z.number().int().min(1).max(12).optional()
+      },
+      output: {
+        ok: import_zod35.z.boolean(),
+        nodes: import_zod35.z.array(import_zod35.z.object({ id: import_zod35.z.string(), vault: import_zod35.z.string(), path: import_zod35.z.string(), title: import_zod35.z.string(), resolved: import_zod35.z.boolean() })).optional(),
+        edges: import_zod35.z.array(import_zod35.z.object({ source: import_zod35.z.string(), target: import_zod35.z.string(), type: import_zod35.z.string(), evidence: import_zod35.z.string(), sourceField: import_zod35.z.string(), resolved: import_zod35.z.boolean() })).optional(),
+        error: import_zod35.z.string().optional()
+      },
+      annotations: { title: "Memory Graph Path", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    };
+    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: import_zod35.z.string().min(1),
+        vault: import_zod35.z.string().optional(),
+        depth: import_zod35.z.number().int().min(0).max(6).optional(),
+        maxNodes: import_zod35.z.number().int().min(1).max(500).optional()
+      },
+      output: {
+        ok: import_zod35.z.boolean(),
+        root: import_zod35.z.string().optional(),
+        depth: import_zod35.z.number().optional(),
+        truncated: import_zod35.z.boolean().optional(),
+        nodes: import_zod35.z.array(import_zod35.z.object({ id: import_zod35.z.string(), vault: import_zod35.z.string(), path: import_zod35.z.string(), title: import_zod35.z.string(), resolved: import_zod35.z.boolean() })).optional(),
+        edges: import_zod35.z.array(import_zod35.z.object({ source: import_zod35.z.string(), target: import_zod35.z.string(), type: import_zod35.z.string(), evidence: import_zod35.z.string(), sourceField: import_zod35.z.string(), resolved: import_zod35.z.boolean() })).optional(),
+        error: import_zod35.z.string().optional()
+      },
+      annotations: { title: "Memory Graph Universe", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    };
     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: import_zod35.z.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: import_zod35.z.string().min(1).describe("Short human-readable title for the item; used to build the stored path. Must be non-empty."),
         content: import_zod35.z.string().min(1).describe("The full captured text (scrape/transcript/output) to store and index. Must be non-empty."),
         source: import_zod35.z.string().min(1).describe("Provenance of the content, e.g. a URL or tool name. Must be non-empty."),
         capturedAt: import_zod35.z.string().optional().describe("ISO-8601 capture timestamp. Optional; defaults to now. Also seeds the deterministic storage path."),
+        summary: import_zod35.z.string().optional().describe("Retrieval-ready source summary. Optional; a provenance summary is generated when omitted."),
+        tags: import_zod35.z.array(import_zod35.z.string()).max(8).optional().describe("Reviewed canonical tags. Existing tags should be resolved first; when omitted, deterministic source/topic tags are generated."),
+        related: import_zod35.z.array(import_zod35.z.string()).optional().describe("Reviewed same-vault Library note paths."),
+        relatedVaultNotes: import_zod35.z.array(import_zod35.z.string()).optional().describe("Reviewed cross-vault references in Vault::path.md form."),
         localVaultPath: import_zod35.z.string().optional().describe("Filesystem root to also mirror the item to. Optional; falls back to MEMORY_LOCAL_VAULT_ROOT env when set.")
       },
       output: {
@@ -31977,6 +32175,7 @@ var init_memory_tool_schemas = __esm({
         path: import_zod35.z.string().optional().describe("Vault-relative path the item was stored at (under library/...)."),
         indexed: import_zod35.z.number().optional().describe("Number of search chunks indexed (0 if embedding failed but the note still saved)."),
         dualWritten: import_zod35.z.boolean().optional().describe("True if the item was also mirrored to the local filesystem vault."),
+        nextStep: import_zod35.z.string().optional().describe("Recommended extraction action after the raw Library source is safe."),
         code: import_zod35.z.string().optional().describe("Machine-readable denial code when ok is false: quota_exceeded or free_cost_cap."),
         error: import_zod35.z.string().optional().describe("Human-readable failure reason when ok is false.")
       },
@@ -32054,10 +32253,27 @@ var init_memory_tool_schemas = __esm({
         openWorldHint: false
       }
     };
+    getTool_notePropsSchema = import_zod35.z.object({
+      status: import_zod35.z.string().describe("Status enum value from the target vault contract."),
+      summary: import_zod35.z.string().describe("Short retrieval-ready description."),
+      tags: import_zod35.z.array(import_zod35.z.string()).describe("AI-generated keyword tags, not vault names."),
+      pinned: import_zod35.z.boolean().describe("Recall boost for important notes."),
+      source_type: import_zod35.z.string().describe("Attribution kind: user, person, url, file, channel, thread, or note."),
+      source_ref: import_zod35.z.string().describe("Attribution reference (URL, path, channel, thread, or source note)."),
+      related: import_zod35.z.array(import_zod35.z.string()).describe("Same-vault links (wiki [[ ]] targets)."),
+      related_vault_notes: import_zod35.z.array(import_zod35.z.string()).describe('Cross-vault references in "Vault Name::relative/path.md" form.'),
+      embed: import_zod35.z.boolean().describe("Whether Smart RAG should index the note."),
+      embed_priority: import_zod35.z.enum(["low", "normal", "high"]).describe("Embedding priority."),
+      embedding_summary: import_zod35.z.string().describe("Optional retrieval-specific summary."),
+      type: import_zod35.z.string().describe("Note type from the target vault contract (also used to route the note)."),
+      domain: import_zod35.z.string().describe("Domain folder for Library/Knowledge (AI, SEO, Copywriting & Ads, Business, Spirituality)."),
+      folder: import_zod35.z.string().describe("Explicit sub-folder within the vault; overrides routing-derived folder."),
+      parentMessageId: import_zod35.z.string().describe("Channel messages only: the path of the top-level message this is a reply to. Absent on top-level messages.")
+    }).partial().passthrough();
     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: import_zod35.z.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."
@@ -32077,6 +32293,7 @@ var init_memory_tool_schemas = __esm({
           capturedAt: import_zod35.z.string().describe("ISO-8601 timestamp of when the note was first captured."),
           revision: import_zod35.z.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: import_zod35.z.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: import_zod35.z.string().optional().describe("Present only when read via shareId: the identity who owns and shared this note."),
           othersEditing: import_zod35.z.array(import_zod35.z.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."),
@@ -32124,7 +32341,7 @@ var init_memory_tool_schemas = __esm({
         openWorldHint: false
       }
     };
-    notePropsSchema = import_zod35.z.object({
+    putTool_notePropsSchema = import_zod35.z.object({
       status: import_zod35.z.string().describe("Status enum value from the target vault contract."),
       summary: import_zod35.z.string().describe("Short retrieval-ready description."),
       tags: import_zod35.z.array(import_zod35.z.string()).describe("AI-generated keyword tags, not vault names."),
@@ -32140,7 +32357,7 @@ var init_memory_tool_schemas = __esm({
       domain: import_zod35.z.string().describe("Domain folder for Library/Knowledge (AI, SEO, Copywriting & Ads, Business, Spirituality)."),
       folder: import_zod35.z.string().describe("Explicit sub-folder within the vault; overrides routing-derived folder."),
       parentMessageId: import_zod35.z.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();
     PutSchema = {
       id: "memory-put",
       upstreamName: "putTool",
@@ -32153,7 +32370,7 @@ var init_memory_tool_schemas = __esm({
         shareId: import_zod35.z.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: import_zod35.z.string().optional().describe("Optional human-readable title; defaults are derived from the path when omitted."),
         content: import_zod35.z.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: import_zod35.z.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: {
@@ -32767,6 +32984,51 @@ var init_memory_tool_schemas = __esm({
         openWorldHint: false
       }
     };
+    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: import_zod35.z.boolean().optional()
+      },
+      output: {
+        ok: import_zod35.z.boolean(),
+        tags: import_zod35.z.array(import_zod35.z.object({ tag: import_zod35.z.string(), description: import_zod35.z.string().nullable(), aliases: import_zod35.z.array(import_zod35.z.string()), status: import_zod35.z.enum(["active", "deprecated"]), usageCount: import_zod35.z.number(), vaultUsage: import_zod35.z.record(import_zod35.z.number()) })).optional(),
+        error: import_zod35.z.string().optional()
+      },
+      annotations: { title: "List Memory Tags", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    };
+    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: import_zod35.z.array(import_zod35.z.object({ tag: import_zod35.z.string().min(1), central: import_zod35.z.boolean().optional(), reusable: import_zod35.z.boolean().optional(), description: import_zod35.z.string().optional() })).min(1).max(20)
+      },
+      output: {
+        ok: import_zod35.z.boolean(),
+        resolutions: import_zod35.z.array(import_zod35.z.object({ candidate: import_zod35.z.string(), normalized: import_zod35.z.string(), action: import_zod35.z.enum(["reuse", "create", "omit"]), tag: import_zod35.z.string().optional(), matchedBy: import_zod35.z.enum(["exact", "alias", "near"]).optional(), score: import_zod35.z.number().optional(), reason: import_zod35.z.string() })).optional(),
+        error: import_zod35.z.string().optional()
+      },
+      annotations: { title: "Resolve Memory Tags", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    };
+    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: import_zod35.z.string().min(1),
+        description: import_zod35.z.string().optional(),
+        aliases: import_zod35.z.array(import_zod35.z.string()).optional(),
+        status: import_zod35.z.enum(["active", "deprecated"]).optional()
+      },
+      output: {
+        ok: import_zod35.z.boolean(),
+        tag: import_zod35.z.object({ tag: import_zod35.z.string(), description: import_zod35.z.string().nullable(), aliases: import_zod35.z.array(import_zod35.z.string()), status: import_zod35.z.enum(["active", "deprecated"]) }).optional(),
+        error: import_zod35.z.string().optional()
+      },
+      annotations: { title: "Upsert Memory Tag", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    };
     AddVaultSchema = {
       id: "add-vault",
       upstreamName: "addVaultTool",
@@ -32834,6 +33096,21 @@ var init_memory_tool_schemas = __esm({
         openWorldHint: false
       }
     };
+    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: import_zod35.z.string().describe("One governed vault: Ideas, Inspiration, Knowledge, Library, People, Communications, Calendar, Tasks, Projects, Issues, Improvement Log, Experiments, or Sprint.")
+      },
+      output: {
+        ok: import_zod35.z.boolean(),
+        vault: import_zod35.z.string().optional(),
+        contract: import_zod35.z.record(import_zod35.z.unknown()).optional(),
+        error: import_zod35.z.string().optional()
+      },
+      annotations: { title: "Get Vault Contract", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    };
     ListSharedWithMeSchema = {
       id: "list-shared-with-me",
       upstreamName: "listSharedWithMeTool",
@@ -32918,6 +33195,26 @@ var init_memory_tool_schemas = __esm({
         openWorldHint: false
       }
     };
+    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: import_zod35.z.string().min(1),
+        content: import_zod35.z.string().min(1),
+        type: import_zod35.z.string().optional(),
+        source: import_zod35.z.string().optional()
+      },
+      output: {
+        ok: import_zod35.z.boolean(),
+        vault: import_zod35.z.string().optional(),
+        folder: import_zod35.z.string().optional(),
+        reason: import_zod35.z.string().optional(),
+        contract: import_zod35.z.record(import_zod35.z.unknown()).optional(),
+        error: import_zod35.z.string().optional()
+      },
+      annotations: { title: "Route Memory", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    };
     VideoAnalyzeStartSchema = {
       id: "video-analyze-start",
       upstreamName: "videoAnalyzeStartTool",
@@ -33040,7 +33337,10 @@ var init_memory_tool_schemas = __esm({
       SwapVaultSchema,
       SwitchAccountSchema,
       UnlinkShareSchema,
+      MemoryCaptureSchema,
       MemoryQuestionsSchema,
+      PrepareMemoryWriteSchema,
+      ValidateMemoryWriteSchema,
       CreateChannelSchema,
       GetMessageNoteSchema,
       ListChannelMembersSchema,
@@ -33053,6 +33353,9 @@ var init_memory_tool_schemas = __esm({
       ReplyMessageSchema,
       FactHistorySchema,
       RecordFactSchema,
+      NoteBacklinksSchema,
+      GraphPathSchema,
+      GraphUniverseSchema,
       LibraryIngestSchema,
       DeleteNoteSchema,
       ExportSchema,
@@ -33082,12 +33385,17 @@ var init_memory_tool_schemas = __esm({
       InsertTableRowsSchema,
       ListTablesSchema,
       QueryTableSchema,
+      ListTagsSchema,
+      ResolveTagsSchema,
+      UpsertTagSchema,
       AddVaultSchema,
       CreateSecureVaultSchema,
       DeleteVaultSchema,
+      GetVaultContractSchema,
       ListSharedWithMeSchema,
       ListVaultsSchema,
       ProvisionDefaultsSchema,
+      RouteMemorySchema,
       VideoAnalyzeStartSchema,
       VideoAnalyzeStatusSchema,
       CreateWebhookSchema,
@@ -33295,8 +33603,44 @@ function registerReadCutovers() {
     const result = await import_list_webhooks.listWebhooksTool.execute({ ...input, apiKey }, {});
     return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
   });
+  registerCutover("getVaultContractTool", async (input, apiKey) => {
+    const result = await import_get_vault_contract.getVaultContractTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("routeMemoryTool", async (input, apiKey) => {
+    const result = await import_route_memory.routeMemoryTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("listTagsTool", async (input, apiKey) => {
+    const result = await import_list_tags.listTagsTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("resolveTagsTool", async (input, apiKey) => {
+    const result = await import_resolve_tags.resolveTagsTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("noteBacklinksTool", async (input, apiKey) => {
+    const result = await import_memory_backlinks.noteBacklinksTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("graphUniverseTool", async (input, apiKey) => {
+    const result = await import_memory_graph_universe.graphUniverseTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("graphPathTool", async (input, apiKey) => {
+    const result = await import_memory_graph_path.graphPathTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("prepareMemoryWriteTool", async (input, apiKey) => {
+    const result = await import_prepare_memory_write.prepareMemoryWriteTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("validateMemoryWriteTool", async (input, apiKey) => {
+    const result = await import_validate_memory_write.validateMemoryWriteTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
 }
-var import_list_approved_senders, import_note_inbox, import_get_message_note, import_list_channel_members, import_my_mentions, import_fact_history, import_export2, import_get, import_list, import_search, import_suggest, import_temporal_recall, import_list_scheduled_actions, import_cost_usage, import_storage_usage, import_table_describe, import_table_list, import_table_query, import_list_shared_with_me, import_list_vaults, import_status, import_list_webhooks, registered;
+var import_list_approved_senders, import_note_inbox, import_get_message_note, import_list_channel_members, import_my_mentions, import_fact_history, import_export2, import_get, import_list, import_search, import_suggest, import_temporal_recall, import_list_scheduled_actions, import_cost_usage, import_storage_usage, import_table_describe, import_table_list, import_table_query, import_list_shared_with_me, import_list_vaults, import_status, import_list_webhooks, import_get_vault_contract, import_route_memory, import_list_tags, import_resolve_tags, import_memory_backlinks, import_memory_graph_universe, import_memory_graph_path, import_prepare_memory_write, import_validate_memory_write, registered;
 var init_reads = __esm({
   "src/mcp/memory-cutover/reads.ts"() {
     "use strict";
@@ -33323,6 +33667,15 @@ var init_reads = __esm({
     import_list_vaults = require("mcpscraper-memory-tools/tools/vaults/list-vaults");
     import_status = require("mcpscraper-memory-tools/tools/video/status");
     import_list_webhooks = require("mcpscraper-memory-tools/tools/webhooks/list-webhooks");
+    import_get_vault_contract = require("mcpscraper-memory-tools/tools/vaults/get-vault-contract");
+    import_route_memory = require("mcpscraper-memory-tools/tools/vaults/route-memory");
+    import_list_tags = require("mcpscraper-memory-tools/tools/tags/list-tags");
+    import_resolve_tags = require("mcpscraper-memory-tools/tools/tags/resolve-tags");
+    import_memory_backlinks = require("mcpscraper-memory-tools/tools/graph/memory-backlinks");
+    import_memory_graph_universe = require("mcpscraper-memory-tools/tools/graph/memory-graph-universe");
+    import_memory_graph_path = require("mcpscraper-memory-tools/tools/graph/memory-graph-path");
+    import_prepare_memory_write = require("mcpscraper-memory-tools/tools/capture/prepare-memory-write");
+    import_validate_memory_write = require("mcpscraper-memory-tools/tools/capture/validate-memory-write");
     registered = false;
   }
 });
@@ -33467,8 +33820,16 @@ function registerWriteCutovers() {
     const result = await import_delete_vault.deleteVaultTool.execute({ ...input, apiKey }, {});
     return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
   });
+  registerCutover("memoryCaptureTool", async (input, apiKey) => {
+    const result = await import_memory_capture.memoryCaptureTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("upsertTagTool", async (input, apiKey) => {
+    const result = await import_upsert_tag.upsertTagTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
 }
-var import_accept_share, import_approve_sender, import_decline_share, import_inbox_settings, import_remove_approved_sender, import_revoke_share, import_set_agent_identity, import_share_note, import_share_vault, import_swap_vault, import_switch_account, import_unlink_share, import_memory_questions, import_create_channel, import_list_channel_messages, import_poll_channel, import_post_message, import_react_message, import_remove_channel_member, import_reply_message, import_record_fact, import_library_ingest, import_delete_note, import_put, import_upload, import_delete_scheduled_action, import_pause_scheduled_action, import_resume_scheduled_action, import_table_create, import_table_delete_rows, import_table_drop, import_table_insert_rows, import_add_vault, import_delete_vault, registered2;
+var import_accept_share, import_approve_sender, import_decline_share, import_inbox_settings, import_remove_approved_sender, import_revoke_share, import_set_agent_identity, import_share_note, import_share_vault, import_swap_vault, import_switch_account, import_unlink_share, import_memory_questions, import_create_channel, import_list_channel_messages, import_poll_channel, import_post_message, import_react_message, import_remove_channel_member, import_reply_message, import_record_fact, import_library_ingest, import_delete_note, import_put, import_upload, import_delete_scheduled_action, import_pause_scheduled_action, import_resume_scheduled_action, import_table_create, import_table_delete_rows, import_table_drop, import_table_insert_rows, import_add_vault, import_delete_vault, import_memory_capture, import_upsert_tag, registered2;
 var init_writes = __esm({
   "src/mcp/memory-cutover/writes.ts"() {
     "use strict";
@@ -33507,6 +33868,8 @@ var init_writes = __esm({
     import_table_insert_rows = require("mcpscraper-memory-tools/tools/tables/table-insert-rows");
     import_add_vault = require("mcpscraper-memory-tools/tools/vaults/add-vault");
     import_delete_vault = require("mcpscraper-memory-tools/tools/vaults/delete-vault");
+    import_memory_capture = require("mcpscraper-memory-tools/tools/capture/memory-capture");
+    import_upsert_tag = require("mcpscraper-memory-tools/tools/tags/upsert-tag");
     registered2 = false;
   }
 });
@@ -37811,7 +38174,7 @@ async function depositScrapeToVault(user, opts) {
     const clipped = content.length > MAX_DEPOSIT_CHARS ? content.slice(0, MAX_DEPOSIT_CHARS) : content;
     const { key, error } = await getOrCreateUserMemoryKey(user);
     if (!key) return { deposited: false, error: error ?? "memory unavailable" };
-    const vault = opts.vault?.trim() || personalVault(user);
+    const vault = opts.vault?.trim() || "Library";
     const title = (opts.title?.trim() || opts.source).slice(0, 200);
     const res = await memoryCall(
       "libraryIngestTool",
@@ -37819,7 +38182,7 @@ async function depositScrapeToVault(user, opts) {
       key
     );
     if (!res.ok) return { deposited: false, vault, error: res.error ?? "ingest failed" };
-    return { deposited: true, vault, noteId: res.noteId, path: res.path, chunks: res.chunks };
+    return { deposited: true, vault, noteId: res.noteId, path: res.path, chunks: res.indexed };
   } catch (err) {
     return { deposited: false, error: err?.message ?? "deposit failed" };
   }