@nooticr/mcp 1.26.28 → 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
@@ -115,10 +115,11 @@ them caps that fan-out with an argument.
 | `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. |
@@ -529,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

@@ -597,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)}` }],
@@ -802,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,
@@ -827,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
@@ -864,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
@@ -872,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,
@@ -942,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,
@@ -967,7 +974,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 +1022,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 +1127,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 +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) {
@@ -2048,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,
+        });
+    });
 }

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/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",

package/dist/shared/tools.js

@@ -14,7 +14,7 @@ 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 { costSentence, EVIDENCE_PLANS, fetchBillingNote, frameIndex, framesToBlocks, planCalls, scoreDraftGuidance, } from "./evidence.js";
+import { costSentence, EVIDENCE_PLANS, fetchBillingNote, frameIndex, framesToBlocks, planCalls, scoreDraftGuidance, KNOWN_PLATFORMS, platformFailureGuidance, } from "./evidence.js";
 import { confirmSpend, declinedResult, searchMentionsCost, SEARCH_PLATFORMS, DISCOVERABLE_PLATFORMS, } from "./spend.js";
 import { BackendWatchStore, MemoryWatchStore, registerWatchlist, } from "./watchlist.js";
 import { registerJobTools } from "./jobs.js";
@@ -25,7 +25,7 @@ import { loadingPlansJson } from "./loading-plans.js";
 import { registerHandoff } from "./handoff.js";
 import { registerCollabTools } from "./collab.js";
 /** Current MCP server version — bumped on every deploy for traceability. */
-export const MCP_SERVER_VERSION = "1.26.28";
+export const MCP_SERVER_VERSION = "1.26.29";
 /** MCP Apps extension identifier */
 const UI_EXTENSION = "io.modelcontextprotocol/ui";
 /** MIME type for MCP Apps HTML resources */
@@ -342,6 +342,21 @@ function toolError(prefix, err) {
             isError: true,
         };
     }
