@nooticr/mcp 1.26.28 → 1.26.30

package/dist/shared/jobs.js

@@ -57,6 +57,7 @@ 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 { withEvidence } from "./evidence-digest.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";
@@ -596,10 +597,22 @@ const metricArg = z
     .optional()
     .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. */
+    /** Guidance AND evidence in both channels, because no host delivers both. */
+    // Neither channel is safe on its own, and which one is dropped depends on
+    // the host: Claude Code discards every `content` text block when a result
+    // carries `structuredContent` (#44, measured at 0 guidance phrases across
+    // 175 tool results), while Claude.ai routes `structuredContent` to the
+    // widget and hands the model only the text blocks (#59).
+    //
+    // #51 made the guidance survive both. The evidence did not, so a real
+    // session got "3 posts that might be someone describing ...", instructions
+    // to quote lines from them, and no posts. The guidance these tools write is
+    // deictic — it counts and describes material that used to be somewhere
+    // else — so `withEvidence` puts a rendering of that material in the same
+    // block as the sentence describing it.
     const evidence = (guidance, payload) => ({
-        content: [{ type: "text", text: guidance }],
-        structuredContent: payload,
+        content: [{ type: "text", text: withEvidence(guidance, payload) }],
+        structuredContent: { guidance, ...payload },
     });
     const failed = (prefix, err) => ({
         content: [{ type: "text", text: `${prefix}: ${reason(err)}` }],
@@ -802,23 +815,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,
@@ -827,7 +842,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
@@ -864,7 +879,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
@@ -872,7 +887,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,
@@ -942,7 +957,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,
@@ -967,7 +982,7 @@ export function registerJobTools(server, makeClient, store) {
     // ───────────────────────────────────────────────────────────────────────────
     // 2b. compare_creators / watchlist_standings
     //
-    // The comparison track_competitor computes and discards. Both are pure
+    // 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.
@@ -1015,7 +1030,7 @@ export function registerJobTools(server, makeClient, store) {
             "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_competitor is one creator alone.",
+            "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
@@ -1120,10 +1135,10 @@ export function registerJobTools(server, makeClient, store) {
             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_competitor for just one.",
+            cheaper: "Unwatch creators you no longer follow, or use track_creator for just one.",
         });
         if (!decision.proceed) {
-            return declinedResult(credits, "Those standings", "Use track_competitor for a single creator.");
+            return declinedResult(credits, "Those standings", "Use track_creator for a single creator.");
         }
         const spend = new Spend();
         const rows = [];
@@ -1817,7 +1832,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) {
@@ -2048,4 +2063,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,
+        });
+    });
 }

package/dist/shared/loading-plans.js

@@ -243,12 +243,21 @@ export const LOADING_PLANS = {
             },
         ],
     },
