@nooticr/mcp 1.26.41 → 1.26.42

package/README.md

@@ -67,7 +67,7 @@ them caps that fan-out with an argument.
 | Tool | Credits | What it is for |
 |------|---------|----------------|
 | `get_social_media` | 1 | The post's facts and media — contentType, title, caption, author, stats, direct media URLs, plus an inline thumbnail. Use when you want the post itself and nothing interpreted. |
-| `get_post_transcript` | 1 | The words actually spoken. Where the platform publishes a caption track (TikTok, Douyin, YouTube) it is read as-is — exact rather than inferred, and far cheaper than watching the video; everywhere else the post's own audio is transcribed, which needs speech-to-text configured on the server. Use before any analysis when the wording matters. |
+| `get_post_transcript` | 1 | The words actually spoken. Where the platform publishes a caption track (TikTok, Douyin, YouTube) it is read as-is — exact rather than inferred, and far cheaper than watching the video; everywhere else the post's own audio is transcribed, which needs speech-to-text configured on the server. `format: "srt"` or `"vtt"` also returns a ready caption file built from the track's own timing, at no extra cost. Use before any analysis when the wording matters. |
 | `get_post_frames` | 2 | Frames sampled evenly across a post's video, returned as **images you can actually look at** — not a description of them. ffmpeg opens the stream directly rather than downloading it, so HLS works and an expired link is re-resolved on the spot. Verified live at 3/3 on TikTok, YouTube, Instagram, Douyin and X; Reddit works on video posts. A carousel or slideshow returns its own images unchanged. Each frame costs roughly 1,200 tokens of your context. |
 | `get_post_comments` | 2 | Top comments plus the themes the platform clusters them into, with which ones the creator pinned or liked. Use when you want to read what people wrote. |
 
@@ -78,7 +78,7 @@ them caps that fan-out with an argument.
 | `analyze_post_fast` | 2 | The post's transcript, caption and stats — everything but the pictures, which is what makes it the cheap read. Two fetches: `get_social_media` (1) and `get_post_transcript` (1). The sensible default. |
 | `analyze_post` | 3 | Frames sampled across the video, as **images your model can actually look at**, plus the transcript. Two fetches: `get_post_frames` (2) and `get_post_transcript` (1). Use when the visuals are the point — framing, editing, on-screen text. |
 | `understand_social_post` | 3 | The same two fetches, asked for a description of what physically happens on screen rather than why it works. Use when you need the events, not the strategy. |
-| `analyze_comments` | 2 | The comment section, every comment with a stable id, and the taxonomy to label them with — sentiment, and whether each is praise, a complaint, a bug report, a question, a request, a comparison or spam. The same `get_post_comments` call, at the same price as reading them directly. |
+| `analyze_comments` | 2 | The comment section, every comment with a stable id, and the taxonomy to label them with — sentiment, and whether each is praise, a complaint, a bug report, a question, a request, a comparison or spam. The same `get_post_comments` call, at the same price as reading them directly. Pass `verbatim: true` to have every item rendered whole for quoting rather than clipped to fit; same price. |
 | `show_comment_review` | free | Draws the classifications your model produced — every comment with its sentiment and category, filterable and selectable. Makes no requests; it only renders what you pass it. |
 | `show_post_analysis` | free | Draws the analysis your model wrote from `analyze_post`/`analyze_post_fast`/`understand_social_post` — hook strength, script structure, quotable lines, suggested hashtags and more, whichever fields you produced. Makes no requests; it only renders what you pass it. |
 | `compare_posts` | 1 | The first of two to five posts, fetched with its stats, and the comparison left to you. Fetch the rest with `get_social_media` at 1 credit each. Use when performance differs and you need to know why. |
@@ -92,12 +92,14 @@ them caps that fan-out with an argument.
 | `get_user_posts` | 2 | One creator's recent posts with stats. Use to scan an account. |
 | `search_creators` | 2 | People by what they make — designers, developers, photographers, anyone with an audience — found by craft, niche or keyword. Use when you know the kind of person but not their names. Searches TikTok, Instagram and Xiaohongshu; **not** YouTube, Douyin, X, Reddit or LinkedIn, which cannot be creator-searched upstream. |
 | `get_similar_creators` | 2 | Lookalikes for a creator that already works. |
