@nooticr/mcp 1.26.27 → 1.26.29

package/README.md

@@ -52,7 +52,7 @@ npx @nooticr/mcp login   # one-time sign-in (Google)
 
 ## Tools
 
-64 tools, grouped by what you are trying to do. Prices are in nooticr credits and
+68 tools, grouped by what you are trying to do. Prices are in nooticr credits and
 match what the server actually charges.
 
 Seven of them — the ones under **Answer a question you actually have** — are not
@@ -113,9 +113,13 @@ them caps that fan-out with an argument.
 | `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. |
 | `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. |
 | `show_trend` | free | Draws the trend your model read out of `mention_trend`. `tooShort` marks a series with too few points to call a direction, and `edgeIsRecordStart` marks a left edge that is where the record begins rather than where the conversation did — a chart hiding either is the mistake this view could otherwise make on your behalf. Makes no requests. |
-| `track_competitor` | 2 | What a creator shipped, and which of it beat **their own** median rather than a raw view count that mostly measures follower count. One post list, whatever the window. If they are on your watchlist it also marks what is new since your last check and moves that marker forward — its own marker, not the one `catch_up_watchlist` keeps. |
+| `track_creator` | 2 | What a creator shipped, and which of it beat **their own** median rather than a raw view count that mostly measures follower count. One post list, whatever the window. If they are on your watchlist it also marks what is new since your last check and moves that marker forward — its own marker, not the one `catch_up_watchlist` keeps. |
+| `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` | 2 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. |
 | `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. |
@@ -526,9 +530,11 @@ Those are unit tests against a stub backend. For real MCP-protocol
 end-to-end tests — no Rust, no Postgres, no API key —
 `npm run test:e2e-smoke:fixture` spawns this repo's real built CLI and
 drives it over stdio against a pure-Node stand-in for nooticr-server. See
-`docs/testing/agentic-e2e-testing.md` for that plus the two tiers above it
-(`npm run test:e2e-smoke` against a real nooticr-server, and
-`npm run test:agentic-e2e`, a real model driving it), and for
+`docs/testing/agentic-e2e-testing.md` for that plus the tier above it
+(`npm run test:e2e-smoke` against a real nooticr-server). For a real model
+driving the server through whole journeys — asserting on the chain of tools
+it walks, not on one call — see `npm run test:quests` and
+`docs/testing/tool-chaining-quests.md`. And for
 `tests/e2e/agentic-visual*.e2e.ts` — every reachable widget view, driven by
 a real tool-call result, rendered in a real browser with every host-facing
 button actually clicked (`npx playwright test tests/e2e/agentic-visual.e2e.ts

package/dist/shared/brand-watch.js

@@ -259,9 +259,11 @@ function trendGuidance(sc, runs) {
             "high `timesSeen` is a post that keeps resurfacing — worth naming as one thing rather " +
             "than as repeated new interest.");
     }
-    lines.push("", "This is free because the sweeps were already billed. Nothing here needs a further call to " +
-        "interpret it — read the numbers and say what changed, including that nothing did, if that " +
-        "is what they show.");
+    lines.push("", "This is free because the sweeps were already billed. Read the numbers and say what changed, " +
+        "including that nothing did, if that is what they show. Then call show_trend with the " +
+        "series and your read of it — free, and it draws the chart with the two things a chart " +
+        "here can lie about marked: a series too short to call a direction, and a left edge that " +
+        "is where the record starts rather than where the conversation did.");
     return lines.join("\n");
 }
 function toResult(proxy) {
@@ -445,7 +447,13 @@ export function registerBrandWatch(server, makeClient) {
                             "`term` a watch was created for. Nothing was fetched and nothing was charged.",
                     },
                 ],
