mcp-scraper 0.4.14 → 0.6.0

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

@@ -483,7 +483,7 @@ render();
 }
 
 // src/version.ts
-var PACKAGE_VERSION = "0.4.14";
+var PACKAGE_VERSION = "0.6.0";
 
 // src/mcp/browser-agent-tool-schemas.ts
 var import_zod = require("zod");
@@ -2676,6 +2676,272 @@ function summaryEnvelope(executiveSummary, offloaded) {
   ].join("\n");
 }
 
+// src/api/rates.ts
+var MC_COSTS = {
+  serp: 100,
+  paa: 200,
+  paa_base: 1e3,
+  page_scrape: 100,
+  url_map: 500,
+  yt_channel: 200,
+  yt_transcription: 200,
+  fb_ad: 200,
+  maps_search: 500,
+  maps_place: 6e3,
+  maps_review: 100,
+  fb_search: 600,
+  fb_transcribe: 33300,
+  google_ads_search: 600,
+  google_ads_intel: 200,
+  google_ads_transcribe: 33300,
+  instagram_profile: 400,
+  instagram_media: 400,
+  instagram_transcribe: 33300,
+  browser_minute: 12e3,
+  reddit_thread: 3e3,
+  reddit_comment: 200,
+  video_analysis: 666700,
+  trustpilot_reviews: 500,
+  trustpilot_review: 100,
+  g2_reviews: 500,
+  g2_review: 200,
+  diff_page: 100
+};
+var MC_PER_BROWSER_MS = MC_COSTS.browser_minute / 6e4;
+var MC_PER_CREDIT = 100;
+var CREDIT_COST_CATALOG = [
+  {
+    key: "serp",
+    label: "SERP search",
+    aliases: ["search_serp", "serp", "google search", "organic results"],
+    credits: mcToCredits(MC_COSTS.serp),
+    unit: "per search",
+    notes: "Returns AI Overview, PAA snippet, videos, forums, and local pack."
+  },
+  {
+    key: "paa",
+    label: "PAA harvest",
+    aliases: ["harvest_paa", "paa", "people also ask", "questions"],
+    credits: mcToCredits(MC_COSTS.paa),
+    unit: `per question (+${mcToCredits(MC_COSTS.paa_base)} credit base)`,
+    notes: `Full SERP feature extraction. Billed ${mcToCredits(MC_COSTS.paa_base)} credit base + ${mcToCredits(MC_COSTS.paa)} per question actually returned (unused estimate refunded).`
+  },
+  {
+    key: "page_scrape",
+    label: "Page crawl / extract",
+    aliases: ["extract_url", "extract_site", "page scrape", "url scrape", "single page", "site crawl"],
+    credits: mcToCredits(MC_COSTS.page_scrape),
+    unit: "per page",
+    notes: "Applies to both single-URL extraction and per-page site crawls."
+  },
+  {
+    key: "url_map",
+    label: "Site URL mapping",
+    aliases: ["map_site_urls", "url map", "site map", "crawl urls"],
+    credits: mcToCredits(MC_COSTS.url_map),
+    unit: "per mapping operation",
+    notes: "Flat rate for the full /map-urls call regardless of URL count discovered."
+  },
+  {
+    key: "yt_channel",
+    label: "YouTube search / channel harvest",
+    aliases: ["youtube_harvest", "youtube search", "youtube channel", "yt_channel"],
+    credits: mcToCredits(MC_COSTS.yt_channel),
+    unit: "per call"
+  },
+  {
+    key: "yt_transcription",
+    label: "YouTube transcription",
+    aliases: ["youtube_transcribe", "youtube transcript", "transcription", "yt_transcription"],
+    credits: mcToCredits(MC_COSTS.yt_transcription),
+    unit: "per minute",
+    notes: "A 5-minute hold is taken, then reconciled to actual video duration."
+  },
+  {
+    key: "fb_ad",
+    label: "Facebook search / ad lookup",
+    aliases: ["facebook_page_intel", "facebook_ad_search", "facebook_ad", "facebook ads", "fb ads"],
+    credits: mcToCredits(MC_COSTS.fb_ad),
+    unit: "per call"
+  },
+  {
+    key: "maps_search",
+    label: "Maps business search",
+    aliases: ["maps_search", "google maps search", "gmb search", "gbp search", "business profiles"],
+    credits: mcToCredits(MC_COSTS.maps_search),
+    unit: "per search",
+    notes: "Returns up to 50 Google Maps business/profile candidates. Use maps_place_intel to hydrate selected businesses."
+  },
+  {
+    key: "maps_place",
+    label: "Maps business lookup",
+    aliases: ["maps_place_intel", "google maps", "maps place", "place intel"],
+    credits: mcToCredits(MC_COSTS.maps_place),
+    unit: "per business",
+    notes: "Base lookup. Reviews billed separately per card at maps_review rate."
+  },
+  {
+    key: "maps_review",
+    label: "Maps review",
+    aliases: ["maps_reviews", "google reviews", "review cards", "reviews"],
+    credits: mcToCredits(MC_COSTS.maps_review),
+    unit: "per review card",
+    notes: "Charged after extraction when includeReviews is true."
+  },
+  {
+    key: "fb_search",
+    label: "Facebook ad library search",
+    aliases: ["facebook_search", "fb_search", "fb ad search"],
+    credits: mcToCredits(MC_COSTS.fb_search),
+    unit: "per search",
+    notes: "Browser automation to search Facebook Ads Library by keyword."
+  },
+  {
+    key: "google_ads_search",
+    label: "Google Ads Transparency search",
+    aliases: ["google_ads_search", "google ads search", "ads transparency search"],
+    credits: mcToCredits(MC_COSTS.google_ads_search),
+    unit: "per search",
+    notes: "Browser automation to find advertisers in Google Ads Transparency Center by domain or name."
+  },
+  {
+    key: "google_ads_intel",
+    label: "Google Ads Transparency advertiser intel",
+    aliases: ["google_ads_page_intel", "google ads intel", "ads transparency intel"],
+    credits: mcToCredits(MC_COSTS.google_ads_intel),
+    unit: "per call",
+    notes: "Lists and hydrates an advertiser's creatives with image URLs and video references."
+  },
+  {
+    key: "google_ads_transcribe",
+    label: "Google ad video transcription",
+    aliases: ["google_ads_transcribe", "google ad transcript"],
+    credits: mcToCredits(MC_COSTS.google_ads_transcribe),
+    unit: "per minute (typical)",
+    notes: "A hold is taken, then reconciled to the real transcription cost for the actual audio duration."
+  },
+  {
+    key: "fb_transcribe",
+    label: "Facebook video / ad transcription",
+    aliases: ["facebook_transcribe", "facebook_video_transcribe", "fb_transcribe", "fb ad transcript"],
+    credits: mcToCredits(MC_COSTS.fb_transcribe),
+    unit: "per minute (typical)",
+    notes: "A hold is taken, then reconciled to the real transcription cost for the actual audio duration."
+  },
+  {
+    key: "instagram_profile",
+    label: "Instagram profile content discovery",
+    aliases: ["instagram_profile_content", "instagram profile", "instagram content list", "ig profile"],
+    credits: mcToCredits(MC_COSTS.instagram_profile),
+    unit: "per profile scan",
+    notes: "Browser extraction of public Instagram profile grid links. Complete history may require a logged-in profile."
+  },
+  {
+    key: "instagram_media",
+    label: "Instagram media download",
+    aliases: ["instagram_media_download", "instagram reel download", "instagram post download", "ig media"],
+    credits: mcToCredits(MC_COSTS.instagram_media),
+    unit: "per post or reel",
+    notes: "Extracts post text, image URLs, and reel audio/video tracks, with local downloads when the server can write files."
+  },
+  {
+    key: "instagram_transcribe",
+    label: "Instagram media transcription",
+    aliases: ["instagram transcript", "instagram reel transcript", "ig transcribe"],
+    credits: mcToCredits(MC_COSTS.instagram_transcribe),
+    unit: "per minute (typical)",
+    notes: "Whisper transcription of selected Instagram audio/video media via fal.ai. A hold is taken, then reconciled to the real transcription cost for the actual audio duration."
+  },
+  {
+    key: "browser_minute",
+    label: "Interactive browser session",
+    aliases: ["browser_open", "browser agent", "browser_agent", "live browser", "browse", "browser control", "interactive browser"],
+    credits: mcToCredits(MC_COSTS.browser_minute),
+    unit: "per minute of use",
+    notes: "Metered per minute of use for the whole time the browser session is open. Close the session to stop the meter; abandoned sessions are auto-closed after a short idle window."
+  },
+  {
+    key: "reddit_thread",
+    label: "Reddit thread base lookup",
+    aliases: ["reddit", "reddit_thread", "reddit comments", "subreddit", "reddit post"],
+    credits: mcToCredits(MC_COSTS.reddit_thread),
+    unit: "per thread",
+    notes: "Base lookup for the post itself. Comments billed separately per comment at reddit_comment rate. Refunded if the thread cannot be retrieved."
+  },
+  {
+    key: "reddit_comment",
+    label: "Reddit comment",
+    aliases: ["reddit_comment", "reddit comments"],
+    credits: mcToCredits(MC_COSTS.reddit_comment),
+    unit: "per comment",
+    notes: "Charged per comment actually extracted, billed down automatically if the balance runs out mid-thread."
+  },
+  {
+    key: "video_analysis",
+    label: "Video breakdown (frame-by-frame + transcript)",
+    aliases: ["video_frame_analysis", "video breakdown", "video analysis", "analyze video"],
+    credits: mcToCredits(MC_COSTS.video_analysis),
+    unit: "per 120 frames (max 480)",
+    notes: "Full multi-lens video breakdown: samples frames across a video (up to 30 minutes), analyzes each with vision AI, transcribes the audio, then produces summary, pacing/energy, words-per-minute, topic outline, key points, hook analysis, visual style, and a how-to-replicate recipe with a quality-control pass. $1 per 120 frames requested (max 480 = $4); billed down automatically if the video cannot use the requested frames, and refunded fully if the run fails."
+  },
+  {
+    key: "trustpilot_reviews",
+    label: "Trustpilot review harvest",
+    aliases: ["trustpilot_reviews", "trustpilot", "trustpilot reviews"],
+    credits: mcToCredits(MC_COSTS.trustpilot_reviews),
+    unit: "per call",
+    notes: "Base lookup. Reviews billed separately per card at trustpilot_review rate. Refunded if no reviews are found."
+  },
+  {
+    key: "trustpilot_review",
+    label: "Trustpilot review card",
+    aliases: ["trustpilot_review", "trustpilot card"],
+    credits: mcToCredits(MC_COSTS.trustpilot_review),
+    unit: "per review card",
+    notes: "Charged per review actually extracted, billed down automatically if the balance runs out mid-page."
+  },
+  {
+    key: "g2_reviews",
+    label: "G2 review harvest",
+    aliases: ["g2_reviews", "g2", "g2 reviews"],
+    credits: mcToCredits(MC_COSTS.g2_reviews),
+    unit: "per call",
+    notes: "Base lookup. Reviews billed separately per card at g2_review rate. Refunded if no reviews are found."
+  },
+  {
+    key: "g2_review",
+    label: "G2 review card",
+    aliases: ["g2_review", "g2 card"],
+    credits: mcToCredits(MC_COSTS.g2_review),
+    unit: "per review card",
+    notes: "Charged per review actually extracted (each card carries up to 3 Q&A sections), billed down automatically if the balance runs out mid-page."
+  },
+  {
+    key: "diff_page",
+    label: "Page change check",
+    aliases: ["diff_page", "page diff", "change detection"],
+    credits: mcToCredits(MC_COSTS.diff_page),
+    unit: "per check",
+    notes: "Same cost as a single page extract \u2014 one scrape is performed per check, then compared against your last stored snapshot for that URL."
+  }
+];
+var SUBSCRIPTION_TIERS = {
+  "price_1TmiHRS8aAcsk3TGwmSNfNIa": { tier: "starter", label: "Starter", price_id: "price_1TmiHRS8aAcsk3TGwmSNfNIa", monthly_usd: 12, credits_mc: 8e6, concurrency: 3, intro_coupon: "mcp-starter-1dollar-intro-12" },
+  "price_1TrgihS8aAcsk3TG5cglrq4D": { tier: "growth", label: "Growth", price_id: "price_1TrgihS8aAcsk3TG5cglrq4D", monthly_usd: 40, credits_mc: 26666700, concurrency: 10, intro_coupon: null },
+  "price_1TrgihS8aAcsk3TG4HnG4gbY": { tier: "scale", label: "Scale", price_id: "price_1TrgihS8aAcsk3TG4HnG4gbY", monthly_usd: 100, credits_mc: 8e7, concurrency: 20, intro_coupon: null }
+};
+var SUBSCRIPTION_TIER_BY_KEY = Object.fromEntries(
+  Object.values(SUBSCRIPTION_TIERS).map((t) => [t.tier, t])
+);
+function mcToCredits(mc) {
+  return mc / MC_PER_CREDIT;
+}
+var MEMORY_FREE_QUOTA_BYTES = 1e7 * 1;
+var MEMORY_MARGIN_MULTIPLE = 3;
+var MEMORY_PRO_COST_BUDGET_USD = 19 / MEMORY_MARGIN_MULTIPLE;
+var MEDIA_TRANSCRIBE_HOLD_MC = MC_COSTS.fb_transcribe * 3;
+var MC_PER_USD = SUBSCRIPTION_TIERS["price_1TmiHRS8aAcsk3TGwmSNfNIa"].credits_mc / SUBSCRIPTION_TIERS["price_1TmiHRS8aAcsk3TGwmSNfNIa"].monthly_usd;
+
 // src/mcp/mcp-response-formatter.ts
 var INLINE_BUDGET_BYTES = Number(process.env.MCP_SCRAPER_INLINE_BUDGET ?? 5e4);
 var STRUCTURED_ARRAY_CAP = 25;