+| `suggest_creator_identity` | 2 per network searched, plus 2 to find the handle (6 by default) | The same person on the other networks, from one handle you already know — with the evidence for each: a link published in both bios, one bio naming the other account, an identical handle, a matching display name. **Suggests, never merges**: nothing is stored, a human confirms, and two accounts' follower counts are never added together. TikTok, Instagram and Xiaohongshu. |
 | `discover_sounds` | 2 | Trending audio with playable previews. Sound is a major ranking signal on TikTok. |
 | `discover_hashtags` | 2 | What to tag with. TikTok comes from the Creative Center trend board — volumes plus rising/cooling/steady. The other eight searchable networks have no trend board upstream, so tags are counted across a live sweep of a niche you name: real and current, but a single sample, so no rising/cooling signal. `source` says which you got. LinkedIn cannot be swept. |
 | `find_hook_pattern` | 2 | A creator's recent posts, so their opening lines can be read as a set and turned into fill-in-the-blank templates. One `get_user_posts` call. |
 | `search_mentions` | 2 per network (5 for Xiaohongshu) | **Brand monitoring.** Every *comment* that names a term, across nine networks at once, grouped under the post it was left on. A brand is named far more often in the replies than in a caption, so the comment is the unit — not the post. Takes a `since` date to read a past window, and pages with `offset`/`pageSize` so a nine-network sweep does not arrive all at once. Does not read speech inside a video — `search_spoken_mentions` does, on TikTok, YouTube and Douyin. |
 | `watch_creator` | free | Add a creator to your watchlist. Stores the handle only — nothing is fetched. |
 | `unwatch_creator` | free | Drop a creator from the watchlist. |
+| `list_watchlist` | free | Who you are watching: handle, platform, note, and when you last caught up on each. |
 | `catch_up_watchlist` | 2 per creator | What everyone you watch has posted since your last catch-up. Compares against the snapshot taken last time and moves it forward, so it answers "what is new" rather than "what exists". |
 | `create_brand_watch` | free to call | Schedule a recurring sweep and get emailed only what is new. `kind: "mentions"` (default) is a recurring `search_mentions` sweep for `term`/`platforms`; `kind: "competitor"` is a recurring `get_user_posts` check on one creator (`handle`/`platform`), mailing only what beats their own recent median. Two calls by design: the first returns the quote (cost per run, cadence, cost per day) and a `confirmationToken`; nothing is created or charged until you call it again with `confirm: true` and that token. Each run then bills the same as calling the matching tool yourself — 2 credits per network (5 for Xiaohongshu) for mentions, a flat 2 credits for competitor. |
 | `list_brand_watches` | free | Every watch you have scheduled: term, networks, cadence, cost per run, credits spent so far, runs made, and when the next one is due. |
@@ -110,7 +112,7 @@ them caps that fan-out with an argument.
 
 | Tool | Credits | What it is for |
 |------|---------|----------------|
-| `answer_my_audience` | 2 + 2 per post opened (14 by default) | **The mirror of `search_mentions`.** The questions waiting under your *own* posts: recent posts fetched, comments read on each, grouped under the post they were left on, every comment with a stable id, and the ones that read like questions or requests flagged and sorted to the top. It finds and drafts — it cannot post a reply, because no nooticr connection carries comment-write permission on any network. `limit` caps how many posts are opened, which is the price. |
+| `answer_my_audience` | 2 + 2 per post opened (14 by default) | **The mirror of `search_mentions`.** The questions waiting under your *own* posts: recent posts fetched, comments read on each, grouped under the post they were left on, every comment with a stable id, and the ones that read like questions or requests flagged and sorted to the top. It finds and drafts — it cannot post a reply: nooticr does not post comments on any network, even where a connection's grant allows managing them. `limit` caps how many posts are opened, which is the price. |
 | `prepare_handoff` | free | **The hand-off to your tracker.** Turns items you classified — a bug report in a comment, a complaint said out loud in a video — into the exact `title`, `body` and `labels` to file through whichever GitHub, Jira or Linear MCP server the host also has connected. nooticr files nothing and holds no tracker credential. The body carries the quote fenced and framed as a third-party report rather than as instructions, because the issue is read next by a coding agent; contact details are redacted, `@handles` and `#numbers` are defanged so filing notifies nobody by accident, and a `searchFirst` string dedupes a second sweep against the first. Makes no requests. |
 | `show_audience_replies` | free | Lays your drafts out for a person to work through, grouped under the post, each with what you decided to do about it. Sends nothing; fetches nothing. |
 | `show_standings` | free | Draws the standings your model read out of `compare_creators` or `watchlist_standings` — one row per creator, with the window and the median it was scored against. `ranking` records which axis you ordered on, and `tooThin` draws a creator with too short a window as unranked rather than last: missing from a comparison is not the same as losing it. Makes no requests. |