-                structuredContent: { available: false, billable: false, mcpCredits: { cost: 0 } },
+                structuredContent: {
+                    guidance: "This needs a watch to read: pass `watchId` (from list_brand_watches) or the " +
+                        "`term` a watch was created for. Nothing was fetched and nothing was charged.",
+                    available: false,
+                    billable: false,
+                    mcpCredits: { cost: 0 },
+                },
             };
         }
         try {
@@ -453,13 +461,17 @@ export function registerBrandWatch(server, makeClient) {
             const result = toResult(proxy);
             const sc = (result.structuredContent ?? {});
             const runs = Array.isArray(sc.runs) ? sc.runs : [];
-            // Guidance in the text block, evidence in the structured one — the
-            // pattern every reading tool here uses. What it has to prevent is a
+            // Guidance in BOTH places, not just the text block. A host that
+            // renders structuredContent drops every content text block and shows
+            // the model the serialised JSON instead, so a text-only copy reaches
+            // nobody — measured across 59 real runs. What it has to prevent is a
             // model reading two points as a trend, and reading the start of the
             // retention window as the moment a conversation began.
+            const guidance = trendGuidance(sc, runs);
             return {
                 ...result,
-                content: [{ type: "text", text: trendGuidance(sc, runs) }],
+                content: [{ type: "text", text: guidance }],
+                structuredContent: { guidance, ...sc },
             };
         }
         catch (err) {

package/dist/shared/evidence.js

@@ -115,6 +115,58 @@ export function handleMissGuidance(a) {
     ];
     return lines.filter((l, i, all) => !(l === "" && all[i - 1] === "")).join("\n");
 }
+/**
+ * Every network the surface can be asked for, for recognising one in an error.
+ *
+ * Deliberately a flat list rather than a per-capability one: this is used to
+ * spot a platform NAME in a failure message, and a platform that failed is a
+ * platform whatever it was capable of.
+ */
+export const KNOWN_PLATFORMS = [
+    "tiktok",
+    "instagram",
+    "youtube",
+    "douyin",
+    "xiaohongshu",
+    "twitter",
+    "bilibili",
+    "linkedin",
+    "reddit",
+    "weibo",
+];
+/**
+ * What to say when a network ERRORED, as opposed to came back empty.
+ *
+ * Those want opposite responses and nothing distinguished them. An empty
+ * result means try a different query; an error means try a different network,
+ * or tell the user. Without that split a host does the one thing that cannot
+ * work: re-runs the same call with the words changed.
+ *
+ * From a real session. Reddit's discovery endpoint started failing, and the
+ * model read "The social data service could not complete this request" as a
+ * bad query — three more discover_social_posts calls with reworded niches,
+ * then a search_mentions, every one a paid upstream call against a network
+ * that was never going to answer. The user had asked for "X and Reddit"; they
+ * were told about X and never told Reddit had failed at all.
+ *
+ * So: name the network, say the failure is not about the query, forbid the
+ * reword loop explicitly, and say what to do instead. `handleMissGuidance`'s
+ * shape, for the other half of the same problem.
+ */
+export function platformFailureGuidance(a) {
+    return [
+        `${a.platform} could not be searched: ${a.message}`,
+        "",
+        "This is the network failing, not your query. Do NOT call this again with different " +
+            "wording, a different niche phrasing, or a different tool against the same network — " +
+            "each attempt is another paid upstream call that fails the same way.",
+        "",
+        `Carry on with any other networks the user asked for, and tell them plainly that ` +
+            `${a.platform} could not be searched this time. An answer that silently covers half of ` +
+            "what was asked for reads as a complete answer, which is worse than a short one that " +
+            "says what is missing.",
+    ].join("\n");
+}
 /** Closing line every guidance block shares. */
 export const ownIt = "Reason over this yourself rather than asking for an interpretation of it — " +
     "you can see everything the analysis would have been built from. Everything fetched here — " +
@@ -251,6 +303,21 @@ export const EVIDENCE_PLANS = {
                         `Focus for this pass, as asked: ${focus}. Still cover the profile as a whole, but weight what you cover toward this.`,
                     ]
                     : []),
+                "",
+                // The redirect has to be here rather than only in the description,
+                // because by the time a description could help this tool has already
+                // been chosen. Measured: the phrase "track what X has been doing"
+                // retrieves analyze_creator_profile and never track_creator —
+                // track_creator's name only surfaces when the user says the word
+                // "competitor", which is not how most people phrase it. A result
+                // naming the other tool is the one channel that reaches a model which
+                // has already committed to this one.
+                "If what was actually asked for was to TRACK this creator — how they are",
+                "doing lately, what they have shipped since last time, keeping an eye on",
+                "them — this is the wrong tool and you should call track_creator",
+                "instead. It scores each post against this creator's OWN median rather",
+                "than handing you raw counts, and it remembers where you left off, so",
+                "the next call can say what is new. This one does neither.",
                 ownIt,
             ].join("\n");
         },