+    // A network that ERRORED is not a network that came back empty, and the two
+    // want opposite responses: an empty result means try a different query, an
+    // error means try a different network or tell the user. Nothing said which,
+    // so a host did the one thing that cannot work — re-ran the same call with
+    // the words changed, three times, each a paid upstream call. The backend
+    // names the platform in these messages ("... failed: reddit: ..."), so the
+    // split is recoverable here without every one of the 26 call sites having to
+    // pass its arguments down.
+    const platform = KNOWN_PLATFORMS.find((p) => new RegExp(`(^|[^a-z])${p}([^a-z]|$)`, "i").test(msg));
+    if (platform) {
+        return {
+            content: [{ type: "text", text: `${prefix}. ${platformFailureGuidance({ platform, message: msg })}` }],
+            isError: true,
+        };
+    }
     return { content: [{ type: "text", text: `${prefix}: ${msg}` }], isError: true };
 }
 /**
@@ -377,16 +392,34 @@ async function runEvidence(tool, args, client) {
             extra = { unavailable: plan.also.via };
         }
     }
-    // The guidance leads. A model reads the first text block in a result, and
-    // that is where the account of what to produce has to be — everything below
-    // it is material with no instruction attached.
+    // The guidance rides in BOTH channels, and the structured one is the one
+    // that arrives.
+    //
+    // This used to say "the guidance leads: a model reads the first text block in
+    // a result, and that is where the account of what to produce has to be". That
+    // is what the MCP spec allows, and it is not what hosts do. Claude Code
+    // discards every `content` text block whenever a result carries
+    // `structuredContent`, keeps the non-text blocks, and shows the model the
+    // serialised JSON instead — unconditionally, with no setting, and without
+    // consulting `outputSchema`. Every tool here declares one, so every guidance
+    // string this file writes was landing nowhere.
+    //
+    // Measured before changing it, over 59 real runs of the quest suite: 0
+    // guidance phrases across 175 tool results. `analyze_post` handed back frames,
+    // a transcript and 2,000 characters ending in "call show_analysis when you are
+    // done"; the model wrote the analysis and delivered it in chat, and
+    // show_analysis was called in 1 run of 12.
+    //
+    // The text block stays for hosts that honour it (and for the images, which
+    // must sit in `content`). `guidance` on the payload is what reaches the rest.
+    // See docs/testing/tool-chaining-quests.md.
     const billing = nothingToFetch
         ? "Nothing was fetched for this call, so nothing was charged."
         : fetchBillingNote(tool);
-    const content = [
-        { type: "text", text: `${plan.guidance(args)}\n\n${billing}` },
-    ];
+    const guidance = `${plan.guidance(args)}\n\n${billing}`;
+    const content = [{ type: "text", text: guidance }];
     const out = {
+        guidance,
         // Kept, and constant. It is not an echo of an argument — the job tools in
         // jobs.ts set the same key with no argument to echo — it marks a payload as
         // material the caller still has to read. Dropping it would break anything
@@ -525,8 +558,8 @@ export function createMcpServer(rawMakeClient, opts) {
         // a search_mentions result render in the monitoring view.
         "answer_my_audience",
         "show_audience_replies",
-        "track_competitor",
-        // The comparison track_competitor computes per creator and never puts side
+        "track_creator",
+        // The comparison track_creator computes per creator and never puts side
         // by side, plus the free view that draws the table once a read is written.
         "compare_creators",
         "watchlist_standings",
@@ -538,6 +571,10 @@ export function createMcpServer(rawMakeClient, opts) {
         // hits rather than comments, so it gets its own view rather than the
         // monitoring one.
         "search_spoken_mentions",
+        // Prospect discovery: the same keyword search as discover_social_posts, but
+        // widened into the shapes a complaint takes rather than the topic it is
+        // about. Returns `posts`, so the gallery view draws it.
+        "find_people_with_problem",
         // Own-account intelligence (own-account.ts). list_own_apps stays
         // view-less like watch_creator — it lists metadata, nothing to draw.
         // get_scheduled_posts and get_post_performance return a `posts` array
@@ -907,7 +944,11 @@ export function createMcpServer(rawMakeClient, opts) {
             "Work out their niche, recurring themes, hook formula, what over- and under-performs and who " +
             "their audience is, reading the spread of the numbers rather than only the best post, and " +
             `name the posts you reason from. ${costSentence("analyze_creator_profile")} ` +
-            "Use for the teardown itself; find_hook_pattern fetches the same posts and asks only for the formula.",
+            "Use for the teardown itself; find_hook_pattern fetches the same posts and asks only for the " +
+            "formula. NOT for keeping an eye on a rival over time: \"track X\", \"how are they doing " +
+            "lately\", \"what have they shipped since I last looked\" are track_creator, which scores " +
+            "each post against that creator's own median and remembers where you left off. This tool " +
+            "returns the posts and no verdict, and remembers nothing between calls.",
         _meta: {
             ui: { resourceUri: uiResource("analyze_creator_profile") },
             "ui/resourceUri": uiResource("analyze_creator_profile"),
@@ -1160,9 +1201,14 @@ export function createMcpServer(rawMakeClient, opts) {
             const res = await client.callTool("get_post_comments", { ...args });
             const structured = (res.structured ?? {});
             const comments = toEvidence(args.url, structured.comments);
+            const guidance = reviewGuidance(args.url, comments.length);
             return {
-                content: [{ type: "text", text: reviewGuidance(args.url, comments.length) }],
+                content: [{ type: "text", text: guidance }],
                 structuredContent: {
+                    // See runEvidence: a text block alone reaches no host that renders
+                    // structuredContent, and this is the tool show_comment_review's whole
+                    // chain hangs off.
+                    guidance,
                     mode: "evidence",
                     url: args.url,
                     platform: structured.platform ?? null,
@@ -1921,16 +1967,24 @@ export function createMcpServer(rawMakeClient, opts) {
     // argument: the draft is the caller's own text, so the backend was only ever
     // being paid to hold it up against a standard, and the standard is what
     // comes back instead. Nothing here can fail, which is why nothing is caught.
-    async (args) => ({
-        content: [{ type: "text", text: scoreDraftGuidance(args.draft, String(args.platform ?? "")) }],
-        structuredContent: {
-            draft: args.draft,
-            platform: args.platform ?? "tiktok",
-            // Same shape the free tools use, so a caller totting up a session's spend
-            // does not have to special-case this one.
-            mcpCredits: { cost: 0 },
-        },
-    }));
+    async (args) => {
+        const guidance = scoreDraftGuidance(args.draft, String(args.platform ?? ""));
+        return {
+            content: [{ type: "text", text: guidance }],
+            structuredContent: {
+                // The rubric IS this tool's answer — it fetches nothing and scores
+                // nothing itself. In a text block it reached no host that renders
+                // structuredContent, which made the tool return its own input and a
+                // credit note. See runEvidence.
+                guidance,
+                draft: args.draft,
+                platform: args.platform ?? "tiktok",
+                // Same shape the free tools use, so a caller totting up a session's spend
+                // does not have to special-case this one.
+                mcpCredits: { cost: 0 },
+            },
+        };
+    });
     server.registerTool("repurpose_post", {
         title: "Repurpose Post",
         description: "The source post, its transcript and its stats, for you to rewrite for other surfaces — X " +
@@ -2247,7 +2301,7 @@ export function createMcpServer(rawMakeClient, opts) {
         }
     });
     registerPrompts(server);
-    // One store for both. track_competitor keeps its "since I last looked" marker
+    // One store for both. track_creator keeps its "since I last looked" marker
     // on the same watchlist entries, in its own field — two stores would mean a
     // creator you watch and a creator you track were different people.
     //

package/dist/shared/ui-template.js

@@ -2782,7 +2782,7 @@ export const NOOTICR_UI_TEMPLATE = `<!DOCTYPE html>
   /**
    * The one line a competitor sweep or an underperformance check actually
    * exists to produce — ratio to the creator's own median, and the verdict
-   * that ratio earns. track_competitor and why_did_this_underperform attach
+   * that ratio earns. track_creator and why_did_this_underperform attach
    * "standing" to every post they score (see performance.ts), and until this
    * existed postCard rendered the same view/like/comment pills any gallery
    * gets, so the computed comparison a person paid for never reached the
@@ -3982,8 +3982,18 @@ export const NOOTICR_UI_TEMPLATE = `<!DOCTYPE html>
 
     // Single post
     if(d.post||d.platform){app.innerHTML=postCard(d.post||d,true);return;}
-    // Fallback
-    app.innerHTML='<div class="json-block fade-in">'+esc(JSON.stringify(d,null,2))+"</div>";
+    // Fallback. The guidance field is prose written for the model, not data —
+    // dumped into the JSON block it reads as a wall of escaped text, and it is
+    // the longest string in most payloads. Drawn above the block and dropped
+    // from it. This is also what finally gives score_draft a view worth
+    // looking at: its rubric IS its answer, and the card used to show the
+    // echoed draft and a credit cost with the rubric nowhere on screen.
+    var rest=d,lead="";
+    if(d&&typeof d==="object"&&typeof d.guidance==="string"){
+      lead='<div class="fade-in" style="white-space:pre-wrap;line-height:1.5;margin-bottom:12px">'+esc(d.guidance)+"</div>";
+      rest={};for(var gk in d){if(gk!=="guidance")rest[gk]=d[gk];}
+    }
+    app.innerHTML=lead+'<div class="json-block fade-in">'+esc(JSON.stringify(rest,null,2))+"</div>";
     setTimeout(reportSize,50);
   }
 

package/dist/shared/watchlist.js

@@ -33,11 +33,18 @@
  * registers, and only one registration under a name can win — but renaming
  * either side would break whichever hosts had already learned the old one,
  * for a tool whose whole promise is "what you called before still works". So
- * nothing about the surface moved. `watch_creator`, `unwatch_creator`,
- * `catch_up_watchlist` and `track_competitor` keep their names, arguments and
+ * nothing about the surface moved for THAT change. `watch_creator`,
+ * `unwatch_creator` and `catch_up_watchlist` keep their names, arguments and
  * behaviour; only the bytes moved, and the backend's own twins stay
  * unregistered here because they would be a second, disconnected list.
  *
+ * `track_creator` is the one exception, and for an unrelated reason: it was
+ * `track_competitor`, and that name was measured to be unreachable for the
+ * way most people ask for it — see its registration in jobs.ts. The backend
+ * still registers `track_competitor` for its own dashboard copilot, which is
+ * the ordinary state of two repos with two release cycles rather than a
+ * collision: the names no longer overlap, so nothing has to win.
+ *
  * The stores above are still live and still matter. They are the fallback for
  * an account with no workspace or a backend too old to have the tools, and
  * they are what the one-time migration reads from. Deleting one because "the
@@ -155,9 +162,10 @@ export class FileWatchStore {
  * and on ChatGPT had two, and a server-side scheduler could read neither.
  *
  * The swap is deliberately at `WatchStore` rather than at the tool layer.
- * `watch_creator`, `unwatch_creator`, `catch_up_watchlist` and
- * `track_competitor` keep their names, their arguments and their behaviour;
- * only where the bytes live changes. That is the whole reason the collision
+ * `watch_creator`, `unwatch_creator` and `catch_up_watchlist` keep their
+ * names, their arguments and their behaviour; only where the bytes live
+ * changes. (`track_creator` was later renamed from `track_competitor` for a
+ * reason that has nothing to do with storage — see above.) That is the whole reason the collision
  * with the backend's identically-named tools was not worth solving by
  * renaming anything: a host that already learned `watch_creator` keeps
  * working, and it now writes somewhere the other host can see.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nooticr/mcp",
   "mcpName": "com.nooticr/mcp",
-  "version": "1.26.28",
+  "version": "1.26.29",
   "description": "MCP server for nooticr - fetch, discover and understand TikTok/Instagram/YouTube/X/Reddit/LinkedIn/Weibo posts with AI (media metadata, niche discovery, brand monitoring, hook & viral analysis)",
   "homepage": "https://mcp.nooticr.com",
   "repository": {
@@ -38,9 +38,10 @@
     "test:e2e:visual": "playwright test tests/e2e/agentic-visual.e2e.ts tests/e2e/agentic-visual-full-app.e2e.ts",
     "test:e2e-smoke": "bash scripts/run-mechanical-e2e-smoke.sh",
     "test:e2e-smoke:fixture": "NOOTICR_E2E_BACKEND=fixture bash scripts/run-mechanical-e2e-smoke.sh",
-    "test:agentic-e2e": "bash scripts/run-agentic-evals.sh",
+    "test:quests": "bash scripts/run-quests.sh",
     "contract:host": "sh scripts/host-contract.sh",
-    "verify": "npm run build && npx tsc --noEmit && (cd cloudflare && npx tsc --noEmit) && npx vitest run && npm run contract:host && npm run conformance:mcpjam && npx playwright test",
+    "chain:map": "bash scripts/run-chain-map.sh",
+    "verify": "npm run build && npx tsc --noEmit && (cd cloudflare && npx tsc --noEmit) && npx vitest run && npm run contract:host && npm run chain:map && npm run conformance:mcpjam && npx playwright test",
     "contract:manifest": "node scripts/contract-check.mjs --from=../nooticr-server/platform-capabilities.json",
     "test:mutation": "node scripts/mutation-guard.mjs",
     "test:invariants": "node scripts/invariant-guard.mjs",