@@ -119,10 +121,11 @@ them caps that fan-out with an argument.
 | `compare_creators` | 2 per creator (4-10) | Two to five creators side by side on the one axis that compares: each post's ratio to **that creator's own** median. Per creator you get the window that was scored, their median, the share of it that beat that median, how hard they beat it when they did, every ratio, and their best and worst post. It does not rank them — "how often they land one" and "how big it is when they do" usually disagree, and a hit rate over a short window is one post either way, so the window travels with every number and the read is yours. |
 | `watchlist_standings` | 2 per watched creator | The same, across everyone on your watchlist: "who moved" in one call instead of one per creator. Reading the watchlist is free; the fetches are not, so it confirms the total before spending. `catch_up_watchlist` answers what is **new**; this answers how it **did**. |
 | `who_should_i_work_with` | 2, or 4 with a seed | A collaboration shortlist: a keyword search merged with the lookalikes of a creator who already fits, marked by which search found each one. Every candidate also carries the **links pulled out of their bio**, typed and sorted by how much opening one will tell you — a repository to read the code in, their own site, a link hub that holds the real links — so vetting is reading the work rather than re-reading the follower count. Those links are never fetched here: they came out of a field the person being evaluated controls, so the host opens them, and the result says so. It does **not** measure audience overlap — that costs about nine credits a candidate, so the result says so and shows how to check a finalist rather than faking the signal. |
-| `find_people_with_problem` | 6 per platform | Find people **describing a problem in their own words** — prospects, early users, anyone whose complaint your product answers. Say the problem the way a person would say it and it searches for posts shaped like that complaint rather than for the topic it is about: searching the topic finds marketing about it, which is what `discover_social_posts` is for. Widens the query into the forms a complaint takes — the plain phrasing, the does-anyone-else question, the is-there-a-tool ask — and marks which one surfaced each post. A wide cheap net and **not** a filter: the posts come back for you to judge, and plenty will be off-target. Defaults to reddit, where people describe workflow pain in sentences. Each platform is searched once per query shape — three by default, at 2 credits a search. Not searchable here: linkedin, which has no keyword post search upstream. |
+| `find_people_with_problem` | 6 per platform | Find people **describing a problem in their own words** — prospects, early users, anyone whose complaint your product answers. Say the problem the way a person would say it and it searches for posts shaped like that complaint rather than for the topic it is about: searching the topic finds marketing about it, which is what `discover_social_posts` is for. Widens the query into the forms a complaint takes — the plain phrasing, the does-anyone-else question, the is-there-a-tool ask — and marks which one surfaced each post. A wide cheap net and **not** a filter: the posts come back for you to judge, and plenty will be off-target. Defaults to reddit, where people describe workflow pain in sentences. Each platform is searched once per query shape — three by default, at 2 credits a search. Not searchable here: linkedin, which has no keyword post search upstream. Pass `verbatim: true` to have every item rendered whole for quoting rather than clipped to fit; same price. |
 | `show_collab_shortlist` | free | Draws the candidates you scored, ranked, and asks the user which to approach. The scores are attributed to your model, not presented as a nooticr rating, and a candidate scored without anything having been opened is marked unverified. Makes no requests. |
 | `why_did_this_underperform` | 3 | One post against the creator's own recent distribution, with the post taken back out of its own baseline. Returns median, quartiles, ratio and percentile, so the answer can be "this is an ordinary result, not a failure". Different question from `compare_posts`, which weighs two URLs you already picked. |
 | `what_should_i_make_next` | 2 + 2 per post read + 2 (12 by default) | Demand against supply: what your commenters explicitly ask for, set beside what a niche sweep shows is already being made. A gap nobody asked for is noise; a request nobody serves is the opportunity. Falls back to your most-used hashtag when you name no niche. |
+| `detect_spoken_mentions` | 2 | **Every brand named out loud in one video.** The spoken transcript and the written caption, side by side, for your model to list each brand with its verbatim sentence, the creator's framing and whether it was said, written or both. Works where the creator never enabled captions, because the audio is transcribed. 1 credit for `get_post_transcript` plus 1 for `get_social_media`; nothing when no transcript can be made. |
 | `search_spoken_mentions` | 2 per platform narrowed by niche + 2 per creator handle + 1 per transcript, up to `maxTranscripts` | **The mirror of `search_mentions`, for what was said rather than typed.** Narrows to candidate posts (a niche sweep, named handles, and/or your watchlist), transcribes only the most-viewed survivors up to a hard ceiling, and searches the words for the term — TikTok, YouTube and Douyin, and only where the creator actually enabled captions. Reports how many candidates were found, transcribed and matched, so the spend is legible. |
 
 ### Study a market on Amazon
@@ -148,7 +151,7 @@ a `scanId` for the rest.
 | `scan_marketplace_category` | 3 per product collected (30 by default) | The same category read on eleven more sites — AliExpress, Cdiscount, Flipkart, Mercado Libre, Lazada, Otto, Rakuten, Trendyol, Jumia, Vinted and Temu. Vinted is resale rather than retail, so its `rating` describes the seller and the scan says so in `ratingScope` — do not read it as a product's reviews. `marketplace` picks the site; `market` picks the storefront for the sites that have several, and the argument names the real set per site so a model cannot send Otto a Lazada region. Same rollup, same confirmation before spending. |
 | `marketplace_scan_status` | free | Picks a running marketplace collection back up by `scanId` and the same `marketplace`. Free, for the same reason `amazon_scan_status` is. |
 | `get_marketplace_product` | 3 | One product from any of the twelve sites, by id or URL: price, rating, the full star histogram, specs and the reviews. |
