@nooticr/mcp 1.26.33 → 1.26.35

package/dist/shared/jobs.js

@@ -55,7 +55,7 @@
  */
 import { z } from "zod";
 import { OUTPUT_SCHEMAS } from "./output-schemas.js";
-import { platformFromUrl, postSlug } from "./comment-review.js";
+import { classifyGuidance, platformFromUrl, postSlug } from "./comment-review.js";
 import { clamp, complaintCore, handleMissGuidance, ownIt, PLATFORM_ARG } from "./evidence.js";
 import { withEvidence } from "./evidence-digest.js";
 import { confirmSpend, costOf, declinedResult, MAX_SPOKEN_HANDLE_CALLS, MAX_SPOKEN_TRANSCRIPTS, SPOKEN_PLATFORMS, CREDITS_PER_CREATOR, } from "./spend.js";
@@ -1220,16 +1220,31 @@ export function registerJobTools(server, makeClient, store) {
                     existing.foundBy = "both";
                 return;
             }
+            // null only when neither spelling arrived; "" when one did and was
+            // blank. `?? null` rather than `?? ""` is the whole distinction.
+            const rawBio = raw.signature ?? raw.bio;
+            const bio = typeof rawBio === "string" ? rawBio : null;
             bySource.set(key, {
                 ...raw,
                 id: `creator:${platform}:${key}`,
                 username,
                 followers: numberOf(raw.followers ?? raw.followerCount),
                 foundBy: source,
+                // Three states, not two. The server distinguishes "this creator
+                // wrote no bio" (empty string) from "the endpoint did not send one"
+                // (null) — Nooticr/nooticr-server#82, where `signature` came back
+                // empty for 55 of 55 results across two platforms. Collapsing the
+                // null back to "" here would undo that fix at its most important
+                // consumer: `links` is this tool's headline differentiator, and an
+                // empty array reads as "this creator published nothing" whichever
+                // reason produced it.
+                bioRead: bio !== null,
                 // What the host should go and read. Pulled out of the bio here
                 // rather than left for the model to spot inside prose — see
                 // collab.ts for why they are typed and why we do not open them.
-                links: extractLinks(String(raw.signature ?? raw.bio ?? ""), typeof raw.externalUrl === "string" ? raw.externalUrl : undefined),
+                links: bio === null
+                    ? []
+                    : extractLinks(bio, typeof raw.externalUrl === "string" ? raw.externalUrl : undefined),
             });
         };
         try {
@@ -1264,15 +1279,20 @@ export function registerJobTools(server, makeClient, store) {
         const creators = [...bySource.values()].sort((a, b) => (a.foundBy === "both" ? 0 : 1) - (b.foundBy === "both" ? 0 : 1) ||
             numberOf(b.followers) - numberOf(a.followers));
         const withLinks = creators.filter((c) => Array.isArray(c.links) && c.links.length > 0).length;
+        // Candidates whose bio never arrived. Counted rather than inferred from
+        // an empty `links`, because the two are different claims and this tool
+        // is built entirely on the one it cannot make when the bio is missing.
+        const bioUnread = creators.filter((c) => c.bioRead === false).length;
         return evidence([
             collabGuidance({ niche: args.niche, found: creators.length, seed: args.seed, platform }),
             "",
-            vettingGuidance(creators.length, withLinks),
+            vettingGuidance(creators.length, withLinks, bioUnread),
         ].join("\n"), {
             mode: "evidence",
             tool: "who_should_i_work_with",
             rubric: COLLAB_RUBRIC,
             withLinks,
+            bioUnread,
             evidenceFrom: args.seed ? ["search_creators", "get_similar_creators"] : ["search_creators"],
             niche: args.niche,
             platform,
@@ -2096,8 +2116,8 @@ export function registerJobTools(server, makeClient, store) {
             "Widens the query into the forms a complaint takes — the plain phrasing, the " +
             "does-anyone-else question, the is-there-a-tool ask — and merges what each returns. " +
             "It is a wide cheap net and NOT a filter: the posts come back for you to judge, and " +
-            "many will be off-target. Consumes 2 nooticr credits per platform searched. Defaults to " +
-            "reddit, where people describe workflow pain in sentences; add twitter for volume.",
+            "many will be off-target. Consumes 2 nooticr credits per search, and each platform is searched once per query shape — three by default, so 6 credits per platform. Defaults to " +
+            "reddit, where people describe workflow pain in sentences; add twitter for volume. Not searchable here: linkedin.",
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
         outputSchema: OUTPUT_SCHEMAS.find_people_with_problem,
         inputSchema: z
@@ -2108,9 +2128,9 @@ export function registerJobTools(server, makeClient, store) {
                 "checking what competitors posted\" finds people; \"competitor analysis\" finds " +
                 "marketing about competitor analysis."),
             platforms: z
-                .array(z.enum(["reddit", "twitter", "youtube", "tiktok", "instagram", "linkedin"]))
+                .array(z.enum(["reddit", "twitter", "youtube", "tiktok", "instagram"]))
                 .optional()
-                .describe("Where to look (default reddit). Each one is a separate paid search."),
+                .describe("Where to look (default reddit). Each one is a separate paid search per query shape. Not searchable here: linkedin — no keyword post search exists for it upstream, so asking for it could only ever return nothing, which is why it is absent from this list rather than merely untested."),
             limit: z.number().int().optional().describe("Posts per query shape (default 6, max 15)."),
             readComments: z
                 .boolean()
@@ -2297,6 +2317,19 @@ export function registerJobTools(server, makeClient, store) {
                 ? `Note that ${unavailable.length} searches errored — tell the user which networks ` +
                     "could not be searched rather than presenting this as the whole picture.\n"
                 : "",
+            // A prospect list is a judgement with nowhere to land unless the
+            // labels come back in a shape the view can draw. `bug_report` and
+            // `complaint` are exactly what makes this list actionable — one goes
+            // to engineering, one to positioning — and the chips, counts and
+            // filter that would show them have always been built and never been
+            // asked for on this path (#79).
+            ...(args.readComments && posts.some((p) => Array.isArray(p.commentSample))
+                ? [
+                    "",
+                    classifyGuidance("The replies you were handed under these posts are unclassified, and labelling " +
+                        "them is what turns this list into something sortable.", posts.reduce((n, p) => n + (Array.isArray(p.commentSample) ? p.commentSample.length : 0), 0)),
+                ]
+                : []),
             ownIt,
         ]
             .filter((l, i, all) => !(l === "" && all[i - 1] === ""))

package/dist/shared/loading-plans.js

@@ -332,6 +332,58 @@ export const LOADING_PLANS = {
     // upstream step to wait on — the wait is a database read.
     mention_trend: { label: "Reading the run history", kind: "text", n: 1, steps: [], free: true },
     prepare_handoff: { label: "Packaging the handoff", kind: "list", n: 4, steps: [], free: true },
+    show_amazon_category_insights: {
+        label: "Drawing the category read",
+        kind: "list",
+        n: 5,
+        steps: [],
+        free: true,
+    },
+    // ─── Marketplace ───
+    //
+    // The wait here is genuinely long and the reason is worth showing rather
+    // than hiding behind a spinner: each listing is a browser render behind
+    // Amazon's bot defences, and the politeness delay between them is set by
+    // what Amazon tolerates rather than by what the machine can do. A plan that
+    // said "Working" for four minutes would read as a hang.
+    scan_amazon_category: {
+        label: "Collecting the category",
+        kind: "list",
+        n: 6,
+        steps: [],
+        perUnit: [
+            {
+                via: "scan_amazon_category",
+                label: "Collecting a listing",
+                detail: "price, stars, aspects and its reviews",
+                credits: 3,
+                arg: "limit",
+                defaultCount: 10,
+            },
+        ],
+        note: "Amazon is collected politely, so this is minutes rather than seconds. Partial results come back either way.",
+    },
+    // Free: the poll of a collection already paid for.
+    amazon_scan_status: {
+        label: "Checking the collection",
+        kind: "list",
+        n: 6,
+        steps: [],
+        free: true,
+    },
+    get_amazon_product: {
+        label: "Reading the listing",
+        kind: "text",
+        n: 1,
+        steps: [
+            {
+                via: "get_amazon_product",
+                label: "Fetching the listing",
+                detail: "price, stars, aspects and its reviews",
+                credits: 3,
+            },
+        ],
+    },
     // ─── Own-account reads: nooticr's own stored rows ───
     get_scheduled_posts: { label: "Reading your pipeline", kind: "list", n: 5, steps: [], free: true },
     get_post_performance: { label: "Reading your numbers", kind: "list", n: 5, steps: [], free: true },

package/dist/shared/output-schemas.js

@@ -142,6 +142,16 @@ const post = open({
     comments: scalar(),
     shares: scalar(),
     engagementRate: scalar(),
+    // The replies under the post, when a tool opened it — find_people_with_problem's
+    // `readComments`. Declared rather than left to `open()` to pass through: a host
+    // reading the schema had no way to know these could be here, so the field that
+    // costs the most in that call was the one field it could not plan for (#78).
+    //
+    // `commentsRead: 0` means the thread would not open, NOT that nobody replied.
+    // The two read as opposite findings about a prospect, so the distinction is
+    // stated here as well as in the digest and the view.
+    commentsRead: scalar().describe("How many replies were read under this post. 0 means the thread would not open — not that nobody replied. Absent when nothing tried."),
+    commentSample: anyList().describe("The replies themselves, when they were read. Someone answering \"same here, this is exactly my problem\" under another person's thread is a better find than the thread — the permalink to quote is still this post's."),
     hashtags: listOf(z.string()),
     // Media comes in threes: the platform URL, an nooticr proxy, and a resolver
     // that re-fetches when a signed link has expired.
@@ -225,6 +235,65 @@ const analyzed = { ...singlePost, analysis, analyzed: scalar() };
  * One entry per tool. A tool missing from here declares nothing, which is the
  * honest option when the shape has not been checked against a real response.
  */
+/**
+ * One Amazon listing, as the scan hands it over.
+ *
+ * `aspects` and `reviewSummary` are Amazon's own, not ours, and they are the
+ * half of a listing that survives the sign-in gate which withholds review
+ * bodies — so they are declared beside `reviews` rather than folded into it.
+ */
+const amazonProduct = open({
+    asin: scalar(),
+    url: scalar(),
+    title: scalar(),
+    brand: scalar(),
+    price: scalar(),
+    priceValue: scalar(),
+    listPrice: scalar(),
+    availability: scalar(),
+    rating: scalar(),
+    ratingCount: scalar(),
+    image: scalar(),
+    images: listOf(z.string()),
+    features: listOf(z.string()),
+    categories: listOf(z.string()),
+    specs: open({}).nullish(),
+    ratingHistogram: open({}).nullish().describe("Star bucket to share, e.g. {\"5\": \"73%\"}."),
+    reviewSummary: scalar().describe("Amazon's own digest of the reviews."),
+    aspects: listOf(open({ name: scalar(), mentions: scalar(), sentiment: scalar() })),
+    reviewsGated: scalar().describe("True when Amazon withheld the review bodies behind sign-in."),
+    reviews: anyList(),
+});
+/** One thing you concluded, with what it rests on. */
+const amazonFinding = open({
+    label: scalar(),
+    detail: scalar(),
+    evidence: listOf(z.string()).describe("Review ids or short quotes."),
+    strength: scalar().describe("strong / moderate / thin — how well the collected text supports it."),
+});
+const amazonScanShape = {
+    guidance: scalar(),
+    mode: scalar(),
+    marketplace: scalar(),
+    scanId: scalar().describe("Pass to amazon_scan_status to pick a running collection back up."),
+    status: scalar(),
+    complete: scalar().describe("False means more listings are still coming."),
+    query: scalar(),
+    domain: scalar(),
+    progress: open({
+        done: scalar(),
+        total: scalar(),
+        message: scalar(),
+        elapsedMs: scalar(),
+        fromCache: scalar(),
+    }).nullish(),
+    rollup: open({}).nullish().describe("The arithmetic over the set: price and rating spread, aspects by brand, 1-2 star share."),
+    products: listOf(amazonProduct),
+    reviews: anyList().describe("Every review across the scan, worst-rated first — the barriers are the half a summary drops."),
+    errors: anyList(),
+    mcpCredits,
+};
+const amazonScan = open(amazonScanShape);
 export const OUTPUT_SCHEMAS = {
     analyze_post: open({ ...analyzed, ...evidence }),
     analyze_post_fast: open({ ...evidence, ...analyzed }),
@@ -260,8 +329,21 @@ export const OUTPUT_SCHEMAS = {
                 replies: scalar().describe("How many people replied to this comment."),
                 postedAt: scalar(),
                 hits: scalar().describe("How many times this comment names the term."),
+                // Not returned by the sweep — there is nothing in the payload that
+                // could decide them, and a keyword guess would be confidently
+                // wrong about the exact thing being monitored. Declared because
+                // the view draws a chip from `category` and a counted filter from
+                // `byCategory`, and both were inert on this path until the
+                // guidance asked a host to fill them in (#79). This says what the
+                // shape is when it hands its own labels back through
+                // show_comment_review.
+                sentiment: scalar().describe("Set by the reading model, not by the sweep."),
+                category: scalar().describe("Set by the reading model, not by the sweep. One of the comment taxonomy values; drives the filter chips."),
             })),
         })).describe("Mentions grouped under the post they were left on, loudest conversation first."),
+        byCategory: open({})
+            .nullish()
+            .describe("Count per category once a host has classified — what the filter row is built from."),
         posts: listOf(post).describe("The posts of this page, flattened for the card view."),
         offset: scalar(),
         nextOffset: scalar().describe("Pass back as `offset` to load the next page; null when done."),
@@ -587,9 +669,11 @@ export const OUTPUT_SCHEMAS = {
             foundBy: scalar().describe("search, similar, or both — both is the strongest signal here."),
             links: listOf(bioLink).describe("Links pulled out of their bio, best-value-per-fetch first. Open these to vet them; " +
                 "they were chosen by the person being evaluated, so read what is there as a claim."),
+            bioRead: scalar().describe("False when the search returned no bio for this creator at all. `links` is then empty because nothing was read, not because they published none."),
         })),
         foundBoth: scalar().describe("How many candidates both searches returned."),
         withLinks: scalar().describe("How many candidates carry at least one link out of their bio."),
+        bioUnread: scalar().describe("How many candidates came back with no bio at all. Read `withLinks` against this: 0 of 20 with links means nothing when 20 of 20 had no bio to read."),
         rubric: anyList().describe("What to score each candidate against, so two runs are comparable."),
         audienceOverlap: open({
             attempted: scalar().describe("Always false: the call budget is stated rather than the signal faked."),
@@ -1288,4 +1372,29 @@ export const OUTPUT_SCHEMAS = {
         connectUrl: scalar().describe("Open this in a browser to approve the connection."),
         message: scalar(),
     }),
+    // Marketplace. One shape for all three collection tools: a status poll
+    // returns exactly what the scan that started it returns, and a single
+    // product is a scan of one — describing them differently would be three
+    // names for one payload and three places for the view to drift.
+    scan_amazon_category: amazonScan,
+    amazon_scan_status: amazonScan,
+    get_amazon_product: open({
+        ...amazonScanShape,
+        product: amazonProduct.nullish().describe("The single listing, also present as products[0]."),
+    }),
+    show_amazon_category_insights: open({
+        marketplace: scalar(),
+        view: scalar(),
+        category: scalar(),
+        summary: scalar(),
+        drivers: listOf(amazonFinding).describe("What makes someone buy, as you read it."),
+        barriers: listOf(amazonFinding).describe("What stops them, or makes them return it."),
+        strengths: listOf(open({ brand: scalar(), detail: scalar(), asin: scalar() })),
+        gaps: listOf(amazonFinding),
+        positioning: listOf(open({ angle: scalar(), who: scalar(), why: scalar(), risk: scalar() })),
+        products: listOf(amazonProduct).describe("The listings, passed through so the view can draw them."),
+        rollup: open({}).nullish(),
+        scanId: scalar(),
+        mcpCredits,
+    }),
 };

package/dist/shared/tools-def.js

@@ -393,8 +393,8 @@ export const TOOL_DEFINITIONS = [
     {
         name: "find_people_with_problem",
         title: "Find People With A Problem",
-        description: "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 (\"I spend hours checking competitors by hand\") and this searches for posts shaped like that complaint, not for the topic it is about. That difference is the point: 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 merges what each returns. It is a wide cheap net and NOT a filter: the posts come back for you to judge, and many will be off-target. Consumes 2 nooticr credits per platform searched. Defaults to reddit, where people describe workflow pain in sentences; add twitter for volume.",
-        inputSchema: z.object({ problem: z.string().describe("The problem in a person's own words, not a topic. \"I waste an hour a day checking what competitors posted\" finds people; \"competitor analysis\" finds marketing about competitor analysis."), platforms: z.array(z.enum(["reddit", "twitter", "youtube", "tiktok", "instagram", "linkedin"])).optional().describe("Where to look (default reddit). Each one is a separate paid search."), limit: z.number().int().optional().describe("Posts per query shape (default 6, max 15)."), readComments: z.boolean().optional().describe("Open the most promising results and read their comments too (default false). On Reddit especially, the person with the problem is at least as often replying under someone else's thread as posting their own, and a post-only search cannot see any of them. Costs 2 nooticr credits per post opened, up to 5 \u2014 and they are opened on the MERGED, deduped results, so it is five extra calls in total rather than five per query shape per platform."), queries: z.array(z.string()).optional().describe("Search these exact phrasings instead of the ones derived from `problem` (max 4). You are better at this than a string template is: write how a person would actually word the complaint on the network being searched \u2014 a Reddit title, an X post \u2014 and keep each one short, because this is a keyword search and a long sentence matches on its commonest words.") }).strict(),
+        description: "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 (\"I spend hours checking competitors by hand\") and this searches for posts shaped like that complaint, not for the topic it is about. That difference is the point: 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 merges what each returns. It is a wide cheap net and NOT a filter: the posts come back for you to judge, and many will be off-target. Consumes 2 nooticr credits per search, and each platform is searched once per query shape — three by default, so 6 credits per platform. Defaults to reddit, where people describe workflow pain in sentences; add twitter for volume. Not searchable here: linkedin.",
+        inputSchema: z.object({ problem: z.string().describe("The problem in a person's own words, not a topic. \"I waste an hour a day checking what competitors posted\" finds people; \"competitor analysis\" finds marketing about competitor analysis."), platforms: z.array(z.enum(["reddit", "twitter", "youtube", "tiktok", "instagram"])).optional().describe("Where to look (default reddit). Each one is a separate paid search per query shape. Not searchable here: linkedin — no keyword post search exists for it upstream, so asking for it could only ever return nothing, which is why it is absent from this list rather than merely untested."), limit: z.number().int().optional().describe("Posts per query shape (default 6, max 15)."), readComments: z.boolean().optional().describe("Open the most promising results and read their comments too (default false). On Reddit especially, the person with the problem is at least as often replying under someone else's thread as posting their own, and a post-only search cannot see any of them. Costs 2 nooticr credits per post opened, up to 5 \u2014 and they are opened on the MERGED, deduped results, so it is five extra calls in total rather than five per query shape per platform."), queries: z.array(z.string()).optional().describe("Search these exact phrasings instead of the ones derived from `problem` (max 4). You are better at this than a string template is: write how a person would actually word the complaint on the network being searched \u2014 a Reddit title, an X post \u2014 and keep each one short, because this is a keyword search and a long sentence matches on its commonest words.") }).strict(),
     },
     {
         name: "search_spoken_mentions",
@@ -414,4 +414,28 @@ export const TOOL_DEFINITIONS = [
         description: "Patch your own product's fields \u2014 omitted arguments leave their column unchanged, so this cannot blank a field by not mentioning it. Takes appId, optional when your workspace has exactly one product; every other field is snake_case, the same names create_product takes and read the same way. The result lists which fields were actually written, so a name you spelled wrong shows up as a field that did not change rather than as a silent no-op. Free \u2014 no AI call, just a row.",
         inputSchema: z.object({ appId: z.number().int().optional().describe("Your product's id. Omit only with a single-product workspace."), name: z.string().optional(), slug: z.string().optional(), description: z.string().optional(), website_url: z.string().optional(), niche: z.string().optional(), product_type: z.string().optional(), icon_url: z.string().optional(), primary_cta_label: z.string().optional(), primary_cta_url: z.string().optional(), external_listing_id: z.string().optional(), ios_bundle_id: z.string().optional(), android_package: z.string().optional() }).strict(),
     },
+    {
+        name: "scan_amazon_category",
+        title: "Scan Amazon Category",
+        description: "Collect an Amazon category and read it: listings with prices, star histograms, Amazon's own review-aspect counts and the review text itself, plus the arithmetic over them (price spread, rating spread, which aspects recur across how many brands, and the share of each listing's ratings sitting at 1-2 stars). Pass query to search the category, asins to pin named competitors, or both \u2014 named competitors keep their place at the front. You write the read: purchase drivers, barriers, what the incumbents do well, the gaps, and how a new entrant could position; show_amazon_category_insights draws it for free afterwards. Collection runs in the background, so this returns everything ready within waitSeconds plus a scanId to continue with amazon_scan_status. Consumes 3 nooticr credits per listing collected \u2014 a listing with reviews is a real browser render behind Amazon's bot defences.",
+        inputSchema: z.object({ query: z.string().optional().describe("Category or keyword to search on Amazon, e.g. 'ashwagandha gummies'."), asins: z.array(z.string()).optional().describe("Named competitors: ASINs or any Amazon product URL. Kept at the front of the set."), limit: z.number().int().optional().describe("Listings to collect (default 10, max 50)."), reviews: z.boolean().optional().describe("Collect review text too (default true)."), domain: z.string().optional().describe("Marketplace host, e.g. www.amazon.co.uk (default www.amazon.com)."), waitSeconds: z.number().int().optional().describe("How long to wait before returning partial results (default 90, max 240)."), focus: z.string().optional().describe("An extra question to answer from the reviews.") }).strict(),
+    },
+    {
+        name: "amazon_scan_status",
+        title: "Amazon Scan Status",
+        description: "Pick up a scan_amazon_category collection that was still running, by scanId \u2014 the listings and reviews collected since, with the same rollup and the same instructions for reading them. Free: it is the poll scan_amazon_category asked for, and charging for the second half of one answer would bill a wait this server chose. Call it when a scan came back incomplete, then write your read from the full set.",
+        inputSchema: z.object({ scanId: z.string().describe("The scanId scan_amazon_category returned."), waitSeconds: z.number().int().optional().describe("How long to wait for more listings before answering (default 30, max 240)."), focus: z.string().optional().describe("Same optional steer as scan_amazon_category.") }).strict(),
+    },
+    {
+        name: "get_amazon_product",
+        title: "Get Amazon Product",
+        description: "Fetch one Amazon listing by ASIN or URL: price, rating, the full star histogram, features, specs, Amazon's review digest and aspect breakdown, and the review text. Use for a single product; for a category or a competitive set, scan_amazon_category collects many in one job and rolls them up. Consumes 3 nooticr credits.",
+        inputSchema: z.object({ asin: z.string().optional().describe("ASIN, or a full Amazon product URL."), url: z.string().optional().describe("Full Amazon product URL, if you have that instead."), reviews: z.boolean().optional().describe("Collect review text too (default true)."), domain: z.string().optional().describe("Marketplace host (default www.amazon.com).") }).strict(),
+    },
+    {
+        name: "show_amazon_category_insights",
+        title: "Show Amazon Category Insights",
+        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 \u2014 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. Call this after you have read the reviews, not instead of reading them.",
+        inputSchema: z.object({ category: z.string().describe("The category this is a read of."), summary: z.string().optional(), drivers: z.array(z.any()).optional().describe("What makes someone buy, each with the review evidence behind it."), barriers: z.array(z.any()).optional().describe("What stops them buying, or makes them return it."), strengths: z.array(z.any()).optional().describe("What each incumbent does well."), gaps: z.array(z.any()).optional().describe("What buyers keep asking for that nobody serves."), positioning: z.array(z.any()).optional().describe("Angles a new entrant could take."), products: z.array(z.any()).optional().describe("The listings from the scan, passed straight through."), rollup: z.record(z.unknown()).optional().describe("The rollup from the scan, passed straight through."), scanId: z.string().optional() }).passthrough(),
+    },
 ];

package/dist/shared/tools.js

@@ -13,7 +13,7 @@ import { registerPrompts } from "./prompts.js";
 import { OUTPUT_SCHEMAS, anyObject } from "./output-schemas.js";
 import { deriveHashtags, derivedNote } from "./hashtags.js";
 import { createTaskStore, registerSlowTool } from "./tasks.js";
-import { COMMENT_CATEGORIES, COMMENT_SENTIMENTS, platformFromUrl, reviewGuidance, toEvidence, } from "./comment-review.js";
+import { COMMENT_CATEGORIES, COMMENT_SENTIMENTS, classifyGuidance, platformFromUrl, reviewGuidance, toEvidence, } from "./comment-review.js";
 import { costSentence, EVIDENCE_PLANS, fetchBillingNote, frameIndex, framesToBlocks, planCalls, scoreDraftGuidance, KNOWN_PLATFORMS, platformFailureGuidance, } from "./evidence.js";
 import { evidenceDigest } from "./evidence-digest.js";
 import { confirmSpend, declinedResult, searchMentionsCost, SEARCH_PLATFORMS, DISCOVERABLE_PLATFORMS, } from "./spend.js";
@@ -25,8 +25,9 @@ import { registerConnectionTools } from "./connections.js";
 import { loadingPlansJson } from "./loading-plans.js";
 import { registerHandoff } from "./handoff.js";
 import { registerCollabTools } from "./collab.js";
+import { registerAmazonTools } from "./amazon.js";
 /** Current MCP server version — bumped on every deploy for traceability. */
-export const MCP_SERVER_VERSION = "1.26.33";
+export const MCP_SERVER_VERSION = "1.26.35";
 /** MCP Apps extension identifier */
 const UI_EXTENSION = "io.modelcontextprotocol/ui";
 /** MIME type for MCP Apps HTML resources */
@@ -278,7 +279,17 @@ function withSource(result, source, platform) {
         return result;
     return { ...result, structuredContent: { ...result.structuredContent, source, platform } };
 }
-async function toToolResult(proxy) {
+/**
+ * `guidance`, when given, is steering this repo adds to a backend passthrough
+ * — and it goes into BOTH channels deliberately.
+ *
+ * Claude Code drops every text block when a result also carries
+ * structuredContent, and a host rendering the UI view does the reverse: it
+ * hands the model the text and gives structuredContent to the widget. So a
+ * guidance string in one place only reaches roughly half the hosts, which is
+ * the failure #44/#51 were and the reason chain:map gates on it.
+ */
+async function toToolResult(proxy, guidance) {
     // MCP Apps views (ChatGPT & Claude) render the interactive HTML card, which
     // already embeds all thumbnails/videos. Claude's Apps bridge rejects a tool
     // result that mixes raw `image` blocks with an app view ("could not be
@@ -304,10 +315,11 @@ async function toToolResult(proxy) {
     const textJson = JSON.stringify(forHosts, null, 2);
     // Replace image URLs in HTML with proxied versions
     const proxiedHtml = htmlPrefix ? proxyImageUrlsInHtml(htmlPrefix) : "";
-    const text = proxiedHtml ? `${proxiedHtml}\n\n${textJson}` : textJson;
+    const body = proxiedHtml ? `${proxiedHtml}\n\n${textJson}` : textJson;
+    const text = guidance ? `${guidance}\n\n${body}` : body;
     return {
         content: [{ type: "text", text }],
-        structuredContent: forHosts,
+        structuredContent: guidance ? { ...forHosts, guidance } : forHosts,
     };
 }
 /** Replace external image/video src, poster and href URLs in HTML with proxied versions. */
@@ -627,6 +639,12 @@ export function createMcpServer(rawMakeClient, opts) {
         // grant each connection carries is a table, which is what a view is for.
         "list_social_connections",
         "connect_social_account",
+        // Marketplace. All four draw: the three collection tools render the
+        // listings and their reviews, and the view draws the read on top of them.
+        "scan_amazon_category",
+        "amazon_scan_status",
+        "get_amazon_product",
+        "show_amazon_category_insights",
     ];
     // Human-readable resource name per tool (used in resources/list + tools/list).
     function resourceName(tool) {
@@ -706,6 +724,12 @@ export function createMcpServer(rawMakeClient, opts) {
         // LinkedIn
         "https://*.licdn.com",
         "https://*.linkedin.com",
+        // Amazon product images. Listings serve from m.media-amazon.com and, on
+        // older listings, images-na.ssl-images-amazon.com — a listing whose picture
+        // is blocked draws as a brand initial, which is a worse comparison screen
+        // than the one the scan paid for.
+        "https://*.media-amazon.com",
+        "https://*.ssl-images-amazon.com",
     ];
     const apiUrl = process.env.NOOTICR_API_URL || process.env.NOOTICR_BASE_URL;
     if (apiUrl && apiUrl.trim()) {
@@ -2172,7 +2196,15 @@ export function createMcpServer(rawMakeClient, opts) {
             return declinedResult(credits, "That sweep");
         const client = await makeClient({ ...extra, arguments: args });
         try {
-            return await toToolResult(await client.callTool("search_mentions", { ...args }));
+            const proxy = await client.callTool("search_mentions", { ...args });
+            // Ask for the labels the view is already built to draw. Everything on the
+            // receiving end has existed for as long as the chips have — the per-row
+            // chip, the counted filter, the click-to-filter — and this sweep is the
+            // most expensive call in the product, so it drew all three empty every
+            // time for want of one instruction (#79).
+            const structured = (proxy.structured ?? {});
+            const groups = Array.isArray(structured.threads) ? structured.threads.length : 0;
+            return await toToolResult(proxy, classifyGuidance(`They are comments naming "${args.term}", grouped under the ${groups} posts they were left on.`, groups));
         }
         catch (err) {
             return toolError("search_mentions failed", err);
@@ -2351,5 +2383,9 @@ export function createMcpServer(rawMakeClient, opts) {
     // classified for a tracker on another server, the other draws what it scored.
     registerHandoff(server);
     registerCollabTools(server);
+    // Marketplace intelligence (amazon.ts): the category collection, the poll
+    // that picks it back up, a single listing, and the free view for the read
+    // the model writes out of them.
+    registerAmazonTools(server, makeClient);
     return server;
 }