@@ -4147,7 +4413,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 ? `
@@ -4197,7 +4463,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 ? {
@@ -5078,7 +5344,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),
@@ -5088,11 +5354,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);
@@ -7391,6 +7691,52 @@ var UnlinkShareSchema = {
     openWorldHint: false
   }
 };
+var memoryCaptureTool_notePropsSchema = import_zod4.z.object({
+  status: import_zod4.z.string().describe("Status enum value from the target vault contract."),
+  summary: import_zod4.z.string().describe("Short retrieval-ready description."),
+  tags: import_zod4.z.array(import_zod4.z.string()).describe("AI-generated keyword tags, not vault names."),
+  pinned: import_zod4.z.boolean().describe("Recall boost for important notes."),
+  source_type: import_zod4.z.string().describe("Attribution kind: user, person, url, file, channel, thread, or note."),
+  source_ref: import_zod4.z.string().describe("Attribution reference (URL, path, channel, thread, or source note)."),
+  related: import_zod4.z.array(import_zod4.z.string()).describe("Same-vault links (wiki [[ ]] targets)."),
+  related_vault_notes: import_zod4.z.array(import_zod4.z.string()).describe('Cross-vault references in "Vault Name::relative/path.md" form.'),
+  embed: import_zod4.z.boolean().describe("Whether Smart RAG should index the note."),
+  embed_priority: import_zod4.z.enum(["low", "normal", "high"]).describe("Embedding priority."),
+  embedding_summary: import_zod4.z.string().describe("Optional retrieval-specific summary."),
+  type: import_zod4.z.string().describe("Note type from the target vault contract (also used to route the note)."),
+  domain: import_zod4.z.string().describe("Domain folder for Library/Knowledge (AI, SEO, Copywriting & Ads, Business, Spirituality)."),
+  folder: import_zod4.z.string().describe("Explicit sub-folder within the vault; overrides routing-derived folder."),
+  parentMessageId: import_zod4.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();
+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: import_zod4.z.string(),
+    folder: import_zod4.z.string().optional(),
+    path: import_zod4.z.string().min(1),
+    title: import_zod4.z.string().min(1),
+    content: import_zod4.z.string().min(1),
+    props: memoryCaptureTool_notePropsSchema,
+    baseRevision: import_zod4.z.number().optional(),
+    tagDecisions: import_zod4.z.array(import_zod4.z.object({ tag: import_zod4.z.string().min(1), central: import_zod4.z.boolean(), reusable: import_zod4.z.boolean(), description: import_zod4.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_zod4.z.boolean(),
+    valid: import_zod4.z.boolean().optional(),
+    errors: import_zod4.z.array(import_zod4.z.string()).optional(),
+    warnings: import_zod4.z.array(import_zod4.z.string()).optional(),
+    tagResolutions: import_zod4.z.array(import_zod4.z.object({ candidate: import_zod4.z.string(), action: import_zod4.z.enum(["reuse", "create", "omit"]), tag: import_zod4.z.string().optional(), reason: import_zod4.z.string() })).optional(),
+    note: import_zod4.z.object({ path: import_zod4.z.string(), title: import_zod4.z.string(), updatedAt: import_zod4.z.string(), revision: import_zod4.z.number() }).optional(),
+    indexed: import_zod4.z.number().optional(),
+    verified: import_zod4.z.object({ contentBytes: import_zod4.z.number(), propsPersisted: import_zod4.z.boolean(), revision: import_zod4.z.number() }).optional(),
+    conflict: import_zod4.z.boolean().optional(),
+    code: import_zod4.z.string().optional(),
+    error: import_zod4.z.string().optional()
+  },
+  annotations: { title: "Capture Governed Memory", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+};
 var MemoryQuestionsSchema = {
   id: "memory-questions",
   upstreamName: "memoryQuestionsTool",
@@ -7420,6 +7766,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: import_zod4.z.string().min(1),
+    content: import_zod4.z.string().min(1),
+    source: import_zod4.z.string().optional(),
+    type: import_zod4.z.string().optional(),
+    vault: import_zod4.z.string().optional(),
+    tagCandidates: import_zod4.z.array(import_zod4.z.object({ tag: import_zod4.z.string().min(1), central: import_zod4.z.boolean().optional(), reusable: import_zod4.z.boolean().optional(), description: import_zod4.z.string().optional() })).max(20).optional(),
+    maxLinks: import_zod4.z.number().int().min(1).max(20).optional()
+  },
+  output: {
+    ok: import_zod4.z.boolean(),
+    route: import_zod4.z.record(import_zod4.z.unknown()).optional(),
+    contract: import_zod4.z.record(import_zod4.z.unknown()).optional(),
+    tagResolutions: import_zod4.z.array(import_zod4.z.record(import_zod4.z.unknown())).optional(),
+    linkOpportunities: import_zod4.z.array(import_zod4.z.record(import_zod4.z.unknown())).optional(),
+    instructions: import_zod4.z.array(import_zod4.z.string()).optional(),
+    error: import_zod4.z.string().optional()
+  },
+  annotations: { title: "Prepare Memory Write", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
+var validateMemoryWriteTool_notePropsSchema = import_zod4.z.object({
+  status: import_zod4.z.string().describe("Status enum value from the target vault contract."),
+  summary: import_zod4.z.string().describe("Short retrieval-ready description."),
+  tags: import_zod4.z.array(import_zod4.z.string()).describe("AI-generated keyword tags, not vault names."),
+  pinned: import_zod4.z.boolean().describe("Recall boost for important notes."),
+  source_type: import_zod4.z.string().describe("Attribution kind: user, person, url, file, channel, thread, or note."),
+  source_ref: import_zod4.z.string().describe("Attribution reference (URL, path, channel, thread, or source note)."),
+  related: import_zod4.z.array(import_zod4.z.string()).describe("Same-vault links (wiki [[ ]] targets)."),
+  related_vault_notes: import_zod4.z.array(import_zod4.z.string()).describe('Cross-vault references in "Vault Name::relative/path.md" form.'),
+  embed: import_zod4.z.boolean().describe("Whether Smart RAG should index the note."),
+  embed_priority: import_zod4.z.enum(["low", "normal", "high"]).describe("Embedding priority."),
+  embedding_summary: import_zod4.z.string().describe("Optional retrieval-specific summary."),
+  type: import_zod4.z.string().describe("Note type from the target vault contract (also used to route the note)."),
+  domain: import_zod4.z.string().describe("Domain folder for Library/Knowledge (AI, SEO, Copywriting & Ads, Business, Spirituality)."),
+  folder: import_zod4.z.string().describe("Explicit sub-folder within the vault; overrides routing-derived folder."),
+  parentMessageId: import_zod4.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();
+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: import_zod4.z.string(),
+    title: import_zod4.z.string(),
+    content: import_zod4.z.string(),
+    props: validateMemoryWriteTool_notePropsSchema
+  },
+  output: {
+    ok: import_zod4.z.boolean(),
+    valid: import_zod4.z.boolean().optional(),
+    errors: import_zod4.z.array(import_zod4.z.string()).optional(),
+    warnings: import_zod4.z.array(import_zod4.z.string()).optional(),
+    normalizedTags: import_zod4.z.array(import_zod4.z.string()).optional(),
+    error: import_zod4.z.string().optional()
+  },
+  annotations: { title: "Validate Memory Write", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
 var CreateChannelSchema = {
   id: "create-channel",
   upstreamName: "createChannelTool",
@@ -7760,18 +8167,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: import_zod4.z.string().min(1),
+    vault: import_zod4.z.string().optional()
+  },
+  output: {
+    ok: import_zod4.z.boolean(),
+    nodes: import_zod4.z.array(import_zod4.z.object({ id: import_zod4.z.string(), vault: import_zod4.z.string(), path: import_zod4.z.string(), title: import_zod4.z.string(), resolved: import_zod4.z.boolean() })).optional(),
+    edges: import_zod4.z.array(import_zod4.z.object({ source: import_zod4.z.string(), target: import_zod4.z.string(), type: import_zod4.z.string(), evidence: import_zod4.z.string(), sourceField: import_zod4.z.string(), resolved: import_zod4.z.boolean() })).optional(),
+    error: import_zod4.z.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: import_zod4.z.string().min(1),
+    to: import_zod4.z.string().min(1),
+    fromVault: import_zod4.z.string().optional(),
+    toVault: import_zod4.z.string().optional(),
+    maxDepth: import_zod4.z.number().int().min(1).max(12).optional()
+  },
+  output: {
+    ok: import_zod4.z.boolean(),
+    nodes: import_zod4.z.array(import_zod4.z.object({ id: import_zod4.z.string(), vault: import_zod4.z.string(), path: import_zod4.z.string(), title: import_zod4.z.string(), resolved: import_zod4.z.boolean() })).optional(),
+    edges: import_zod4.z.array(import_zod4.z.object({ source: import_zod4.z.string(), target: import_zod4.z.string(), type: import_zod4.z.string(), evidence: import_zod4.z.string(), sourceField: import_zod4.z.string(), resolved: import_zod4.z.boolean() })).optional(),
+    error: import_zod4.z.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: import_zod4.z.string().min(1),
+    vault: import_zod4.z.string().optional(),
+    depth: import_zod4.z.number().int().min(0).max(6).optional(),
+    maxNodes: import_zod4.z.number().int().min(1).max(500).optional()
+  },
+  output: {
+    ok: import_zod4.z.boolean(),
+    root: import_zod4.z.string().optional(),
+    depth: import_zod4.z.number().optional(),
+    truncated: import_zod4.z.boolean().optional(),
+    nodes: import_zod4.z.array(import_zod4.z.object({ id: import_zod4.z.string(), vault: import_zod4.z.string(), path: import_zod4.z.string(), title: import_zod4.z.string(), resolved: import_zod4.z.boolean() })).optional(),
+    edges: import_zod4.z.array(import_zod4.z.object({ source: import_zod4.z.string(), target: import_zod4.z.string(), type: import_zod4.z.string(), evidence: import_zod4.z.string(), sourceField: import_zod4.z.string(), resolved: import_zod4.z.boolean() })).optional(),
+    error: import_zod4.z.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: import_zod4.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_zod4.z.string().min(1).describe("Short human-readable title for the item; used to build the stored path. Must be non-empty."),
     content: import_zod4.z.string().min(1).describe("The full captured text (scrape/transcript/output) to store and index. Must be non-empty."),
     source: import_zod4.z.string().min(1).describe("Provenance of the content, e.g. a URL or tool name. Must be non-empty."),
     capturedAt: import_zod4.z.string().optional().describe("ISO-8601 capture timestamp. Optional; defaults to now. Also seeds the deterministic storage path."),
+    summary: import_zod4.z.string().optional().describe("Retrieval-ready source summary. Optional; a provenance summary is generated when omitted."),
+    tags: import_zod4.z.array(import_zod4.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_zod4.z.array(import_zod4.z.string()).optional().describe("Reviewed same-vault Library note paths."),
+    relatedVaultNotes: import_zod4.z.array(import_zod4.z.string()).optional().describe("Reviewed cross-vault references in Vault::path.md form."),
     localVaultPath: import_zod4.z.string().optional().describe("Filesystem root to also mirror the item to. Optional; falls back to MEMORY_LOCAL_VAULT_ROOT env when set.")
   },
   output: {
@@ -7781,6 +8248,7 @@ var LibraryIngestSchema = {
     path: import_zod4.z.string().optional().describe("Vault-relative path the item was stored at (under library/...)."),
     indexed: import_zod4.z.number().optional().describe("Number of search chunks indexed (0 if embedding failed but the note still saved)."),
     dualWritten: import_zod4.z.boolean().optional().describe("True if the item was also mirrored to the local filesystem vault."),
+    nextStep: import_zod4.z.string().optional().describe("Recommended extraction action after the raw Library source is safe."),
     code: import_zod4.z.string().optional().describe("Machine-readable denial code when ok is false: quota_exceeded or free_cost_cap."),
     error: import_zod4.z.string().optional().describe("Human-readable failure reason when ok is false.")
   },
@@ -7858,10 +8326,27 @@ var ExportSchema = {
     openWorldHint: false
   }
 };
+var getTool_notePropsSchema = import_zod4.z.object({
+  status: import_zod4.z.string().describe("Status enum value from the target vault contract."),
+  summary: import_zod4.z.string().describe("Short retrieval-ready description."),
+  tags: import_zod4.z.array(import_zod4.z.string()).describe("AI-generated keyword tags, not vault names."),
+  pinned: import_zod4.z.boolean().describe("Recall boost for important notes."),
+  source_type: import_zod4.z.string().describe("Attribution kind: user, person, url, file, channel, thread, or note."),
+  source_ref: import_zod4.z.string().describe("Attribution reference (URL, path, channel, thread, or source note)."),
+  related: import_zod4.z.array(import_zod4.z.string()).describe("Same-vault links (wiki [[ ]] targets)."),
+  related_vault_notes: import_zod4.z.array(import_zod4.z.string()).describe('Cross-vault references in "Vault Name::relative/path.md" form.'),
+  embed: import_zod4.z.boolean().describe("Whether Smart RAG should index the note."),
+  embed_priority: import_zod4.z.enum(["low", "normal", "high"]).describe("Embedding priority."),
+  embedding_summary: import_zod4.z.string().describe("Optional retrieval-specific summary."),
+  type: import_zod4.z.string().describe("Note type from the target vault contract (also used to route the note)."),
+  domain: import_zod4.z.string().describe("Domain folder for Library/Knowledge (AI, SEO, Copywriting & Ads, Business, Spirituality)."),
+  folder: import_zod4.z.string().describe("Explicit sub-folder within the vault; overrides routing-derived folder."),
+  parentMessageId: import_zod4.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();
 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: import_zod4.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."
@@ -7881,6 +8366,7 @@ var GetSchema = {
       capturedAt: import_zod4.z.string().describe("ISO-8601 timestamp of when the note was first captured."),
       revision: import_zod4.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_zod4.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_zod4.z.string().optional().describe("Present only when read via shareId: the identity who owns and shared this note."),
       othersEditing: import_zod4.z.array(import_zod4.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."),
@@ -7928,7 +8414,7 @@ var ListSchema = {
     openWorldHint: false
   }
 };
-var notePropsSchema = import_zod4.z.object({
+var putTool_notePropsSchema = import_zod4.z.object({
   status: import_zod4.z.string().describe("Status enum value from the target vault contract."),
   summary: import_zod4.z.string().describe("Short retrieval-ready description."),
   tags: import_zod4.z.array(import_zod4.z.string()).describe("AI-generated keyword tags, not vault names."),
@@ -7944,7 +8430,7 @@ var notePropsSchema = import_zod4.z.object({
   domain: import_zod4.z.string().describe("Domain folder for Library/Knowledge (AI, SEO, Copywriting & Ads, Business, Spirituality)."),
   folder: import_zod4.z.string().describe("Explicit sub-folder within the vault; overrides routing-derived folder."),
   parentMessageId: import_zod4.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();
 var PutSchema = {
   id: "memory-put",
   upstreamName: "putTool",
@@ -7957,7 +8443,7 @@ var PutSchema = {
     shareId: import_zod4.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_zod4.z.string().optional().describe("Optional human-readable title; defaults are derived from the path when omitted."),
     content: import_zod4.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_zod4.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: {
@@ -8571,6 +9057,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: import_zod4.z.boolean().optional()
+  },
+  output: {
+    ok: import_zod4.z.boolean(),
+    tags: import_zod4.z.array(import_zod4.z.object({ tag: import_zod4.z.string(), description: import_zod4.z.string().nullable(), aliases: import_zod4.z.array(import_zod4.z.string()), status: import_zod4.z.enum(["active", "deprecated"]), usageCount: import_zod4.z.number(), vaultUsage: import_zod4.z.record(import_zod4.z.number()) })).optional(),
+    error: import_zod4.z.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: import_zod4.z.array(import_zod4.z.object({ tag: import_zod4.z.string().min(1), central: import_zod4.z.boolean().optional(), reusable: import_zod4.z.boolean().optional(), description: import_zod4.z.string().optional() })).min(1).max(20)
+  },
+  output: {
+    ok: import_zod4.z.boolean(),
+    resolutions: import_zod4.z.array(import_zod4.z.object({ candidate: import_zod4.z.string(), normalized: import_zod4.z.string(), action: import_zod4.z.enum(["reuse", "create", "omit"]), tag: import_zod4.z.string().optional(), matchedBy: import_zod4.z.enum(["exact", "alias", "near"]).optional(), score: import_zod4.z.number().optional(), reason: import_zod4.z.string() })).optional(),
+    error: import_zod4.z.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: import_zod4.z.string().min(1),
+    description: import_zod4.z.string().optional(),
+    aliases: import_zod4.z.array(import_zod4.z.string()).optional(),
+    status: import_zod4.z.enum(["active", "deprecated"]).optional()
+  },
+  output: {
+    ok: import_zod4.z.boolean(),
+    tag: import_zod4.z.object({ tag: import_zod4.z.string(), description: import_zod4.z.string().nullable(), aliases: import_zod4.z.array(import_zod4.z.string()), status: import_zod4.z.enum(["active", "deprecated"]) }).optional(),
+    error: import_zod4.z.string().optional()
+  },
+  annotations: { title: "Upsert Memory Tag", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
 var AddVaultSchema = {
   id: "add-vault",
   upstreamName: "addVaultTool",
@@ -8638,6 +9169,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: import_zod4.z.string().describe("One governed vault: Ideas, Inspiration, Knowledge, Library, People, Communications, Calendar, Tasks, Projects, Issues, Improvement Log, Experiments, or Sprint.")
+  },
+  output: {
+    ok: import_zod4.z.boolean(),
+    vault: import_zod4.z.string().optional(),
+    contract: import_zod4.z.record(import_zod4.z.unknown()).optional(),
+    error: import_zod4.z.string().optional()
+  },
+  annotations: { title: "Get Vault Contract", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
 var ListSharedWithMeSchema = {
   id: "list-shared-with-me",
   upstreamName: "listSharedWithMeTool",
@@ -8722,6 +9268,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: import_zod4.z.string().min(1),
+    content: import_zod4.z.string().min(1),
+    type: import_zod4.z.string().optional(),
+    source: import_zod4.z.string().optional()
+  },
+  output: {
+    ok: import_zod4.z.boolean(),
+    vault: import_zod4.z.string().optional(),
+    folder: import_zod4.z.string().optional(),
+    reason: import_zod4.z.string().optional(),
+    contract: import_zod4.z.record(import_zod4.z.unknown()).optional(),
+    error: import_zod4.z.string().optional()
+  },
+  annotations: { title: "Route Memory", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
 var VideoAnalyzeStartSchema = {
   id: "video-analyze-start",
   upstreamName: "videoAnalyzeStartTool",
@@ -8844,7 +9410,10 @@ var MEMORY_TOOL_SCHEMAS = [
   SwapVaultSchema,
   SwitchAccountSchema,
   UnlinkShareSchema,
+  MemoryCaptureSchema,
   MemoryQuestionsSchema,
+  PrepareMemoryWriteSchema,
+  ValidateMemoryWriteSchema,
   CreateChannelSchema,
   GetMessageNoteSchema,
   ListChannelMembersSchema,
@@ -8857,6 +9426,9 @@ var MEMORY_TOOL_SCHEMAS = [
   ReplyMessageSchema,
   FactHistorySchema,
   RecordFactSchema,
+  NoteBacklinksSchema,
+  GraphPathSchema,
+  GraphUniverseSchema,
   LibraryIngestSchema,
   DeleteNoteSchema,
   ExportSchema,
@@ -8886,12 +9458,17 @@ var MEMORY_TOOL_SCHEMAS = [
   InsertTableRowsSchema,
   ListTablesSchema,
   QueryTableSchema,
+  ListTagsSchema,
+  ResolveTagsSchema,
+  UpsertTagSchema,
   AddVaultSchema,
   CreateSecureVaultSchema,
   DeleteVaultSchema,
+  GetVaultContractSchema,
   ListSharedWithMeSchema,
   ListVaultsSchema,
   ProvisionDefaultsSchema,
+  RouteMemorySchema,
   VideoAnalyzeStartSchema,
   VideoAnalyzeStatusSchema,
   CreateWebhookSchema,