-| `show_amazon_category_insights` | free | Draws the read **your model** wrote — purchase drivers, barriers, what each brand does well, the gaps, the positioning angles — beside the listings and their reviews, so a person can click a product and check any claim against the text it came from. The conclusions are attributed to your model, never presented as a nooticr rating of anyone's product. Makes no requests. |
+| `show_amazon_category_insights` | free | Draws the read **your model** wrote — purchase drivers, barriers, what each brand does well, the gaps, the positioning angles — beside the listings and their reviews, so a person can click a product and check any claim against the text it came from. The conclusions are attributed to your model, never presented as a nooticr rating of anyone's product. Given the `scanId`, it re-reads the listings from the scan itself (free) instead of drawing whatever the model re-sends, and flags any ASIN the read cites that the scan does not contain; without one, the card says its listings were not checked. |
 
 ### Make something
 
@@ -166,9 +169,12 @@ a `scanId` for the rest.
 
 | Tool | Credits | What it is for |
 |------|---------|----------------|
+| `nooticr_getting_started` | free | **Start here.** Where this account stands — balance, connected accounts, watchlist — and the next calls worth making, each with its price and an example. The server's `instructions` point every host at it. |
 | `check_nooticr_credits` | free | Balance and billing URL. |
+| `list_tool_runs` | free | Your tool-call history: what ran, whether it worked, and the credits each call actually took (0 for a free, refunded, cached or replayed call). `scope: "workspace"` shows every member's runs to owners and admins. |
+| `get_tool_run` | free | One run from that history by id, with its full error. |
 | `nooticr_login` | free | Re-link the account when a call fails with an authentication error. |
-| `list_social_connections` | free | What you have connected and what each connection is actually allowed to do — read the account, publish a post, manage comments — as yes, no or **unknown**. Unknown means the grant predates scope recording: treat it as "try it", not as a refusal. Also says which platforms can be linked at all, which is a smaller set than the networks nooticr reads. |
+| `list_social_connections` | free | What you have connected and what each connection is actually allowed to do — read the account, publish a post, manage comments — as yes, no or **unknown**. "Manage comments" reports the platform's grant; no nooticr tool posts or replies to a comment. Unknown means the grant predates scope recording: treat it as "try it", not as a refusal. Also says which platforms can be linked at all, which is a smaller set than the networks nooticr reads. |
 | `connect_social_account` | free | A link the user opens to connect one account. They approve at the provider in their own browser; nothing is connected until they do, and no credential passes through the tool or the model's context. Each call mints a fresh link — an old one does not work twice. |
 | `create_product` | free | Create a product in your own workspace — the row every other own-account tool needs before it has anything to work with. Always creates in the calling session's workspace, never one you could name. `name` and `slug` are required; every other field is snake_case and read by exact key, so a camelCase `websiteUrl` lands nowhere. Writes no brand playbook. |
 | `update_product` | free | Patch a product's fields. An omitted argument leaves its column unchanged, so this cannot blank a field by not mentioning it, and the result lists what was actually written — a misspelled field shows up as one that did not change rather than as a silent no-op. |

package/dist/shared/amazon.js

@@ -192,7 +192,7 @@ export function categoryGuidance(opts) {
     lines.push("Judge only from what the reviews say. Where the evidence is thin, say so rather than", "producing a confident line the text does not support — a category read that overstates its", "basis is worse than a short one. Prices, ratings and mention counts are in the payload;", "do not re-derive them by hand.");
     if (insightsTool) {
         lines.push("");
-        lines.push("To show the result in the conversation — products, their reviews, and your read side by", `side — call ${insightsTool} with what you concluded. It costs nothing and`, "makes no further requests.");
+        lines.push("To show the result in the conversation — products, their reviews, and your read side by", `side — call ${insightsTool} with what you concluded${opts.scanId ? ` and scanId "${opts.scanId}"` : " and the scanId"}.`, "It costs nothing, and it re-reads the listings from the scan itself, so do not re-send them.");
     }
     return lines.join("\n");
 }