-    track_competitor: {
+    track_creator: {
         label: "Reading what they shipped",
         kind: "strip",
         n: 3,
         steps: [step("get_user_posts")],
     },
+    find_people_with_problem: {
+        label: "Looking for people with this problem",
+        kind: "list",
+        n: 6,
+        // Three query shapes per platform, so the step repeats rather than
+        // representing one search — the wait is proportional to platforms asked
+        // for, and a single-step plan would under-report it badly.
+        steps: [step("discover_social_posts")],
+    },
     // Both fan out one post-list fetch per creator, so the price is the size of
     // the list and the wait is drawn per unit — same shape as catch_up_watchlist.
     compare_creators: {

package/dist/shared/output-schemas.js

@@ -198,7 +198,19 @@ const analysis = open({
  * marker, what it fetched, and where it came from. Optional throughout,
  * because the shape of the material itself differs per tool.
  */
+/**
+ * What to do with the material, carried where a host will actually deliver it.
+ *
+ * Every tool that returns guidance puts the same string in a `content` text
+ * block too. That block is the one the MCP spec points at and the one hosts
+ * drop: a host rendering `structuredContent` replaces the text blocks with the
+ * serialised JSON, so the text copy reaches no model. Declared here rather than
+ * left to `passthrough()` because a host reading the schema should be able to
+ * see that the field exists.
+ */
+const guidance = scalar().describe("What to do with this payload, in prose. Read it: it is the instruction, not a summary.");
 const evidence = {
+    guidance,
     mode: scalar().describe('Always "evidence": this payload is material you have still to read.'),
     tool: scalar(),
     evidenceFrom: listOf(z.string()).describe("The cheap calls this was assembled from."),
@@ -311,6 +323,7 @@ export const OUTPUT_SCHEMAS = {
      * one should not find the key gone.
      */
     analyze_comments: open({
+        guidance,
         summary: scalar(),
         themes: anyList(),
         commentsAnalyzed: scalar(),
@@ -516,7 +529,7 @@ export const OUTPUT_SCHEMAS = {
         threads: anyList().describe("Shaped like search_mentions so one view renders both."),
         mcpCredits,
     }),
-    track_competitor: open({
+    track_creator: open({
         ...evidence,
         username: scalar(),
         platform: scalar(),
@@ -525,7 +538,7 @@ export const OUTPUT_SCHEMAS = {
         since: scalar(),
         sinceApplied: scalar(),
         tracked: scalar().describe("True when this creator is on the watchlist, which is what makes a diff possible."),
-        lastCheckedAt: scalar().describe("When track_competitor last looked, or null on a first look."),
+        lastCheckedAt: scalar().describe("When track_creator last looked, or null on a first look."),
         newSincePreviousCheck: scalar().describe("Posts not seen at the last check; null when there was none."),
         baseline: open({
             count: scalar(),
@@ -549,6 +562,21 @@ export const OUTPUT_SCHEMAS = {
         creditsCharged: scalar(),
         mcpCredits,
     }),
+    /**
+     * Prospect discovery. The unit is a POST that might be someone describing a
+     * problem — `posts` rather than a bespoke key, because the gallery view
+     * already draws that shape and a wide net does not need a view of its own.
+     */
+    find_people_with_problem: open({
+        ...evidence,
+        problem: scalar(),
+        platforms: listOf(z.string()),
+        posts: listOf(post),
+        searchedShapes: listOf(z.string()).describe("Which complaint phrasings were searched: plain, shared, asking."),
+        unavailable: anyList().describe("Searches that errored, by platform and shape."),
+        creditsCharged: scalar(),
+        mcpCredits,
+    }),
     who_should_i_work_with: open({
         ...evidence,
         niche: scalar(),
@@ -844,6 +872,7 @@ export const OUTPUT_SCHEMAS = {
      * documenting a field that never arrives is worse than omitting it.
      */
     score_draft: open({
+        guidance,
         draft: scalar(),
         platform: scalar(),
         mcpCredits,
@@ -936,6 +965,7 @@ export const OUTPUT_SCHEMAS = {
         trend: scalar().describe("The discriminator the view keys on."),
     }),
     mention_trend: open({
+        guidance,
         runs: listOf(open({
             ranAt: scalar(),
             found: scalar().describe("Everything that sweep saw."),

package/dist/shared/own-account.js

@@ -51,13 +51,23 @@
  * `get_content_plan` above); this file is what makes them reachable here.
  */
 import { z } from "zod";
+import { withEvidence } from "./evidence-digest.js";
 import { OUTPUT_SCHEMAS } from "./output-schemas.js";
 import { viewMeta } from "./view-meta.js";
 function toResult(proxy) {
     const textBlock = proxy.contentBlocks.find((c) => c.type === "text");
+    const structured = proxy.structured;
+    // The backend's summary line, plus the rows it summarises. `list_own_apps`
+    // said "You have 2 app(s) in this workspace" and kept the appIds in
+    // `structuredContent` — which a host rendering the view gives to the widget,
+    // leaving a model that needs an appId for draft_post with the count alone
+    // (#59).
+    const text = String(textBlock?.text ?? "");
     return {
-        content: textBlock ? [{ type: "text", text: String(textBlock.text ?? "") }] : [],
-        structuredContent: proxy.structured,
+        content: [
+            { type: "text", text: structured ? withEvidence(text, structured) : text },
+        ],
+        structuredContent: structured,
     };
 }
 function failed(prefix, err) {

package/dist/shared/prompts.js

@@ -298,7 +298,7 @@ export function registerPrompts(server) {
         `over- and under-performs, who the audience is. 2 credits.\n` +
         `4. watch_creator to add them to your watchlist — free, stores the handle only, fetches ` +
         `nothing.\n` +
-        `5. track_competitor on the same handle — what they have shipped recently and which of it ` +
+        `5. track_creator on the same handle — what they have shipped recently and which of it ` +
         `beat THEIR OWN median, not a raw view count that mostly measures follower count. 2 credits, ` +
         `whatever the window. Because they are now on your watchlist, this also sets its own "since I ` +
         `last checked" marker — a different one from catch_up_watchlist's.\n` +

package/dist/shared/standings.js

@@ -2,7 +2,7 @@
  * Putting two creators side by side (issue #30).
  *
  * The surface had a strong and correct stance on baselines, applied in one
- * direction only. `track_competitor` scores each post against the median of
+ * direction only. `track_creator` scores each post against the median of
  * that creator's own window, "because a raw view count mostly measures
  * follower count — outperformance against themselves is the signal".
  * `why_did_this_underperform` does the same for a single post.
@@ -136,7 +136,10 @@ export function standingsGuidance(a) {
     lines.push("", `Every ratio here is against a window measured now. It cannot tell you whether anyone's ` +
         "baseline is itself moving — that needs a second point in time, which nothing stores yet " +
         "(issue #28). So do not read a high hit rate as 'improving'; it is 'consistent within this " +
-        "window' and nothing more.");
+        "window' and nothing more.", "", "When you have decided what the numbers say, call show_standings with the rows and the axis " +
+        "you ranked on. Free, and it is the one place the ranking is attributed to you rather than " +
+        "presented as a nooticr score — it also draws a creator with too thin a window as unranked " +
+        "rather than last, which is the mistake a plain table makes on your behalf.");
     return lines.join("\n");
 }
 /** Threshold re-exported so the tools and the view agree on the badge. */

package/dist/shared/tools-def.js

@@ -349,15 +349,15 @@ export const TOOL_DEFINITIONS = [
         inputSchema: z.object({ username: z.string().describe("Whose audience this is, with or without @."), summary: z.string().optional(), replies: z.array(z.object({ id: z.string(), comment: z.string(), author: z.string().optional(), likes: z.number().optional(), postUrl: z.string().optional(), postTitle: z.string().optional(), postedAt: z.string().optional(), draft: z.string().optional(), kind: z.string().optional(), why: z.string().optional() })), themes: z.array(z.string()).optional(), nextSteps: z.array(z.string()).optional() }).strict(),
     },
     {
-        name: "track_competitor",
+        name: "track_creator",
         title: "Track Competitor",
-        description: "What a creator shipped recently, and which of it beat their own baseline. Scores every post in the window against the median of that same window, because a raw view count mostly measures follower count \u2014 outperformance against themselves is the signal worth reporting. If they are on your watchlist it also marks which posts are new since your last track_competitor call and moves that marker forward. Use for a rival you follow over time. Consumes 2 nooticr credits, whatever the window size.",
+        description: "What a creator shipped recently, and which of it beat their own baseline. Scores every post in the window against the median of that same window, because a raw view count mostly measures follower count \u2014 outperformance against themselves is the signal worth reporting. If they are on your watchlist it also marks which posts are new since your last track_creator call and moves that marker forward. Use for a rival you follow over time. Consumes 2 nooticr credits, whatever the window size.",
         inputSchema: z.object({ username: z.string().describe("Creator handle, with or without @."), platform: z.string().optional().describe("Platform (default tiktok)."), limit: z.number().int().optional().describe("Posts in the window (default 12, max 30)."), metric: z.enum(["views", "likes", "comments", "shares", "engagementRate"]).optional().describe("Which stat to rank on (default views)."), since: z.string().optional().describe("Only posts published on or after this date, as YYYY-MM-DD.") }).strict(),
     },
     {
         name: "compare_creators",
         title: "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_competitor is one creator alone.",
+        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.",
         inputSchema: z.object({ usernames: z.array(z.string()).min(2).max(5), platform: z.string().optional(), limit: z.number().int().optional(), metric: z.string().optional() }).strict(),
     },
     {
@@ -390,6 +390,12 @@ export const TOOL_DEFINITIONS = [
         description: "Demand and supply in one result. Reads the comments on a creator's own recent posts for what their audience explicitly asks for, sweeps the niche for what is already being made, and returns both with ids so an idea can be traced back to the comment that asked for it \u2014 a gap nobody asked for is noise, a request nobody serves is the opportunity. Names the niche from the creator's most-used hashtag when you do not give one. Use to decide what to film; niche_report covers the supply half alone. Consumes 2 nooticr credits for the post list, 2 per post read, and 2 for the sweep \u2014 12 at the default of 4 posts.",
         inputSchema: z.object({ username: z.string().describe("Your handle, with or without @."), platform: z.string().optional().describe("Platform (default tiktok)."), niche: z.string().optional().describe("Niche for the supply sweep. Defaults to your most frequent hashtag."), limit: z.number().int().optional().describe("Your posts to read comments on (default 4, max 8). This is the price."), commentsPerPost: z.number().int().optional().describe("Comments per post (default 25, max 50)."), supplyLimit: z.number().int().optional().describe("Posts in the niche sweep (default 12, max 30).") }).strict(),
     },
+    {
+        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).") }).strict(),
+    },
     {
         name: "search_spoken_mentions",
         title: "Search Spoken Mentions",