mcp-scraper 0.4.14 → 0.6.0

package/dist/bin/mcp-stdio-server.js

@@ -7,7 +7,7 @@ import {
   registerMemoryMcpTools,
   registerPaaExtractorMcpTools,
   registerSerpIntelligenceCaptureTools
-} from "../chunk-XZ2GPRCM.js";
+} from "../chunk-3K5GT6VG.js";
 import "../chunk-GWRIO6JT.js";
 import "../chunk-HPV4VOQX.js";
 import {
@@ -16,7 +16,8 @@ import {
 import "../chunk-XGIPATLV.js";
 import {
   PACKAGE_VERSION
-} from "../chunk-OL65BO4S.js";
+} from "../chunk-F2BXETDX.js";
+import "../chunk-APJO2XV5.js";
 import "../chunk-M2S27J6Z.js";
 
 // bin/mcp-stdio-server.ts

package/dist/bin/mcp-stdio-server.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../bin/mcp-stdio-server.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { readFileSync } from 'node:fs'\nimport { homedir } from 'node:os'\nimport { join } from 'node:path'\nimport { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'\nimport { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'\nimport { HttpMcpToolExecutor } from '../src/mcp/http-mcp-tool-executor.js'\nimport { registerBrowserAgentMcpTools } from '../src/mcp/browser-agent-mcp-server.js'\nimport { registerPaaExtractorMcpTools, registerSerpIntelligenceCaptureTools } from '../src/mcp/paa-mcp-server.js'\nimport { registerMemoryMcpTools } from '../src/mcp/memory-mcp-server.js'\nimport { MemoryMcpToolExecutor } from '../src/mcp/memory-mcp-tool-executor.js'\nimport { SERVER_INSTRUCTIONS } from '../src/mcp/server-instructions.js'\nimport { renderInstallTerminal } from '../src/install-terminal.js'\nimport { PACKAGE_VERSION } from '../src/version.js'\n\nconst forceStdio =\n  process.argv.includes('--stdio') ||\n  process.env.MCP_SCRAPER_FORCE_STDIO === '1'\nconst interactiveTerminal = Boolean(process.stdin.isTTY && process.stdout.isTTY)\nconst wantsHelp = process.argv.includes('--help') || process.argv.includes('-h')\n\nif (!forceStdio && (interactiveTerminal || wantsHelp)) {\n  const noColor =\n    process.argv.includes('--no-color') ||\n    process.env.NO_COLOR !== undefined ||\n    process.env.FORCE_COLOR === '0' ||\n    !process.stdout.isTTY\n\n  process.stdout.write(renderInstallTerminal({\n    version: PACKAGE_VERSION,\n    color: !noColor,\n    apiKeyConfigured: Boolean(process.env.MCP_SCRAPER_API_KEY?.trim()),\n  }))\n  process.exit(0)\n}\n\nfunction readApiKeyFile(): string | undefined {\n  const explicitPath = process.env.MCP_SCRAPER_KEY_PATH?.trim()\n  const paths = [explicitPath, join(homedir(), '.mcp-scraper-key')].filter(Boolean) as string[]\n  for (const path of paths) {\n    try {\n      const value = readFileSync(path, 'utf8').trim()\n      if (value) return value\n    } catch {\n      void 0\n    }\n  }\n  return undefined\n}\n\nconst apiKey = (\n  process.env.MCP_SCRAPER_API_KEY ??\n  process.env.MCP_SCRAPER_KEY ??\n  process.env.MCP_API_KEY ??\n  readApiKeyFile()\n)?.trim()\nif (!apiKey) {\n  process.stderr.write('MCP_SCRAPER_API_KEY env var or ~/.mcp-scraper-key is required\\n')\n  process.exit(1)\n}\n\nconst baseUrl = process.env.MCP_SCRAPER_BASE_URL?.trim() || process.env.MCP_BASE_URL?.trim() || 'https://mcpscraper.dev'\nconst consoleBaseUrl = process.env.BROWSER_AGENT_CONSOLE_URL?.trim() || baseUrl\nconst server = new McpServer({ name: 'mcp-scraper', version: PACKAGE_VERSION }, { instructions: SERVER_INSTRUCTIONS })\n\nconst httpExecutor = new HttpMcpToolExecutor(baseUrl, apiKey)\nregisterPaaExtractorMcpTools(server, httpExecutor)\nregisterSerpIntelligenceCaptureTools(server, httpExecutor)\nregisterBrowserAgentMcpTools(server, { baseUrl, apiKey, consoleBaseUrl })\nregisterMemoryMcpTools(server, new MemoryMcpToolExecutor(baseUrl, apiKey))\n\nconst transport = new StdioServerTransport()\n\nasync function main() {\n  await server.connect(transport)\n}\n\nmain().catch(err => {\n  process.stderr.write(`${err instanceof Error ? err.message : String(err)}\\n`)\n  process.exit(1)\n})\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AACA,SAAS,oBAAoB;AAC7B,SAAS,eAAe;AACxB,SAAS,YAAY;AACrB,SAAS,iBAAiB;AAC1B,SAAS,4BAA4B;AAUrC,IAAM,aACJ,QAAQ,KAAK,SAAS,SAAS,KAC/B,QAAQ,IAAI,4BAA4B;AAC1C,IAAM,sBAAsB,QAAQ,QAAQ,MAAM,SAAS,QAAQ,OAAO,KAAK;AAC/E,IAAM,YAAY,QAAQ,KAAK,SAAS,QAAQ,KAAK,QAAQ,KAAK,SAAS,IAAI;AAE/E,IAAI,CAAC,eAAe,uBAAuB,YAAY;AACrD,QAAM,UACJ,QAAQ,KAAK,SAAS,YAAY,KAClC,QAAQ,IAAI,aAAa,UACzB,QAAQ,IAAI,gBAAgB,OAC5B,CAAC,QAAQ,OAAO;AAElB,UAAQ,OAAO,MAAM,sBAAsB;AAAA,IACzC,SAAS;AAAA,IACT,OAAO,CAAC;AAAA,IACR,kBAAkB,QAAQ,QAAQ,IAAI,qBAAqB,KAAK,CAAC;AAAA,EACnE,CAAC,CAAC;AACF,UAAQ,KAAK,CAAC;AAChB;AAEA,SAAS,iBAAqC;AAC5C,QAAM,eAAe,QAAQ,IAAI,sBAAsB,KAAK;AAC5D,QAAM,QAAQ,CAAC,cAAc,KAAK,QAAQ,GAAG,kBAAkB,CAAC,EAAE,OAAO,OAAO;AAChF,aAAW,QAAQ,OAAO;AACxB,QAAI;AACF,YAAM,QAAQ,aAAa,MAAM,MAAM,EAAE,KAAK;AAC9C,UAAI,MAAO,QAAO;AAAA,IACpB,QAAQ;AAAA,IAER;AAAA,EACF;AACA,SAAO;AACT;AAEA,IAAM,UACJ,QAAQ,IAAI,uBACZ,QAAQ,IAAI,mBACZ,QAAQ,IAAI,eACZ,eAAe,IACd,KAAK;AACR,IAAI,CAAC,QAAQ;AACX,UAAQ,OAAO,MAAM,iEAAiE;AACtF,UAAQ,KAAK,CAAC;AAChB;AAEA,IAAM,UAAU,QAAQ,IAAI,sBAAsB,KAAK,KAAK,QAAQ,IAAI,cAAc,KAAK,KAAK;AAChG,IAAM,iBAAiB,QAAQ,IAAI,2BAA2B,KAAK,KAAK;AACxE,IAAM,SAAS,IAAI,UAAU,EAAE,MAAM,eAAe,SAAS,gBAAgB,GAAG,EAAE,cAAc,oBAAoB,CAAC;AAErH,IAAM,eAAe,IAAI,oBAAoB,SAAS,MAAM;AAC5D,6BAA6B,QAAQ,YAAY;AACjD,qCAAqC,QAAQ,YAAY;AACzD,6BAA6B,QAAQ,EAAE,SAAS,QAAQ,eAAe,CAAC;AACxE,uBAAuB,QAAQ,IAAI,sBAAsB,SAAS,MAAM,CAAC;AAEzE,IAAM,YAAY,IAAI,qBAAqB;AAE3C,eAAe,OAAO;AACpB,QAAM,OAAO,QAAQ,SAAS;AAChC;AAEA,KAAK,EAAE,MAAM,SAAO;AAClB,UAAQ,OAAO,MAAM,GAAG,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC;AAAA,CAAI;AAC5E,UAAQ,KAAK,CAAC;AAChB,CAAC;","names":[]}
+{"version":3,"sources":["../../bin/mcp-stdio-server.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { readFileSync } from 'node:fs'\nimport { homedir } from 'node:os'\nimport { join } from 'node:path'\nimport { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'\nimport { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'\nimport { HttpMcpToolExecutor } from '../src/mcp/http-mcp-tool-executor.js'\nimport { registerBrowserAgentMcpTools } from '../src/mcp/browser-agent-mcp-server.js'\nimport { registerPaaExtractorMcpTools, registerSerpIntelligenceCaptureTools } from '../src/mcp/paa-mcp-server.js'\nimport { registerMemoryMcpTools } from '../src/mcp/memory-mcp-server.js'\nimport { MemoryMcpToolExecutor } from '../src/mcp/memory-mcp-tool-executor.js'\nimport { SERVER_INSTRUCTIONS } from '../src/mcp/server-instructions.js'\nimport { renderInstallTerminal } from '../src/install-terminal.js'\nimport { PACKAGE_VERSION } from '../src/version.js'\n\nconst forceStdio =\n  process.argv.includes('--stdio') ||\n  process.env.MCP_SCRAPER_FORCE_STDIO === '1'\nconst interactiveTerminal = Boolean(process.stdin.isTTY && process.stdout.isTTY)\nconst wantsHelp = process.argv.includes('--help') || process.argv.includes('-h')\n\nif (!forceStdio && (interactiveTerminal || wantsHelp)) {\n  const noColor =\n    process.argv.includes('--no-color') ||\n    process.env.NO_COLOR !== undefined ||\n    process.env.FORCE_COLOR === '0' ||\n    !process.stdout.isTTY\n\n  process.stdout.write(renderInstallTerminal({\n    version: PACKAGE_VERSION,\n    color: !noColor,\n    apiKeyConfigured: Boolean(process.env.MCP_SCRAPER_API_KEY?.trim()),\n  }))\n  process.exit(0)\n}\n\nfunction readApiKeyFile(): string | undefined {\n  const explicitPath = process.env.MCP_SCRAPER_KEY_PATH?.trim()\n  const paths = [explicitPath, join(homedir(), '.mcp-scraper-key')].filter(Boolean) as string[]\n  for (const path of paths) {\n    try {\n      const value = readFileSync(path, 'utf8').trim()\n      if (value) return value\n    } catch {\n      void 0\n    }\n  }\n  return undefined\n}\n\nconst apiKey = (\n  process.env.MCP_SCRAPER_API_KEY ??\n  process.env.MCP_SCRAPER_KEY ??\n  process.env.MCP_API_KEY ??\n  readApiKeyFile()\n)?.trim()\nif (!apiKey) {\n  process.stderr.write('MCP_SCRAPER_API_KEY env var or ~/.mcp-scraper-key is required\\n')\n  process.exit(1)\n}\n\nconst baseUrl = process.env.MCP_SCRAPER_BASE_URL?.trim() || process.env.MCP_BASE_URL?.trim() || 'https://mcpscraper.dev'\nconst consoleBaseUrl = process.env.BROWSER_AGENT_CONSOLE_URL?.trim() || baseUrl\nconst server = new McpServer({ name: 'mcp-scraper', version: PACKAGE_VERSION }, { instructions: SERVER_INSTRUCTIONS })\n\nconst httpExecutor = new HttpMcpToolExecutor(baseUrl, apiKey)\nregisterPaaExtractorMcpTools(server, httpExecutor)\nregisterSerpIntelligenceCaptureTools(server, httpExecutor)\nregisterBrowserAgentMcpTools(server, { baseUrl, apiKey, consoleBaseUrl })\nregisterMemoryMcpTools(server, new MemoryMcpToolExecutor(baseUrl, apiKey))\n\nconst transport = new StdioServerTransport()\n\nasync function main() {\n  await server.connect(transport)\n}\n\nmain().catch(err => {\n  process.stderr.write(`${err instanceof Error ? err.message : String(err)}\\n`)\n  process.exit(1)\n})\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AACA,SAAS,oBAAoB;AAC7B,SAAS,eAAe;AACxB,SAAS,YAAY;AACrB,SAAS,iBAAiB;AAC1B,SAAS,4BAA4B;AAUrC,IAAM,aACJ,QAAQ,KAAK,SAAS,SAAS,KAC/B,QAAQ,IAAI,4BAA4B;AAC1C,IAAM,sBAAsB,QAAQ,QAAQ,MAAM,SAAS,QAAQ,OAAO,KAAK;AAC/E,IAAM,YAAY,QAAQ,KAAK,SAAS,QAAQ,KAAK,QAAQ,KAAK,SAAS,IAAI;AAE/E,IAAI,CAAC,eAAe,uBAAuB,YAAY;AACrD,QAAM,UACJ,QAAQ,KAAK,SAAS,YAAY,KAClC,QAAQ,IAAI,aAAa,UACzB,QAAQ,IAAI,gBAAgB,OAC5B,CAAC,QAAQ,OAAO;AAElB,UAAQ,OAAO,MAAM,sBAAsB;AAAA,IACzC,SAAS;AAAA,IACT,OAAO,CAAC;AAAA,IACR,kBAAkB,QAAQ,QAAQ,IAAI,qBAAqB,KAAK,CAAC;AAAA,EACnE,CAAC,CAAC;AACF,UAAQ,KAAK,CAAC;AAChB;AAEA,SAAS,iBAAqC;AAC5C,QAAM,eAAe,QAAQ,IAAI,sBAAsB,KAAK;AAC5D,QAAM,QAAQ,CAAC,cAAc,KAAK,QAAQ,GAAG,kBAAkB,CAAC,EAAE,OAAO,OAAO;AAChF,aAAW,QAAQ,OAAO;AACxB,QAAI;AACF,YAAM,QAAQ,aAAa,MAAM,MAAM,EAAE,KAAK;AAC9C,UAAI,MAAO,QAAO;AAAA,IACpB,QAAQ;AAAA,IAER;AAAA,EACF;AACA,SAAO;AACT;AAEA,IAAM,UACJ,QAAQ,IAAI,uBACZ,QAAQ,IAAI,mBACZ,QAAQ,IAAI,eACZ,eAAe,IACd,KAAK;AACR,IAAI,CAAC,QAAQ;AACX,UAAQ,OAAO,MAAM,iEAAiE;AACtF,UAAQ,KAAK,CAAC;AAChB;AAEA,IAAM,UAAU,QAAQ,IAAI,sBAAsB,KAAK,KAAK,QAAQ,IAAI,cAAc,KAAK,KAAK;AAChG,IAAM,iBAAiB,QAAQ,IAAI,2BAA2B,KAAK,KAAK;AACxE,IAAM,SAAS,IAAI,UAAU,EAAE,MAAM,eAAe,SAAS,gBAAgB,GAAG,EAAE,cAAc,oBAAoB,CAAC;AAErH,IAAM,eAAe,IAAI,oBAAoB,SAAS,MAAM;AAC5D,6BAA6B,QAAQ,YAAY;AACjD,qCAAqC,QAAQ,YAAY;AACzD,6BAA6B,QAAQ,EAAE,SAAS,QAAQ,eAAe,CAAC;AACxE,uBAAuB,QAAQ,IAAI,sBAAsB,SAAS,MAAM,CAAC;AAEzE,IAAM,YAAY,IAAI,qBAAqB;AAE3C,eAAe,OAAO;AACpB,QAAM,OAAO,QAAQ,SAAS;AAChC;AAEA,KAAK,EAAE,MAAM,SAAO;AAClB,UAAQ,OAAO,MAAM,GAAG,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC;AAAA,CAAI;AAC5E,UAAQ,KAAK,CAAC;AAChB,CAAC;","names":[]}

package/dist/{chunk-XZ2GPRCM.js → chunk-3K5GT6VG.js}

@@ -17,7 +17,10 @@ import {
 } from "./chunk-XGIPATLV.js";
 import {
   PACKAGE_VERSION
-} from "./chunk-OL65BO4S.js";
+} from "./chunk-F2BXETDX.js";
+import {
+  MC_PER_CREDIT
+} from "./chunk-APJO2XV5.js";
 import {
   sanitizeVendorName
 } from "./chunk-M2S27J6Z.js";
@@ -196,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),
@@ -206,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);
@@ -1958,7 +1995,7 @@ function formatCreditsInfo(raw, input) {
     return `| ${c.label} | ${c.credits} | ${c.unit}${notes} |`;
   }).join("\n");
   const ledgerRows = ledger.map((row) => {
-    const credits = row.amount_mc / 1e3;
+    const credits = row.amount_mc / MC_PER_CREDIT;
     return `| ${row.created_at} | ${row.operation} | ${credits} | ${row.description ?? ""} |`;
   }).join("\n");
   const matchedSection = matched ? `
@@ -2008,7 +2045,7 @@ ${ledgerRows}` : ""
       ledger: ledger.map((row) => ({
         createdAt: String(row.created_at ?? ""),
         operation: String(row.operation ?? ""),
-        credits: row.amount_mc / 1e3,
+        credits: row.amount_mc / MC_PER_CREDIT,
         description: row.description ?? null
       })),
       concurrency: concurrencyRaw && upgradeRaw ? {
@@ -6874,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",
@@ -6903,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",
@@ -7243,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: {
@@ -7264,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.")
   },
@@ -7341,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."
@@ -7364,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."),
@@ -7411,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."),
@@ -7427,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",
@@ -7440,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: {
@@ -8054,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",
@@ -8121,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",
@@ -8205,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",
@@ -8327,7 +8630,10 @@ var MEMORY_TOOL_SCHEMAS = [
   SwapVaultSchema,
   SwitchAccountSchema,
   UnlinkShareSchema,
+  MemoryCaptureSchema,
   MemoryQuestionsSchema,
+  PrepareMemoryWriteSchema,
+  ValidateMemoryWriteSchema,
   CreateChannelSchema,
   GetMessageNoteSchema,
   ListChannelMembersSchema,
@@ -8340,6 +8646,9 @@ var MEMORY_TOOL_SCHEMAS = [
   ReplyMessageSchema,
   FactHistorySchema,
   RecordFactSchema,
+  NoteBacklinksSchema,
+  GraphPathSchema,
+  GraphUniverseSchema,
   LibraryIngestSchema,
   DeleteNoteSchema,
   ExportSchema,
@@ -8369,12 +8678,17 @@ var MEMORY_TOOL_SCHEMAS = [
   InsertTableRowsSchema,
   ListTablesSchema,
   QueryTableSchema,
+  ListTagsSchema,
+  ResolveTagsSchema,
+  UpsertTagSchema,
   AddVaultSchema,
   CreateSecureVaultSchema,
   DeleteVaultSchema,
+  GetVaultContractSchema,
   ListSharedWithMeSchema,
   ListVaultsSchema,
   ProvisionDefaultsSchema,
+  RouteMemorySchema,
   VideoAnalyzeStartSchema,
   VideoAnalyzeStatusSchema,
   CreateWebhookSchema,
@@ -8453,4 +8767,4 @@ export {
   registerMemoryMcpTools,
   MemoryMcpToolExecutor
 };
-//# sourceMappingURL=chunk-XZ2GPRCM.js.map
+//# sourceMappingURL=chunk-3K5GT6VG.js.map