@@ -390,14 +390,19 @@ export function registerAmazonTools(server, makeClient) {
         description: "Display the category read you produced from scan_amazon_category: purchase drivers, " +
             "barriers, what each brand does well, the gaps, and the positioning angles — drawn beside " +
             "the listings and their reviews, so a person can click a product and check any claim " +
-            "against the text it came from. Free, and makes no requests: it only draws what you pass " +
-            "it, attributed to you rather than presented as a nooticr rating of anyone's product. " +
+            "against the text it came from. Pass the scanId: the listings are then re-read from the " +
+            "scan itself (free) rather than taken from you, so do not re-send them, and any ASIN you " +
+            "cite that the scan does not contain is flagged on the card. Without a scanId, listings " +
+            "you pass are drawn marked as not checked against a scan. Free. Your read is attributed " +
+            "to you rather than presented as a nooticr rating of anyone's product. " +
             "Call this after you have read the reviews, not instead of reading them.",
         annotations: {
             readOnlyHint: true,
             destructiveHint: false,
             idempotentHint: true,
-            // Draws what it is given; reaches nothing.
+            // Draws what it is given. Its one request re-reads a scan the caller
+            // already ran, from nooticr's own job store with no wait, so it
+            // fetches nothing new from the marketplace (#107).
             openWorldHint: false,
         },
         outputSchema: OUTPUT_SCHEMAS.show_amazon_category_insights,
@@ -457,15 +462,17 @@ export function registerAmazonTools(server, makeClient) {
             products: z
                 .array(anyObject())
                 .optional()
-                .describe("The listings from the scan, passed straight through so the view can draw them."),
-            rollup: anyObject().optional().describe("The rollup from the scan, passed straight through."),
-            scanId: z.string().optional().describe("The scan this reads, for the record."),
+                .describe("Only when there is no scanId. With one, the listings are re-read from the scan and anything here is ignored."),
+            rollup: anyObject().optional().describe("Only when there is no scanId; re-read from the scan otherwise."),
+            scanId: z
+                .string()
+                .optional()
+                .describe("The scan this reads. Pass it: it is what lets the card draw the collector's own listings."),
         })
             .passthrough(),