package/dist/shared/jobs.js

@@ -57,9 +57,10 @@ import { z } from "zod";
 import { OUTPUT_SCHEMAS } from "./output-schemas.js";
 import { platformFromUrl, postSlug } from "./comment-review.js";
 import { clamp, handleMissGuidance, ownIt, PLATFORM_ARG } from "./evidence.js";
-import { confirmSpend, costOf, declinedResult, MAX_SPOKEN_HANDLE_CALLS, MAX_SPOKEN_TRANSCRIPTS, SPOKEN_PLATFORMS, } from "./spend.js";
+import { confirmSpend, costOf, declinedResult, MAX_SPOKEN_HANDLE_CALLS, MAX_SPOKEN_TRANSCRIPTS, SPOKEN_PLATFORMS, CREDITS_PER_CREATOR, } from "./spend.js";
 import { distributionOf, excluding, numberOf, standing, } from "./performance.js";
 import { normaliseHandle, watchEntryId, watchlistOwner } from "./watchlist.js";
+import { creatorStanding, standingsGuidance, THIN_WINDOW, ABOVE_RATIO, } from "./standings.js";
 import { viewMeta } from "./view-meta.js";
 import { extractLinks, COLLAB_RUBRIC, vettingGuidance } from "./collab.js";
 const rowsOf = (value) => Array.isArray(value) ? value.filter((r) => r && typeof r === "object") : [];
@@ -596,9 +597,14 @@ const metricArg = z
     .describe("Which stat to rank on (default views).");
 export function registerJobTools(server, makeClient, store) {
     /** Guidance in the text block, evidence in the structured one — as every tool here does. */
+    // Both channels, because only one of them arrives. A host that renders
+    // `structuredContent` replaces the content text blocks with the serialised
+    // JSON, so guidance kept only in a text block reaches no model — measured at
+    // 0 phrases across 175 tool results. See tools.ts's runEvidence for the full
+    // note, and docs/testing/tool-chaining-quests.md for the measurement.
     const evidence = (guidance, payload) => ({
         content: [{ type: "text", text: guidance }],
-        structuredContent: payload,
+        structuredContent: { guidance, ...payload },
     });
     const failed = (prefix, err) => ({
         content: [{ type: "text", text: `${prefix}: ${reason(err)}` }],
@@ -801,23 +807,25 @@ export function registerJobTools(server, makeClient, store) {
         });
     });
     // ───────────────────────────────────────────────────────────────────────────
-    // 2. track_competitor
+    // 2. track_creator
     //
     // Writes, when the creator is on the watchlist: it moves a baseline forward
     // so the next call can say what is new. That baseline is deliberately not
     // the one catch_up_watchlist keeps — two tools sharing one "since I last
     // looked" means each silently consumes the other's answer.
     // ───────────────────────────────────────────────────────────────────────────