-    }, async (args) => {
-        const products = Array.isArray(args.products)
-            ? args.products
-            : [];
+    }, async (args, extra) => {
+        const checked = await rehydrate(args, () => makeClient({ ...extra, arguments: args }));
+        const products = checked.products;
         const counts = {
             drivers: Array.isArray(args.drivers) ? args.drivers.length : 0,
             barriers: Array.isArray(args.barriers) ? args.barriers.length : 0,
@@ -475,7 +482,8 @@ export function registerAmazonTools(server, makeClient) {
         const text = `Category read for ${String(args.category ?? "this category")}: ${counts.drivers} driver(s), ` +
             `${counts.barriers} barrier(s), ${counts.gaps} gap(s), ${counts.positioning} positioning angle(s)` +
             `${products.length ? `, drawn beside ${products.length} listing(s)` : ""}.` +
-            (args.summary ? ` ${String(args.summary)}` : "");
+            (args.summary ? ` ${String(args.summary)}` : "") +
+            ` ${checked.verification.note}`;
         return {
             content: [{ type: "text", text }],
             structuredContent: {
@@ -489,14 +497,77 @@ export function registerAmazonTools(server, makeClient) {
                 gaps: args.gaps ?? [],
                 positioning: args.positioning ?? [],
                 products,
-                rollup: args.rollup ?? {},
+                rollup: checked.rollup,
                 scanId: args.scanId ?? null,
-                // Nothing was fetched, so nothing was charged.
+                verification: checked.verification,
+                // The one read is amazon_scan_status, which is free by design.
                 mcpCredits: { cost: 0 },
             },
         };
     });
 }
+/**
+ * The listings a category read is drawn beside, from the scan rather than
+ * from the model (#107).
+ *
+ * The card exists so a person can check a claim against the text it came
+ * from, which only works if the text is the collector's. A model that dropped
+ * three listings, mis-copied a price or invented a competitor used to produce
+ * a card identical to a truthful one. With a scanId the listings are re-read
+ * from the scan, free and with no wait, and whatever the model sent is only
+ * compared against them. Without one, or when the re-read fails, what the
+ * model sent is drawn and marked unverified rather than refused: a card with a
+ * visible caveat is more use to a person than no card.
+ */
+export async function rehydrate(args, client) {
+    const sent = Array.isArray(args.products) ? args.products : [];
+    const sentRollup = (args.rollup ?? {});
+    const scanId = typeof args.scanId === "string" ? args.scanId.trim() : "";
+    const unverified = (note) => ({
+        products: sent,
+        rollup: sentRollup,
+        verification: { status: "unverified", note },
+    });
+    if (!scanId) {
+        return unverified(sent.length
+            ? "No scanId was passed, so these listings are as re-sent and were not checked against a scan."
+            : "No scanId was passed, so there are no listings to draw beside this read.");
+    }
+    let payload;
+    try {
+        const res = await (await client()).callTool("amazon_scan_status", { scanId, waitSeconds: 0 });
+        payload = structured(res);
+    }
+    catch (err) {
+        const why = err instanceof Error ? err.message : String(err);
+        return unverified(`Scan ${scanId} could not be re-read (${why}), so these listings are as re-sent and were not checked.`);
+    }
+    const products = normaliseProducts(payload.products);
+    const ids = new Set(products.map((p) => String(p.asin ?? "")).filter(Boolean));
+    const idOf = (p) => String([p.asin, p.sku, p.pid, p.goods_id, p.item_id, p.product_id, p.id].find((v) => typeof v === "string" && v) ?? "");
+    const notInScan = [...new Set(sent.map(idOf).filter((id) => id && !ids.has(id)))];
+    const cited = Array.isArray(args.strengths)
+        ? args.strengths.map((s) => String(s.asin ?? "")).filter(Boolean)
+        : [];
+    const unknownAsins = [...new Set(cited.filter((a) => !ids.has(a)))];
+    const scanComplete = payload.complete !== false;
+    const flags = [
+        notInScan.length ? `${notInScan.length} listing(s) you sent are not in the scan (${notInScan.join(", ")}) and are not drawn.` : "",
+        unknownAsins.length ? `ASIN(s) cited in strengths but not in the scan: ${unknownAsins.join(", ")}.` : "",
+        scanComplete ? "" : "The scan is still running, so the set drawn is what it had collected so far.",
+    ].filter(Boolean);
+    return {
+        products,
+        rollup: (payload.rollup ?? {}),
+        verification: {
+            status: "verified",
+            note: [`The ${products.length} listing(s) drawn are the scan's own, re-read from ${scanId}.`, ...flags].join(" "),
+            scanComplete,
+            notInScan,
+            unknownAsins,
+        },
+    };
+}
 /**
  * One scan result, shaped for both channels.
  *

package/dist/shared/backend-only.js

@@ -0,0 +1,27 @@
+/**
+ * nooticr-server tools this public surface deliberately does not register.
+ *
+ * `POST /mcp` also serves the dashboard's internal copilot, so it carries
+ * tools that have no business in a Claude or ChatGPT host. Absence alone
+ * reads the same as "nobody got round to it", so each exclusion is written
+ * down with its reason (#106). A tool leaving this list for `TOOL_NAMES` is a
+ * product decision, not a cleanup; tests/backend-only.test.ts keeps the two
+ * lists disjoint.
+ */
+export const BACKEND_ONLY_TOOLS = {
+    get_watchlist_baseline: "Plumbing for BackendWatchStore, which reads a creator's baseline itself; a host has nothing to do with the raw row.",
+    advance_watchlist_baseline: "Plumbing for BackendWatchStore; catch_up_watchlist advances the baseline after the user confirms, so a host never needs to.",
+    buy_nooticr_credits: "No purchase path is exposed to a model (#100). Credits are topped up on the nooticr website.",
+    overlay_bake: "Rendering and publishing stay in the dashboard (#92).",
+    bake_job_status: "Rendering and publishing stay in the dashboard (#92).",
+    compose_sequence: "Rendering and publishing stay in the dashboard (#92).",
+    spawn_variants: "Rendering and publishing stay in the dashboard (#92).",
+    enqueue_publish_job: "Rendering and publishing stay in the dashboard (#92).",
+    schedule_post: "Rendering and publishing stay in the dashboard (#92).",
+    get_batch_history: "History of the dashboard's compose batches, which only exist once rendering does; stays with #92.",
+    get_latest_analysis: "Returns the dashboard's stored AI fleet-analysis verdict; the public surface sells the evidence, not a judgement of ours.",
+    brand_watch_history: "Not a deliberate exclusion: a candidate for the public surface once it has a trend view to draw. Listed so it reads as pending, not forgotten.",
+    get_google_analytics: "Site analytics are dashboard-only until #104 decides their shape.",
+    get_posthog_analytics: "Site analytics are dashboard-only until #104 decides their shape.",
+    get_search_console_data: "Site analytics are dashboard-only until #104 decides their shape.",
+};

package/dist/shared/connections.js

@@ -44,8 +44,10 @@ export function registerConnectionTools(server, makeClient) {
             "allowed to do — read the account, publish a post, manage comments. Each answer is yes, " +
             "no, or unknown; unknown means the grant predates scope recording, so treat it as \"try " +
             "it\", not as a refusal. Also returns which platforms can be connected at all, which is a " +
-            "smaller set than the networks nooticr can read. Call this before promising that " +
-            "something can be posted or replied to. No cost to call.",
+            "smaller set than the networks nooticr can read. \"Manage comments\" reports what the " +
+            "platform granted, not something nooticr does: no nooticr tool posts, replies to or " +
+            "moderates a comment, so a yes there never means a drafted reply will be sent. Call this " +
+            "before promising that something can be posted or replied to. No cost to call.",
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
         inputSchema: z.object({}).strict(),
         outputSchema: OUTPUT_SCHEMAS.list_social_connections,

package/dist/shared/evidence-digest.js

@@ -48,11 +48,37 @@ const ITEM_CHARS = 600;
 const DIGEST_CHARS = 6000;
 /** How many items of one kind are worth rendering before the count matters more than the detail. */
 const MAX_ITEMS = 25;
+function budget(verbatim) {
+    return verbatim
+        ? { item: 20_000, reply: 20_000, replies: 1_000, field: 4_000, digest: 200_000, items: 500, clipped: false }
+        : { item: ITEM_CHARS, reply: 240, replies: 4, field: 160, digest: DIGEST_CHARS, items: MAX_ITEMS, clipped: false };
+}
 const str = (v) => (typeof v === "string" ? v : "");
 const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
-function clamp(text, max = ITEM_CHARS) {
+function clamp(text, max, b) {
     const flat = text.replace(/\s+/g, " ").trim();
-    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+    if (flat.length <= max)
+        return flat;
+    if (b)
+        b.clipped = true;
+    return `${flat.slice(0, max - 1)}…`;
+}
+/**
+ * The picture to embed beside a row, proxied where one exists (#91).
+ *
+ * A report writer on a host that renders the view gets only this text block,
+ * so without it the model had the review text and the price and no picture
+ * to put next to them. The proxy URL comes first for the reason
+ * `normaliseProducts` gives: the raw CDN link is signed, short-lived and
+ * Referer-gated, so pasted into a document it dies within the hour.
+ */
+function media(row) {
+    for (const k of ["thumbnailProxyUrl", "imageProxyUrl", "image", "coverProxyUrl", "thumbnailUrl", "coverUrl"]) {
+        const v = row[k];
+        if (typeof v === "string" && /^https?:\/\//.test(v))
+            return v;
+    }
+    return "";
 }
 /** `12.3k`, because a raw 12345 beside four other numbers is harder to read than it looks. */
 function compactCount(n) {
@@ -82,7 +108,7 @@ function stats(row) {
  * for qualifying posts to be reported "with their permalink, so they can
  * actually be replied to". A digest without links cannot answer that.
  */
-function postLine(row) {
+function postLine(row, b) {
     const head = [
         str(row.platform) || null,
         str(row.creatorHandle) ? `@${str(row.creatorHandle)}` : null,
@@ -92,20 +118,22 @@ function postLine(row) {
     ]
         .filter(Boolean)
         .join(" · ");
-    const text = clamp(str(row.caption) || str(row.title) || str(row.text));
+    const text = clamp(str(row.caption) || str(row.title) || str(row.text), b.item, b);
     const url = str(row.externalUrl) || str(row.url);
+    const picture = media(row);
     // Replies under the post, when something opened it. Nested one level down,
     // which is exactly where #59 could come back without the chain-map gate
     // noticing: `posts` is rendered, so the check is satisfied while the thing
     // that was paid for — the comment that says "same here, this is my problem"
     // — stays in the payload only.
     const replies = Array.isArray(row.commentSample) ? row.commentSample : [];
-    const shown = replies.slice(0, 4).map((c) => `    - ${clamp(commentLine(c), 240)}`);
+    const shown = replies.slice(0, b.replies).map((c) => `    - ${clamp(commentLine(c, b), b.reply, b)}`);
     if (replies.length > shown.length) {
+        b.clipped = true;
         shown.push(`    - (${replies.length - shown.length} more under this post)`);
     }
     const readNothing = row.commentsRead === 0 ? "    - (this thread would not open — not that nobody replied)" : "";
-    return [head && `[${head}]`, text, url, ...shown, readNothing]
+    return [head && `[${head}]`, text, url, picture && `image: ${picture}`, ...shown, readNothing]
         .filter(Boolean)
         .join("\n  ");
 }
@@ -116,16 +144,16 @@ function postLine(row) {
  * classification per comment and `show_comment_review` takes those ids back.
  * A digest that renders the text and drops the id breaks the next call.
  */
-function commentLine(row) {
+function commentLine(row, b) {
     const id = str(row.id);
     const who = str(row.author) || str(row.username);
     const likes = num(row.likes);
     const head = [id || null, who ? `@${who}` : null, likes ? `${compactCount(likes)} likes` : null]
         .filter(Boolean)
         .join(" · ");
-    return [head && `[${head}]`, clamp(str(row.text) || str(row.comment))].filter(Boolean).join("\n  ");
+    return [head && `[${head}]`, clamp(str(row.text) || str(row.comment), b.item, b)].filter(Boolean).join("\n  ");
 }
-function creatorLine(row) {
+function creatorLine(row, b) {
     const head = [
         str(row.username) ? `@${str(row.username)}` : str(row.handle) ? `@${str(row.handle)}` : null,
         str(row.platform) || null,
@@ -134,7 +162,7 @@ function creatorLine(row) {
     ]
         .filter(Boolean)
         .join(" · ");
-    const why = clamp(str(row.why) || str(row.bio) || str(row.verdict));
+    const why = clamp(str(row.why) || str(row.bio) || str(row.verdict), b.item, b);
     const links = Array.isArray(row.links)
         ? row.links
             .map((l) => str(l.url))
@@ -150,11 +178,34 @@ function runLine(row) {
     const reported = num(row.reported);
     return `${when || "(undated)"} · found ${found ?? "?"} · reported ${reported ?? "?"}`;
 }
+/**
+ * One marketplace listing, with its picture (#91).
+ *
+ * Products used to fall to `genericLine`, whose first eight scalar fields ran
+ * out before `image` — so the one listing field a report most wants to embed
+ * never reached the model.
+ */
+function productLine(row, b) {
+    const rating = num(row.rating);
+    const count = num(row.ratingCount);
+    const head = [
+        str(row.asin) || null,
+        str(row.brand) || null,
+        str(row.price) || null,
+        rating != null ? `${rating}★${count ? ` from ${compactCount(count)} ratings` : ""}` : null,
+    ]
+        .filter(Boolean)
+        .join(" · ");
+    const picture = media(row);
+    return [head && `[${head}]`, clamp(str(row.title), b.item, b), str(row.url), picture && `image: ${picture}`]
+        .filter(Boolean)
+        .join("\n  ");
+}
 /** Everything with no shape of its own: the short scalar fields, in order. */
-function genericLine(row) {
+function genericLine(row, b) {
     const pairs = Object.entries(row)
         .filter(([, v]) => typeof v === "string" || typeof v === "number" || typeof v === "boolean")
-        .map(([k, v]) => `${k}: ${clamp(String(v), 160)}`)
+        .map(([k, v]) => `${k}: ${clamp(String(v), b.field, b)}`)
         .slice(0, 8);
     return pairs.join(" · ");
 }
@@ -166,6 +217,7 @@ function genericLine(row) {
  */
 const SHAPES = [
     { key: "posts", label: "post", line: postLine },
+    { key: "products", label: "listing", line: productLine },
     // The baseline a post is scored against, and the asks a niche sweep found.
     // Both are posts in all but name, and both are the material their tool's
     // guidance reasons over — `why_did_this_underperform` cannot say "this is an
@@ -237,20 +289,24 @@ function unclaimedShapes(payload) {
     })
         .map(([key]) => ({ key, label: key.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase(), line: genericLine }));
 }
-export function evidenceDigest(payload) {
+export function evidenceDigest(payload, opts = {}) {
     const blocks = [];
     let spent = 0;
+    const b = budget(opts.verbatim === true);
+    const elsewhere = opts.recover
+        ? `the rest are in the structured payload and in the view; to read them here, ${opts.recover}`
+        : "the rest are in the structured payload and in the view";
     for (const shape of [...SHAPES, ...unclaimedShapes(payload)]) {
         const rows = payload[shape.key];
         if (!Array.isArray(rows) || rows.length === 0)
             continue;
-        if (spent >= DIGEST_CHARS)
+        if (spent >= b.digest)
             break;
         const shown = [];
-        for (const row of rows.slice(0, MAX_ITEMS)) {
-            if (spent >= DIGEST_CHARS)
+        for (const row of rows.slice(0, b.items)) {
+            if (spent >= b.digest)
                 break;
-            const line = shape.line((row ?? {}));
+            const line = shape.line((row ?? {}), b);
             if (!line.trim())
                 continue;
             shown.push(line);
@@ -264,10 +320,17 @@ export function evidenceDigest(payload) {
         const total = rows.length;
         const plural = total === 1 || shape.label.endsWith("s") ? shape.label : `${shape.label}s`;
         const header = shown.length < total
-            ? `${shown.length} of ${total} ${plural} (the rest are in the structured payload and in the view):`
+            ? `${shown.length} of ${total} ${plural} (${elsewhere}):`
             : `${total} ${plural}:`;
         blocks.push([header, ...shown.map((l, i) => `${i + 1}. ${l}`)].join("\n"));
     }
+    // A clipped item ends in "…", which a model can miss and then quote as if
+    // whole. Said once, with the way to get the full text when there is one.
+    if (b.clipped && blocks.length) {
+        blocks.push(opts.recover
+            ? `Some text above was shortened (it ends in "…"). Do not quote a shortened line as complete; to get every item whole, ${opts.recover}.`
+            : `Some text above was shortened (it ends in "…"). Do not quote a shortened line as complete.`);
+    }
     return blocks.join("\n\n");
 }
 /**
@@ -276,7 +339,7 @@ export function evidenceDigest(payload) {
  * Guidance first: it is the instruction, and a model that reads the material
  * before knowing what it is for reads it twice.
  */
-export function withEvidence(guidance, payload) {
-    const digest = evidenceDigest(payload);
+export function withEvidence(guidance, payload, opts = {}) {
+    const digest = evidenceDigest(payload, opts);
     return digest ? `${guidance}\n\n---\n\n${digest}` : guidance;
 }