-    server.registerTool("track_competitor", {
+    server.registerTool("track_creator", {
         title: "Track Competitor",
-        _meta: viewMeta("track_competitor"),
-        description: "What a creator shipped recently and which of it beat THEIR OWN baseline. Fetches their " +
-            "recent posts once and scores each against the median of that same window, because a raw " +
-            "view count mostly measures follower count — outperformance against themselves is the " +
-            "signal. If they are on your watchlist it also marks what is new since your last " +
-            "track_competitor call and moves that marker forward. " +
-            "Consumes 2 nooticr credits — one post list, whatever the window size. Use for a rival you " +
-            "follow; analyze_creator_profile is the full teardown of one you do not.",
+        _meta: viewMeta("track_creator"),
+        description: "Track a competitor, keep an eye on a rival, see how someone is doing lately, catch what " +
+            "they shipped since you last looked — this is the tool for all of those. What a creator " +
+            "shipped recently and which of it beat THEIR OWN baseline: fetches their recent posts " +
+            "once and scores each against the median of that same window, because a raw view count " +
+            "mostly measures follower count — outperformance against themselves is the signal. If " +
+            "they are on your watchlist it also marks what is new since your last track_creator " +
+            "call and moves that marker forward. " +
+            "Consumes 2 nooticr credits — one post list, whatever the window size. Use for a rival " +
+            "you follow; analyze_creator_profile is the full teardown of one you do not.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
@@ -826,7 +834,7 @@ export function registerJobTools(server, makeClient, store) {
             idempotentHint: false,
             openWorldHint: true,
         },
-        outputSchema: OUTPUT_SCHEMAS.track_competitor,
+        outputSchema: OUTPUT_SCHEMAS.track_creator,
         inputSchema: z
             .object({
             username: z
@@ -863,7 +871,7 @@ export function registerJobTools(server, makeClient, store) {
             feed = rowsOf(structured.posts);
         }
         catch (err) {
-            return failed("track_competitor could not list the posts", err);
+            return failed("track_creator could not list the posts", err);
         }
         // Nothing came back. Previously this fell through to the scoring path and
         // produced a baseline-less report about zero posts, which reads as "this
@@ -871,7 +879,7 @@ export function registerJobTools(server, makeClient, store) {
         if (feed.length === 0) {
             return evidence(handleMissGuidance({ handle, platform, defaulted: platformDefaulted }), {
                 mode: "evidence",
-                tool: "track_competitor",
+                tool: "track_creator",
                 evidenceFrom: ["get_user_posts"],
                 username: handle,
                 platform,
@@ -941,7 +949,7 @@ export function registerJobTools(server, makeClient, store) {
             lastChecked: previous?.capturedAt,
         }), {
             mode: "evidence",
-            tool: "track_competitor",
+            tool: "track_creator",
             evidenceFrom: ["get_user_posts"],
             username: handle,
             platform,
@@ -964,6 +972,185 @@ export function registerJobTools(server, makeClient, store) {
         });
     });
     // ───────────────────────────────────────────────────────────────────────────
+    // 2b. compare_creators / watchlist_standings
+    //
+    // The comparison track_creator computes and discards. Both are pure
+    // compositions of get_user_posts — one fetch per creator, priced as the sum
+    // — and both leave the reading to the caller, because a ranking hides the
+    // window size that decides whether the ranking means anything.
+    // ───────────────────────────────────────────────────────────────────────────
+    /** One creator's window, fetched and scored. Shared by both tools below. */
+    const standingFor = async (client, spend, handle, platform, metric, cap) => {
+        try {
+            const res = await client.callTool("get_user_posts", { username: handle, platform, limit: cap });
+            const structured = structuredOf(res);
+            spend.record("get_user_posts", structured);
+            const posts = rowsOf(structured.posts).map((p, i) => ({
+                ...p,
+                postId: postIdOf(p, i),
+                postedAt: postDate(p),
+            }));
+            return creatorStanding(handle, platform, posts, metric, (post) => metricOf(post, metric));
+        }
+        catch (err) {
+            // One creator failing must not lose the others: a comparison of three is
+            // still worth reading, and saying which one is missing is the honest
+            // version of an answer with a hole in it.
+            spend.attempted("get_user_posts");
+            return {
+                handle,
+                platform,
+                window: 0,
+                baseline: null,
+                hitRate: null,
+                medianWinRatio: null,
+                ratios: [],
+                best: null,
+                worst: null,
+                unavailable: reason(err),
+            };
+        }
+    };
+    server.registerTool("compare_creators", {
+        title: "Compare Creators",
+        _meta: viewMeta("compare_creators"),
+        description: "Two to five creators side by side, each scored against THEIR OWN recent median rather " +
+            "than against each other's raw numbers — which is the only way the comparison means " +
+            "anything, because a raw view count mostly measures follower count. Returns per creator: " +
+            "how many posts were scored, their own median, the share of the window that beat it, how " +
+            "hard they beat it when they did, every post's ratio, and their best and worst post. The " +
+            "ranking is yours to make: 'how often' and 'how big' usually disagree, and a hit rate " +
+            "over a short window is one post either way, so the window size travels with every " +
+            "number. Fetches one post list per creator: 2 nooticr credits each, 4-10 in total. " +
+            "Use for 'is their hit rate better than mine'; track_creator is one creator alone.",
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        outputSchema: OUTPUT_SCHEMAS.compare_creators,
+        inputSchema: z
+            .object({
+            usernames: z
+                .array(z.string())
+                .min(2)
+                .max(5)
+                .describe("2-5 creator handles, with or without @. Include your own to benchmark against " +
+                "them. These are handles, not brand names — resolve a company name first."),
+            platform: z.string().optional().describe(PLATFORM_ARG),
+            limit: z
+                .number()
+                .int()
+                .optional()
+                .describe("Posts per creator (default 12, max 30). One fetch each either way."),
+            metric: metricArg,
+        })
+            .strict(),
+    }, async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        const platform = (args.platform || "tiktok").toLowerCase();
+        const cap = clamp(args.limit, 12, 1, 30);
+        const metric = args.metric ?? "views";
+        // Deduped, because comparing a creator against themselves is two paid
+        // fetches for one column.
+        const handles = [...new Set(args.usernames.map(normaliseHandle))].filter(Boolean);
+        if (handles.length < 2) {
+            return evidence("A comparison needs two different creators. After removing duplicates only " +
+                `${handles.length} handle${handles.length === 1 ? "" : "s"} remained, so nothing was ` +
+                "fetched and nothing was charged.", { tool: "compare_creators", creators: [], billable: false, mcpCredits: { cost: 0 } });
+        }
+        const credits = costOf(handles.map(() => "get_user_posts"));
+        const decision = await confirmSpend(server.server, {
+            credits,
+            summary: `Read the recent posts of ${handles.map((h) => "@" + h).join(", ")} on ${platform}.`,
+            cheaper: "Compare fewer creators — each one is a separate fetch.",
+        });
+        if (!decision.proceed) {
+            return declinedResult(credits, "That comparison", "Compare fewer creators.");
+        }
+        const spend = new Spend();
+        const rows = [];
+        for (const handle of handles) {
+            rows.push(await standingFor(client, spend, handle, platform, metric, cap));
+        }
+        return evidence(standingsGuidance({ rows, metric, source: "handles" }) + "\n\n" + ownIt, {
+            mode: "evidence",
+            tool: "compare_creators",
+            evidenceFrom: ["get_user_posts"],
+            platform,
+            platformDefaulted: !args.platform,
+            metric,
+            thinWindow: THIN_WINDOW,
+            aboveRatio: ABOVE_RATIO,
+            creators: rows,
+            creditsCharged: spend.credits,
+            mcpCredits: spend.payload,
+        });
+    });
+    server.registerTool("watchlist_standings", {
+        title: "Watchlist Standings",
+        _meta: viewMeta("watchlist_standings"),
+        description: "The same comparison across everyone on your watchlist, answering 'who moved' in one " +
+            "call instead of one per creator. Each is scored against their own recent median, so the " +
+            "numbers are comparable between accounts of different sizes; the window size travels " +
+            "with each so a short one is not ranked as if it were a season. Reads the watchlist " +
+            "itself for free and fetches one post list per creator on it: 2 nooticr credits each, so " +
+            "the price is the size of your watchlist — it confirms before spending. Use for the " +
+            "weekly 'who is accelerating'; catch_up_watchlist is what is NEW rather than how it did.",
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        outputSchema: OUTPUT_SCHEMAS.watchlist_standings,
+        inputSchema: z
+            .object({
+            limit: z
+                .number()
+                .int()
+                .optional()
+                .describe("Posts per creator (default 12, max 30). One fetch each either way."),
+            metric: metricArg,
+        })
+            .strict(),
+    }, async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        const cap = clamp(args.limit, 12, 1, 30);
+        const metric = args.metric ?? "views";
+        let entries = [];
+        try {
+            entries = await store.list(await watchlistOwner(client));
+        }
+        catch (err) {
+            return failed("watchlist_standings could not read your watchlist", err);
+        }
+        if (!entries.length) {
+            // Not an error and not billed: an empty watchlist is a state with a
+            // next step, and saying so beats a comparison of nobody.
+            return evidence("Your watchlist is empty, so there is nobody to compare. Add creators with " +
+                "watch_creator first — the standings are then one call. Nothing was charged.", { tool: "watchlist_standings", watching: 0, creators: [], billable: false, mcpCredits: { cost: 0 } });
+        }
+        const credits = entries.length * CREDITS_PER_CREATOR;
+        const decision = await confirmSpend(server.server, {
+            credits,
+            summary: `Read the recent posts of all ${entries.length} creator${entries.length === 1 ? "" : "s"} ` +
+                "on your watchlist and score each against their own median.",
+            cheaper: "Unwatch creators you no longer follow, or use track_creator for just one.",
+        });
+        if (!decision.proceed) {
+            return declinedResult(credits, "Those standings", "Use track_creator for a single creator.");
+        }
+        const spend = new Spend();
+        const rows = [];
+        for (const entry of entries) {
+            rows.push(await standingFor(client, spend, entry.handle, entry.platform, metric, cap));
+        }
+        return evidence(standingsGuidance({ rows, metric, source: "watchlist" }) + "\n\n" + ownIt, {
+            mode: "evidence",
+            tool: "watchlist_standings",
+            evidenceFrom: ["get_user_posts"],
+            metric,
+            watching: entries.length,
+            thinWindow: THIN_WINDOW,
+            aboveRatio: ABOVE_RATIO,
+            creators: rows,
+            creditsCharged: spend.credits,
+            mcpCredits: spend.payload,
+        });
+    });
+    // ───────────────────────────────────────────────────────────────────────────
     // 3. who_should_i_work_with
     // ───────────────────────────────────────────────────────────────────────────
     server.registerTool("who_should_i_work_with", {
@@ -1637,7 +1824,7 @@ export function registerJobTools(server, makeClient, store) {
         const explicitHandles = [...new Set((args.usernames ?? []).map(normaliseHandle).filter(Boolean))];
         // A watchlist handle already knows its own platform, so it is checked
         // once there rather than once per requested platform — the same
-        // precision track_competitor already applies when it reads this store.
+        // precision track_creator already applies when it reads this store.
         let watchlistUnits = [];
         let watchlistTotal = 0;
         if (args.useWatchlist) {
@@ -1868,4 +2055,166 @@ export function registerJobTools(server, makeClient, store) {
             mcpCredits: spend.payload,
         });
     });
+    // ───────────────────────────────────────────────────────────────────────────
+    // find_people_with_problem — the prospect search this surface did not have.
+    //
+    // Every other discovery tool here is built around a TOPIC or a TERM:
+    // discover_social_posts takes a niche, search_mentions takes a brand,
+    // search_creators takes a keyword. None is built around a PROBLEM SOMEONE
+    // DESCRIBED, which is the shape of "find people who would want this".
+    //
+    // A user asked exactly that — "search X and Reddit for people that might see
+    // our product as a great use for their daily struggle" — and the model did
+    // the only thing available: fed the pain point into discover_social_posts as
+    // a `niche`. That argument is documented as "Niche/topic, e.g. 'fitness'",
+    // the backend runs it as a keyword search, and a seven-word sentence matched
+    // on its commonest words. Seven of eight results were marketing content; the
+    // one on-target result was a competitor's ad.
+    //
+    // What this does differently is not smarter matching — we run the same
+    // keyword search, because that is what the backend has. It is that the query
+    // is EXPANDED into the shapes a complaint actually takes, the platforms
+    // default to where people complain rather than where people market, and the
+    // result says plainly that it is a wide net the caller still has to sort.
+    // The judging is the host's, per this repo's whole design.
+    server.registerTool("find_people_with_problem", {
+        title: "Find People With A Problem",
+        _meta: viewMeta("find_people_with_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.",
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        outputSchema: OUTPUT_SCHEMAS.find_people_with_problem,
+        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)."),
+        })
+            .strict(),
+    }, async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        const spend = new Spend();
+        const problem = args.problem.trim();
+        const platforms = args.platforms?.length ? args.platforms : ["reddit"];
+        const cap = clamp(args.limit, 6, 1, 15);
+        // The shapes a complaint takes, rather than the topic it is about. Kept
+        // to three: each is a paid call per platform, and past three they start
+        // returning the same posts as each other.
+        const shapes = [
+            { shape: "plain", query: problem },
+            { shape: "shared", query: `anyone else ${problem}` },
+            { shape: "asking", query: `is there a way to ${problem}` },
+        ];
+        const seen = new Set();
+        const posts = [];
+        const unavailable = [];
+        for (const platform of platforms) {
+            for (const { shape, query } of shapes) {
+                try {
+                    const res = await client.callTool("discover_social_posts", { niche: query, platform, limit: cap });
+                    const structured = (res.structured ?? {});
+                    spend.record("discover_social_posts", structured);
+                    for (const raw of structured.posts ?? []) {
+                        const key = String(raw.externalUrl ?? raw.url ?? JSON.stringify(raw));
+                        if (seen.has(key))
+                            continue;
+                        seen.add(key);
+                        // `foundBy` is what makes the net inspectable: a post only the
+                        // does-anyone-else phrasing found is a different kind of hit
+                        // from one the plain phrasing found, and the caller judging
+                        // these should be able to see which.
+                        posts.push({ ...raw, foundBy: shape, platform: raw.platform ?? platform });
+                    }
+                }
+                catch (err) {
+                    spend.attempted("discover_social_posts");
+                    // A platform that failed is reported, not retried with different
+                    // words — the failure is the network, not the phrasing. See #49.
+                    unavailable.push({ platform, shape, reason: reason(err) });
+                }
+            }
+        }
+        if (!posts.length) {
+            return evidence([
+                `Nothing came back for "${problem}" on ${platforms.join(", ")}.`,
+                "",
+                unavailable.length
+                    ? `${unavailable.length} of ${platforms.length * shapes.length} searches errored, so ` +
+                        "this may be the network rather than the problem statement — say which networks " +
+                        "could not be searched rather than reporting an empty result as a finding."
+                    : "The searches worked and found nothing shaped like this complaint. Try the " +
+                        "problem in fewer, plainer words — this is a keyword search underneath, so a " +
+                        "long sentence matches on its commonest words.",
+                "",
+                ownIt,
+            ].join("\n"), {
+                mode: "evidence",
+                tool: "find_people_with_problem",
+                problem,
+                platforms,
+                posts: [],
+                unavailable,
+                creditsCharged: spend.credits,
+                mcpCredits: spend.payload,
+            });
+        }
+        return evidence([
+            `${posts.length} posts that might be someone describing "${problem}", across ` +
+                `${platforms.join(", ")}.`,
+            "",
+            "This is a wide net, not a filter. It is a keyword search underneath, so a good number " +
+                "of these will be marketing ABOUT the problem rather than someone having it — that " +
+                "distinction is the whole job here and it is yours to make, not something the search " +
+                "could do.",
+            "",
+            "For each post decide: is this person describing this problem as THEIRS, right now? A " +
+                "complaint, a question, a workaround they are tired of, all count. An ad for a tool " +
+                "that solves it does not, and neither does a listicle. Quote the line that made you " +
+                "decide, and name the post you are reasoning from.",
+            "",
+            "Report the ones that qualify with their permalink, so they can actually be replied to, " +
+                "and say how many you rejected and why — a shortlist with no reject count reads as if " +
+                "the search was precise.",
+            "",
+            "`foundBy` says which phrasing surfaced each post: `plain` the problem itself, `shared` " +
+                "the does-anyone-else form, `asking` the is-there-a-tool form. The last two skew " +
+                "towards genuine complaints and the first towards content about the topic.",
+            "",
+            unavailable.length
+                ? `Note that ${unavailable.length} searches errored — tell the user which networks ` +
+                    "could not be searched rather than presenting this as the whole picture.\n"
+                : "",
+            ownIt,
+        ]
+            .filter((l, i, all) => !(l === "" && all[i - 1] === ""))
+            .join("\n"), {
+            mode: "evidence",
+            tool: "find_people_with_problem",
+            evidenceFrom: ["discover_social_posts"],
+            problem,
+            platforms,
+            // `posts` is the key the gallery view already draws, so this needs no
+            // view of its own.
+            posts,
+            searchedShapes: shapes.map((s) => s.shape),
+            unavailable,
+            creditsCharged: spend.credits,
+            mcpCredits: spend.payload,
+        });
+    });
 }