@nooticr/mcp 1.26.26 → 1.26.28

package/README.md

@@ -101,6 +101,7 @@ them caps that fan-out with an argument.
 | `catch_up_watchlist` | 2 per creator | What everyone you watch has posted since your last catch-up. Compares against the snapshot taken last time and moves it forward, so it answers "what is new" rather than "what exists". |
 | `create_brand_watch` | free to call | Schedule a recurring sweep and get emailed only what is new. `kind: "mentions"` (default) is a recurring `search_mentions` sweep for `term`/`platforms`; `kind: "competitor"` is a recurring `get_user_posts` check on one creator (`handle`/`platform`), mailing only what beats their own recent median. Two calls by design: the first returns the quote (cost per run, cadence, cost per day) and a `confirmationToken`; nothing is created or charged until you call it again with `confirm: true` and that token. Each run then bills the same as calling the matching tool yourself — 2 credits per network (5 for Xiaohongshu) for mentions, a flat 2 credits for competitor. |
 | `list_brand_watches` | free | Every watch you have scheduled: term, networks, cadence, cost per run, credits spent so far, runs made, and when the next one is due. |
+| `mention_trend` | free | **What a watch has seen over time**, which nothing else here answers — every other read is about now. One point per run: when it ran, how many mentions it found, how many were new, and both counts per network, so "which network is growing" and "did it go quiet or did we stop looking" come apart. On a competitor watch each point carries the median that run measured, which turns "they beat their own median" into "and that median has doubled". Plus the mentions more than one run has seen. Free because the sweeps were billed when they ran; charging again to read what was already paid for is the thing it fixes. |
 | `stop_brand_watch` | free | Stop a watch by `watchId` or `term`. Immediate — the next run does not happen and nothing more is charged. |
 | `niche_report` | 2 | Recent posts in a niche with their stats, so the dominant formats, hook patterns and the gaps nobody fills can be read off them. One `discover_social_posts` call. Use when deciding what to make. |
 | `analyze_creator_profile` | 2 | A creator's recent posts with their stats — the material of a teardown: niche, themes, hook formula, what over- and underperforms, who the audience is. One `get_user_posts` call. |
@@ -112,7 +113,11 @@ them caps that fan-out with an argument.
 | `answer_my_audience` | 2 + 2 per post opened (14 by default) | **The mirror of `search_mentions`.** The questions waiting under your *own* posts: recent posts fetched, comments read on each, grouped under the post they were left on, every comment with a stable id, and the ones that read like questions or requests flagged and sorted to the top. It finds and drafts — it cannot post a reply, because no nooticr connection carries comment-write permission on any network. `limit` caps how many posts are opened, which is the price. |
 | `prepare_handoff` | free | **The hand-off to your tracker.** Turns items you classified — a bug report in a comment, a complaint said out loud in a video — into the exact `title`, `body` and `labels` to file through whichever GitHub, Jira or Linear MCP server the host also has connected. nooticr files nothing and holds no tracker credential. The body carries the quote fenced and framed as a third-party report rather than as instructions, because the issue is read next by a coding agent; contact details are redacted, `@handles` and `#numbers` are defanged so filing notifies nobody by accident, and a `searchFirst` string dedupes a second sweep against the first. Makes no requests. |
 | `show_audience_replies` | free | Lays your drafts out for a person to work through, grouped under the post, each with what you decided to do about it. Sends nothing; fetches nothing. |
+| `show_standings` | free | Draws the standings your model read out of `compare_creators` or `watchlist_standings` — one row per creator, with the window and the median it was scored against. `ranking` records which axis you ordered on, and `tooThin` draws a creator with too short a window as unranked rather than last: missing from a comparison is not the same as losing it. Makes no requests. |
+| `show_trend` | free | Draws the trend your model read out of `mention_trend`. `tooShort` marks a series with too few points to call a direction, and `edgeIsRecordStart` marks a left edge that is where the record begins rather than where the conversation did — a chart hiding either is the mistake this view could otherwise make on your behalf. Makes no requests. |
 | `track_competitor` | 2 | What a creator shipped, and which of it beat **their own** median rather than a raw view count that mostly measures follower count. One post list, whatever the window. If they are on your watchlist it also marks what is new since your last check and moves that marker forward — its own marker, not the one `catch_up_watchlist` keeps. |
+| `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. |
 | `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. |

package/dist/shared/brand-watch.js

@@ -14,6 +14,7 @@
  */
 import { z } from "zod";
 import { OUTPUT_SCHEMAS } from "./output-schemas.js";
+import { viewMeta } from "./view-meta.js";
 import { BACKEND_CALL_CREDITS, confirmSpend, declinedResult, searchMentionsCost } from "./spend.js";
 /** Exported so prompts.ts's completion offers exactly what create_brand_watch accepts. */
 export const CADENCES = ["hourly", "every_6_hours", "every_12_hours", "daily", "weekly"];
@@ -136,6 +137,133 @@ async function gateRecurringCharge(server, args) {
     return null;
 }
 /** Same shaping every other proxied tool uses: text block plus structured payload. */
+/**
+ * What to do with a run series.
+ *
+ * Three ways a reader gets this wrong, and all three produce a confident
+ * sentence about a change that did not happen:
+ *
+ *  - Two points are not a trend. A watch that has run twice can only say what
+ *    the second run found, and the difference between two sweeps of scraped
+ *    data is mostly the scrape.
+ *  - The start of the window is not the start of the conversation. It is the
+ *    edge of what is kept, or the day the watch was created — a flat left
+ *    edge reads as silence and is neither.
+ *  - Volume found and volume mailed answer different questions. A run that
+ *    found forty and mailed none is a conversation that has stopped moving,
+ *    not one that has stopped.
+ */
+/**
+ * Which networks moved, and which way — computed, not left to the reader.
+ *
+ * `runs` comes back newest-first, which is the order it is read in and the
+ * wrong order to subtract in. Naming the direction here removes the one step
+ * where an off-by-one-end error produces a confident sentence about a change
+ * that went the other way.
+ */
+function perPlatformDirection(runs) {
+    const at = (r) => String(r.ranAt ?? "");
+    const chronological = [...runs].sort((a, b) => (at(a) < at(b) ? -1 : 1));
+    const foundIn = (r, platform) => {
+        const per = (r?.perPlatform ?? {});
+        const v = per[platform]?.found;
+        return typeof v === "number" && Number.isFinite(v) ? v : null;
+    };
+    const first = chronological[0];
+    const last = chronological[chronological.length - 1];
+    const platforms = new Set();
+    for (const r of chronological) {
+        for (const k of Object.keys((r.perPlatform ?? {})))
+            platforms.add(k);
+    }
+    const moves = [];
+    for (const platform of platforms) {
+        const from = foundIn(first, platform);
+        const to = foundIn(last, platform);
+        if (from === null || to === null || from === to)
+            continue;
+        moves.push({ platform, from, to, delta: to - from });
+    }
+    if (!moves.length) {
+        return ("No network's count differs between the earliest and latest sweep in this window, so " +
+            "whatever moved, moved inside it rather than across it — look at the points themselves.");
+    }
+    moves.sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
+    const said = moves
+        .slice(0, 4)
+        .map((m) => `${m.platform} ${m.delta > 0 ? "rose" : "fell"} from ${m.from} to ${m.to} ` +
+        `(${m.delta > 0 ? "+" : ""}${m.delta})`)
+        .join(", ");
+    return (`Earliest to latest sweep in this window: ${said}. Those directions are computed here on ` +
+        "purpose — `runs` is newest-first, so subtracting the ends by hand is where a real reading " +
+        "of this went backwards. Use these rather than re-deriving them.");
+}
+function trendGuidance(sc, runs) {
+    const n = runs.length;
+    const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : null);
+    const term = typeof sc.term === "string" && sc.term ? `"${sc.term}"` : "this watch";
+    const kind = sc.kind === "competitor" ? "competitor" : "mentions";
+    const lines = [];
+    if (!n) {
+        lines.push(`No runs recorded for ${term} in that window. A watch records a point every time it ` +
+            "sweeps, so this means it has not run yet rather than that nobody has said anything — " +
+            "say which, and check `nextRun` on list_brand_watches. Nothing was charged.");
+        return lines.join("\n");
+    }
+    const windowDays = num(sc.windowDays);
+    lines.push(`${n} run${n === 1 ? "" : "s"} of ${term}` +
+        (windowDays ? ` in the last ${windowDays} days` : "") +
+        `, newest first. Each point is one sweep: \`found\` is everything it saw, \`reported\` is ` +
+        "the subset that was new, and `perPlatform` splits both by network.");
+    if (n < 3) {
+        lines.push("", `Two points are not a trend, and ${n} ${n === 1 ? "is" : "are"} what you have. Report what ` +
+            "the runs found and say the series is too short to call a direction — the difference " +
+            "between two sweeps of scraped data is mostly the scrape.");
+    }
+    else {
+        lines.push("", "Read it yourself: the shape of `found` over time is the volume question, and `perPlatform` " +
+            "is the one underneath it — a total that holds steady while one network doubles and " +
+            "another empties is the finding, and the total hides it.", "", 
+        // Stated rather than left to be derived, because deriving it means
+        // knowing which end of the array is which — and `runs` is newest-first.
+        // Reading it by hand got the direction exactly backwards on the first
+        // attempt ("TikTok fell from 5 to 12"), which is a mistake a model makes
+        // just as easily and reports with the same confidence.
+        perPlatformDirection(runs), "", "`found` and `reported` are different questions and usually move differently. Flat `found` " +
+            "with falling `reported` is a conversation that has stopped moving rather than stopped. A " +
+            "spike in `found` that is almost all already-seen is one post being re-surfaced by a " +
+            "platform, not new interest.");
+    }
+    if (kind === "competitor") {
+        const newest = num(sc.medianViews?.newest);
+        const oldest = num(sc.medianViews?.oldest);
+        lines.push("", "This is a competitor watch, so each point carries `medianViews` — the baseline that run " +
+            "measured. That is the second axis: a creator can beat their own median every week while " +
+            "the median itself is falling, which is a shrinking account having good weeks." +
+            (newest !== null && oldest !== null
+                ? ` Here it went from ${oldest.toLocaleString("en-US")} to ${newest.toLocaleString("en-US")}.`
+                : ""));
+    }
+    const retained = num(sc.retainedDays);
+    const created = typeof sc.watchCreatedAt === "string" ? sc.watchCreatedAt : null;
+    lines.push("", "Do not read the left edge as the start of anything." +
+        (retained ? ` Runs are kept for ${retained} days.` : "") +
+        (created ? ` This watch was created ${created.slice(0, 10)}.` : "") +
+        " A series that starts flat starts where the record does, which is not the same as a " +
+        "period when nobody was talking.");
+    const recurring = Array.isArray(sc.recurring) ? sc.recurring : [];
+    if (recurring.length) {
+        lines.push("", `\`recurring\` lists the ${recurring.length} mention${recurring.length === 1 ? "" : "s"} more ` +
+            "than one run has seen, with how many runs saw each. These are fingerprints, not text: " +
+            "the mentions themselves are other people's writing and are deliberately not stored. A " +
+            "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.");
+    return lines.join("\n");
+}
 function toResult(proxy) {
     const textBlock = proxy.contentBlocks.find((c) => c.type === "text");
     return {
@@ -274,6 +402,70 @@ export function registerBrandWatch(server, makeClient) {
             return failed("list_brand_watches failed", err);
         }
     });
+    server.registerTool("mention_trend", {
+        title: "Mention Trend",
+        _meta: viewMeta("mention_trend"),
+        description: "What a watch has SEEN OVER TIME, which no other tool here can answer — every read on " +
+            "this surface answers about now, and until the backend started keeping run history each " +
+            "sweep threw its numbers away. Takes `watchId` (or `term`) and an optional `days`. " +
+            "Returns one point per run: when it ran, how many mentions it found, how many were new, " +
+            "and both counts per network — so \"which network is growing\" and \"did it go quiet, or " +
+            "did we stop looking\" are separable. On a competitor watch each point also carries the " +
+            "median that run measured, which is what turns \"they beat their own median\" into \"and " +
+            "that median has doubled\". Also returns the mentions more than one run has seen. " +
+            "FREE: the sweeps were billed when they ran, and charging again to read what was already " +
+            "paid for is the thing this fixes. " +
+            "Read the series yourself and say what changed — this returns numbers, not a verdict.",
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        inputSchema: z
+            .object({
+            watchId: z.string().optional().describe("The watch id from list_brand_watches."),
+            term: z
+                .string()
+                .optional()
+                .describe("The watched term, if you do not have the id. One of the two is required."),
+            days: z
+                .number()
+                .int()
+                .optional()
+                .describe("Window in days (default 90). Clamped to how long the backend keeps runs, which " +
+                "comes back as `retainedDays` — asking for more silently returns less, and a " +
+                "flat start would read as silence rather than as the edge of the record."),
+        })
+            .strict(),
+        outputSchema: OUTPUT_SCHEMAS.mention_trend,
+    }, async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        if (!args.watchId && !args.term?.trim()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "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.",
+                    },
+                ],
+                structuredContent: { available: false, billable: false, mcpCredits: { cost: 0 } },
+            };
+        }
+        try {
+            const proxy = await client.callTool("brand_watch_history", { ...args });
+            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
+            // model reading two points as a trend, and reading the start of the
+            // retention window as the moment a conversation began.
+            return {
+                ...result,
+                content: [{ type: "text", text: trendGuidance(sc, runs) }],
+            };
+        }
+        catch (err) {
+            return failed("mention_trend failed", err);
+        }
+    });
     server.registerTool("stop_brand_watch", {
         title: "Stop Brand Watch",
         description: "Stop a scheduled brand-monitoring watch, by watchId or by term. Takes effect immediately: " +

package/dist/shared/jobs.js

@@ -57,9 +57,10 @@ import { z } from "zod";
 import { OUTPUT_SCHEMAS } from "./output-schemas.js";
 import { platformFromUrl, postSlug } from "./comment-review.js";
 import { clamp, handleMissGuidance, ownIt, PLATFORM_ARG } from "./evidence.js";
-import { confirmSpend, costOf, declinedResult, MAX_SPOKEN_HANDLE_CALLS, MAX_SPOKEN_TRANSCRIPTS, SPOKEN_PLATFORMS, } from "./spend.js";
+import { confirmSpend, costOf, declinedResult, MAX_SPOKEN_HANDLE_CALLS, MAX_SPOKEN_TRANSCRIPTS, SPOKEN_PLATFORMS, CREDITS_PER_CREATOR, } from "./spend.js";
 import { distributionOf, excluding, numberOf, standing, } from "./performance.js";
 import { normaliseHandle, watchEntryId, watchlistOwner } from "./watchlist.js";
+import { creatorStanding, standingsGuidance, THIN_WINDOW, ABOVE_RATIO, } from "./standings.js";
 import { viewMeta } from "./view-meta.js";
 import { extractLinks, COLLAB_RUBRIC, vettingGuidance } from "./collab.js";
 const rowsOf = (value) => Array.isArray(value) ? value.filter((r) => r && typeof r === "object") : [];
@@ -964,6 +965,185 @@ export function registerJobTools(server, makeClient, store) {
         });
     });
     // ───────────────────────────────────────────────────────────────────────────
+    // 2b. compare_creators / watchlist_standings
+    //
+    // The comparison track_competitor computes and discards. Both are pure
+    // compositions of get_user_posts — one fetch per creator, priced as the sum
+    // — and both leave the reading to the caller, because a ranking hides the
+    // window size that decides whether the ranking means anything.
+    // ───────────────────────────────────────────────────────────────────────────
+    /** One creator's window, fetched and scored. Shared by both tools below. */
+    const standingFor = async (client, spend, handle, platform, metric, cap) => {
+        try {
+            const res = await client.callTool("get_user_posts", { username: handle, platform, limit: cap });
+            const structured = structuredOf(res);
+            spend.record("get_user_posts", structured);
+            const posts = rowsOf(structured.posts).map((p, i) => ({
+                ...p,
+                postId: postIdOf(p, i),
+                postedAt: postDate(p),
+            }));
+            return creatorStanding(handle, platform, posts, metric, (post) => metricOf(post, metric));
+        }
+        catch (err) {
+            // One creator failing must not lose the others: a comparison of three is
+            // still worth reading, and saying which one is missing is the honest
+            // version of an answer with a hole in it.
+            spend.attempted("get_user_posts");
+            return {
+                handle,
+                platform,
+                window: 0,
+                baseline: null,
+                hitRate: null,
+                medianWinRatio: null,
+                ratios: [],
+                best: null,
+                worst: null,
+                unavailable: reason(err),
+            };
+        }
+    };
+    server.registerTool("compare_creators", {
+        title: "Compare Creators",
+        _meta: viewMeta("compare_creators"),
+        description: "Two to five creators side by side, each scored against THEIR OWN recent median rather " +
+            "than against each other's raw numbers — which is the only way the comparison means " +
+            "anything, because a raw view count mostly measures follower count. Returns per creator: " +
+            "how many posts were scored, their own median, the share of the window that beat it, how " +
+            "hard they beat it when they did, every post's ratio, and their best and worst post. The " +
+            "ranking is yours to make: 'how often' and 'how big' usually disagree, and a hit rate " +
+            "over a short window is one post either way, so the window size travels with every " +
+            "number. Fetches one post list per creator: 2 nooticr credits each, 4-10 in total. " +
+            "Use for 'is their hit rate better than mine'; track_competitor is one creator alone.",
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        outputSchema: OUTPUT_SCHEMAS.compare_creators,
+        inputSchema: z
+            .object({
+            usernames: z
+                .array(z.string())
+                .min(2)
+                .max(5)
+                .describe("2-5 creator handles, with or without @. Include your own to benchmark against " +
+                "them. These are handles, not brand names — resolve a company name first."),
+            platform: z.string().optional().describe(PLATFORM_ARG),
+            limit: z
+                .number()
+                .int()
+                .optional()
+                .describe("Posts per creator (default 12, max 30). One fetch each either way."),
+            metric: metricArg,
+        })
+            .strict(),
+    }, async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        const platform = (args.platform || "tiktok").toLowerCase();
+        const cap = clamp(args.limit, 12, 1, 30);
+        const metric = args.metric ?? "views";
+        // Deduped, because comparing a creator against themselves is two paid
+        // fetches for one column.
+        const handles = [...new Set(args.usernames.map(normaliseHandle))].filter(Boolean);
+        if (handles.length < 2) {
+            return evidence("A comparison needs two different creators. After removing duplicates only " +
+                `${handles.length} handle${handles.length === 1 ? "" : "s"} remained, so nothing was ` +
+                "fetched and nothing was charged.", { tool: "compare_creators", creators: [], billable: false, mcpCredits: { cost: 0 } });
+        }
+        const credits = costOf(handles.map(() => "get_user_posts"));
+        const decision = await confirmSpend(server.server, {
+            credits,
+            summary: `Read the recent posts of ${handles.map((h) => "@" + h).join(", ")} on ${platform}.`,
+            cheaper: "Compare fewer creators — each one is a separate fetch.",
+        });
+        if (!decision.proceed) {
+            return declinedResult(credits, "That comparison", "Compare fewer creators.");
+        }
+        const spend = new Spend();
+        const rows = [];
+        for (const handle of handles) {
+            rows.push(await standingFor(client, spend, handle, platform, metric, cap));
+        }
+        return evidence(standingsGuidance({ rows, metric, source: "handles" }) + "\n\n" + ownIt, {
+            mode: "evidence",
+            tool: "compare_creators",
+            evidenceFrom: ["get_user_posts"],
+            platform,
+            platformDefaulted: !args.platform,
+            metric,
+            thinWindow: THIN_WINDOW,
+            aboveRatio: ABOVE_RATIO,
+            creators: rows,
+            creditsCharged: spend.credits,
+            mcpCredits: spend.payload,
+        });
+    });
+    server.registerTool("watchlist_standings", {
+        title: "Watchlist Standings",
+        _meta: viewMeta("watchlist_standings"),
+        description: "The same comparison across everyone on your watchlist, answering 'who moved' in one " +
+            "call instead of one per creator. Each is scored against their own recent median, so the " +
+            "numbers are comparable between accounts of different sizes; the window size travels " +
+            "with each so a short one is not ranked as if it were a season. Reads the watchlist " +
+            "itself for free and fetches one post list per creator on it: 2 nooticr credits each, so " +
+            "the price is the size of your watchlist — it confirms before spending. Use for the " +
+            "weekly 'who is accelerating'; catch_up_watchlist is what is NEW rather than how it did.",
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        outputSchema: OUTPUT_SCHEMAS.watchlist_standings,
+        inputSchema: z
+            .object({
+            limit: z
+                .number()
+                .int()
+                .optional()
+                .describe("Posts per creator (default 12, max 30). One fetch each either way."),
+            metric: metricArg,
+        })
+            .strict(),
+    }, async (args, extra) => {
+        const client = await makeClient({ ...extra, arguments: args });
+        const cap = clamp(args.limit, 12, 1, 30);
+        const metric = args.metric ?? "views";
+        let entries = [];
+        try {
+            entries = await store.list(await watchlistOwner(client));
+        }
+        catch (err) {
+            return failed("watchlist_standings could not read your watchlist", err);
+        }
+        if (!entries.length) {
+            // Not an error and not billed: an empty watchlist is a state with a
+            // next step, and saying so beats a comparison of nobody.
+            return evidence("Your watchlist is empty, so there is nobody to compare. Add creators with " +
+                "watch_creator first — the standings are then one call. Nothing was charged.", { tool: "watchlist_standings", watching: 0, creators: [], billable: false, mcpCredits: { cost: 0 } });
+        }
+        const credits = entries.length * CREDITS_PER_CREATOR;
+        const decision = await confirmSpend(server.server, {
+            credits,
+            summary: `Read the recent posts of all ${entries.length} creator${entries.length === 1 ? "" : "s"} ` +
+                "on your watchlist and score each against their own median.",
+            cheaper: "Unwatch creators you no longer follow, or use track_competitor for just one.",
+        });
+        if (!decision.proceed) {
+            return declinedResult(credits, "Those standings", "Use track_competitor for a single creator.");
+        }
+        const spend = new Spend();
+        const rows = [];
+        for (const entry of entries) {
+            rows.push(await standingFor(client, spend, entry.handle, entry.platform, metric, cap));
+        }
+        return evidence(standingsGuidance({ rows, metric, source: "watchlist" }) + "\n\n" + ownIt, {
+            mode: "evidence",
+            tool: "watchlist_standings",
+            evidenceFrom: ["get_user_posts"],
+            metric,
+            watching: entries.length,
+            thinWindow: THIN_WINDOW,
+            aboveRatio: ABOVE_RATIO,
+            creators: rows,
+            creditsCharged: spend.credits,
+            mcpCredits: spend.payload,
+        });
+    });
+    // ───────────────────────────────────────────────────────────────────────────
     // 3. who_should_i_work_with
     // ───────────────────────────────────────────────────────────────────────────
     server.registerTool("who_should_i_work_with", {

package/dist/shared/loading-plans.js

@@ -249,6 +249,24 @@ export const LOADING_PLANS = {
         n: 3,
         steps: [step("get_user_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: {
+        label: "Scoring each against their own median",
+        kind: "list",
+        n: 3,
+        steps: [],
+        perUnit: [CREATOR_UNIT],
+        note: "Priced per creator compared.",
+    },
+    watchlist_standings: {
+        label: "Reading the whole watchlist",
+        kind: "list",
+        n: 5,
+        steps: [],
+        perUnit: [CREATOR_UNIT],
+        note: "Priced per creator on the watchlist.",
+    },
     who_should_i_work_with: {
         label: "Building a shortlist",
         kind: "list",
@@ -299,6 +317,11 @@ export const LOADING_PLANS = {
     show_variants: { label: "Laying out the variants", kind: "list", n: 4, steps: [], free: true },
     show_repurposed_post: { label: "Laying out the rewrites", kind: "text", n: 1, steps: [], free: true },
     show_collab_shortlist: { label: "Drawing the shortlist", kind: "list", n: 5, steps: [], free: true },
+    show_standings: { label: "Drawing the standings", kind: "list", n: 4, steps: [], free: true },
+    show_trend: { label: "Drawing the trend", kind: "text", n: 1, steps: [], free: true },
+    // Reads stored aggregates the sweeps already paid for. Free, and no
+    // upstream step to wait on — the wait is a database read.
+    mention_trend: { label: "Reading the run history", kind: "text", n: 1, steps: [], free: true },
     prepare_handoff: { label: "Packaging the handoff", kind: "list", n: 4, steps: [], free: true },
     // ─── Own-account reads: nooticr's own stored rows ───
     get_scheduled_posts: { label: "Reading your pipeline", kind: "list", n: 5, steps: [], free: true },

package/dist/shared/output-schemas.js

@@ -726,6 +726,84 @@ export const OUTPUT_SCHEMAS = {
         days: scalar(),
         mcpCredits,
     }),
+    /**
+     * One row per creator, on the axis every creator shares. `window` sits
+     * beside every derived number on purpose — a hit rate whose denominator is
+     * invisible cannot be told apart from a hit rate that means something.
+     */
+    compare_creators: open({
+        creators: listOf(open({
+            handle: scalar(),
+            platform: scalar(),
+            window: scalar().describe("Posts scored — the denominator of hitRate and the baseline."),
+            baseline: open({
+                count: scalar(),
+                median: scalar(),
+                min: scalar(),
+                max: scalar(),
+                p25: scalar(),
+                p75: scalar(),
+            }).nullish(),
+            hitRate: scalar().describe("Share of the window at or above aboveRatio x their own median."),
+            medianWinRatio: scalar().describe("How hard they beat their median when they did."),
+            ratios: listOf(z.number()).describe("Every post's ratio to their own median, ascending."),
+            best: post.nullish(),
+            worst: post.nullish(),
+            unavailable: scalar().describe("Set when this creator could not be scored, and why."),
+        })).optional(),
+        platform: scalar(),
+        platformDefaulted: scalar(),
+        metric: scalar(),
+        thinWindow: scalar().describe("Below this many posts, a hit rate is one post either way."),
+        aboveRatio: scalar().describe("The ratio hitRate counts from."),
+        billable: scalar(),
+        mode: scalar(),
+        tool: scalar(),
+        evidenceFrom: listOf(z.string()),
+        creditsCharged: scalar(),
+        mcpCredits,
+    }),
+    show_standings: open({
+        creators: listOf(anyObject()),
+        metric: scalar(),
+        ranking: scalar().describe("Which axis the order is on — 'how often' and 'how big' disagree."),
+        verdict: scalar(),
+        tooThin: listOf(z.string()).describe("Handles drawn unranked rather than bottom."),
+        // The discriminator the view keys on, since `creators` alone is ambiguous
+        // with the two fetching tools' payloads.
+        standings: scalar(),
+    }),
+    watchlist_standings: open({
+        creators: listOf(open({
+            handle: scalar(),
+            platform: scalar(),
+            window: scalar(),
+            baseline: open({
+                count: scalar(),
+                median: scalar(),
+                min: scalar(),
+                max: scalar(),
+                p25: scalar(),
+                p75: scalar(),
+            }).nullish(),
+            hitRate: scalar(),
+            medianWinRatio: scalar(),
+            ratios: listOf(z.number()),
+            best: post.nullish(),
+            worst: post.nullish(),
+            unavailable: scalar(),
+        })).optional(),
+        watching: scalar().describe("How many creators are on the watchlist."),
+        metric: scalar(),
+        thinWindow: scalar(),
+        aboveRatio: scalar(),
+        billable: scalar(),
+        mode: scalar(),
+        tool: scalar(),
+        evidenceFrom: listOf(z.string()),
+        creditsCharged: scalar(),
+        mcpCredits,
+    }),
     discover_sounds: open({
         sounds: listOf(open({
             title: scalar(),
@@ -842,6 +920,55 @@ export const OUTPUT_SCHEMAS = {
         firstRun: scalar(),
         message: scalar(),
     }),
+    /**
+     * A run series. `runs` is newest first, and every derived number the caller
+     * might want is left underived on purpose — the model reads the series.
+     */
+    show_trend: open({
+        points: listOf(anyObject()),
+        term: scalar(),
+        metric: scalar(),
+        verdict: scalar(),
+        // Both caveats are fields rather than prose, so the view can draw them
+        // and cannot quietly omit them.
+        tooShort: scalar().describe("Too few points to call a direction."),
+        edgeIsRecordStart: scalar().describe("The left edge is the record's start, not the conversation's."),
+        trend: scalar().describe("The discriminator the view keys on."),
+    }),
+    mention_trend: open({
+        runs: listOf(open({
+            ranAt: scalar(),
+            found: scalar().describe("Everything that sweep saw."),
+            reported: scalar().describe("The subset that was new — a different question from found."),
+            perPlatform: anyObject().nullish().describe('{"tiktok":{"found":12,"reported":3},...}'),
+            medianViews: scalar().describe("Competitor watches only: the baseline that run measured."),
+            postsScored: scalar(),
+            costCredits: scalar(),
+        })).optional(),
+        watchId: scalar(),
+        kind: scalar(),
+        term: scalar(),
+        competitorHandle: scalar(),
+        platforms: listOf(z.string()),
+        windowDays: scalar(),
+        // Two numbers a caller cannot derive and will otherwise assume: how long
+        // anything is kept, and how long the watch has existed. A flat left edge
+        // is one of those, not a quiet period.
+        retainedDays: scalar(),
+        watchCreatedAt: scalar(),
+        runCount: scalar(),
+        found: anyObject().nullish().describe("newest and oldest in the window, so direction needs no array maths."),
+        medianViews: anyObject().nullish(),
+        recurring: listOf(open({
+            mentionKey: scalar().describe("A fingerprint. The text is deliberately not stored."),
+            timesSeen: scalar(),
+            firstReportedAt: scalar(),
+            lastSeenAt: scalar(),
+        })),
+        available: scalar(),
+        billable: scalar(),
+        mcpCredits,
+    }),
     list_brand_watches: open({
         watches: listOf(open({
             watchId: scalar(),

package/dist/shared/standings.js

@@ -0,0 +1,143 @@
+/**
+ * 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
+ * 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.
+ *
+ * Both were right, and both then discarded the comparison. A ratio to one's
+ * own median is *exactly* the quantity that IS comparable across creators of
+ * different sizes — a 300k-follower account beating its median by 2.1× and a
+ * 4k-follower account doing the same are the same event — and no tool ever
+ * placed two of them next to each other. So "is their hit rate better than
+ * mine?" was unanswerable at any price, while every ingredient was computed on
+ * every call and thrown away.
+ *
+ * The comparison itself stays the model's job, as everywhere else here. This
+ * module normalises each creator to the same axis and reports how much window
+ * it had to do it with; ranking them server-side would hide exactly the thing
+ * that decides whether a ranking means anything.
+ */
+import { ABOVE_RATIO, BREAKOUT_RATIO, distributionOf, MIN_BASELINE_POSTS, numberOf, standing, } from "./performance.js";
+/** Median of an already-sorted list. */
+function mid(sorted) {
+    if (!sorted.length)
+        return null;
+    const i = Math.floor(sorted.length / 2);
+    return sorted.length % 2 ? sorted[i] : (sorted[i - 1] + sorted[i]) / 2;
+}
+const round2 = (n) => Math.round(n * 100) / 100;
+/**
+ * One creator, reduced to the axis every creator shares.
+ *
+ * `hitRate` is a share of a window and not a rate — over six posts it is one
+ * post either way — which is why `window` travels beside it everywhere rather
+ * than being folded into a score. A caller that cannot see the denominator
+ * cannot know the number is noise, and the guidance below leans on it.
+ */
+export function creatorStanding(handle, platform, posts, metric, pick) {
+    const values = posts.map(pick);
+    const baseline = distributionOf(values);
+    const empty = {
+        handle,
+        platform,
+        window: posts.length,
+        baseline,
+        hitRate: null,
+        medianWinRatio: null,
+        ratios: [],
+        best: null,
+        worst: null,
+    };
+    if (!posts.length) {
+        return { ...empty, unavailable: "no posts came back for this handle" };
+    }
+    if (!baseline) {
+        // Fewer than MIN_BASELINE_POSTS is not a baseline, and inventing one would
+        // put a confident ratio on an account nobody has enough of. The same
+        // refusal `distributionOf` already makes for a single post.
+        return {
+            ...empty,
+            unavailable: `only ${posts.length} post${posts.length === 1 ? "" : "s"} in the window — ` +
+                `${MIN_BASELINE_POSTS} is the fewest that make a baseline`,
+        };
+    }
+    const scored = posts.map((post) => ({ post, standing: standing(pick(post), values) }));
+    const ratios = scored.map((s) => numberOf(s.standing.ratio)).filter((r) => Number.isFinite(r));
+    const winners = ratios.filter((r) => r >= ABOVE_RATIO);
+    const byRatio = [...scored].sort((a, b) => numberOf(b.standing.ratio) - numberOf(a.standing.ratio));
+    return {
+        handle,
+        platform,
+        window: posts.length,
+        baseline,
+        hitRate: round2(winners.length / posts.length),
+        medianWinRatio: winners.length ? round2(mid([...winners].sort((a, b) => a - b)) ?? 0) : null,
+        ratios: [...ratios].sort((a, b) => a - b).map(round2),
+        best: { ...byRatio[0].post, standing: byRatio[0].standing, metric },
+        worst: { ...byRatio[byRatio.length - 1].post, standing: byRatio[byRatio.length - 1].standing, metric },
+        unavailable: null,
+    };
+}
+/**
+ * The window below which a hit rate should not be quoted as one.
+ *
+ * Not a hard floor — the row is still returned, because "we only have 5 posts"
+ * is itself the answer to "who is accelerating?" and hiding it would leave the
+ * model guessing. It is the number the guidance names so the model says "too
+ * few posts to call this" instead of ranking confidently, the same discipline
+ * `find_hook_pattern` applies with "a template that fits one post is not a
+ * pattern".
+ */
+export const THIN_WINDOW = 8;
+/**
+ * What to do with a set of standings.
+ *
+ * Written to be read by the model that just received them, in the voice
+ * `evidence.ts` sets: say what the material is, what is comparable about it,
+ * and what would be a mistake to conclude.
+ */
+export function standingsGuidance(a) {
+    const scored = a.rows.filter((r) => !r.unavailable);
+    const thin = scored.filter((r) => r.window < THIN_WINDOW);
+    const lines = [];
+    lines.push(`${a.rows.length} creator${a.rows.length === 1 ? "" : "s"}` +
+        (a.source === "watchlist" ? " from your watchlist" : "") +
+        `, each scored against their OWN recent median ${a.metric} — never against each other's raw ` +
+        "numbers, because a raw count mostly measures follower count. The ratio is what compares: " +
+        "a large account beating its median by 2× and a small one doing the same have done the same " +
+        "thing.");
+    if (!scored.length) {
+        lines.push("", "None of them could be scored — see `unavailable` on each row. That is a gap in what came " +
+            "back, not a finding about the creators, so say which ones and why rather than reporting " +
+            "an empty comparison.");
+        return lines.join("\n");
+    }
+    lines.push("", "Per creator: `window` is how many posts were scored, `baseline.median` is the middle of " +
+        `their own window, \`hitRate\` is the share of it at or above ${ABOVE_RATIO}× that median, ` +
+        "`medianWinRatio` is how hard they beat it when they did, and `ratios` is every post's " +
+        "ratio ascending so the spread is visible. `best` and `worst` carry the posts themselves.", "", "Two different questions live in those numbers and they usually disagree: how OFTEN someone " +
+        "lands one (`hitRate`) and how BIG it is when they do (`medianWinRatio`). A creator with a " +
+        "low hit rate and a high win ratio is swinging; the reverse is consistent and capped. Say " +
+        "which of the two you are ranking on, because 'who is doing better' has no single answer.");
+    if (thin.length) {
+        lines.push("", `Do not rank ${thin.map((r) => `@${r.handle} (${r.window} posts)`).join(", ")} confidently. ` +
+            `A hit rate over fewer than ${THIN_WINDOW} posts is one post either way, and a median over ` +
+            "a window that small moves with the window. Say the sample is too thin to call rather " +
+            "than putting them in an order.");
+    }
+    const unavailable = a.rows.filter((r) => r.unavailable);
+    if (unavailable.length) {
+        lines.push("", `Not scored: ${unavailable.map((r) => `@${r.handle} — ${r.unavailable}`).join("; ")}. ` +
+            "Missing from the comparison is not the same as bottom of it.");
+    }
+    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.");
+    return lines.join("\n");
+}
+/** Threshold re-exported so the tools and the view agree on the badge. */
+export { ABOVE_RATIO, BREAKOUT_RATIO };

package/dist/shared/tools-def.js

@@ -228,6 +228,18 @@ export const TOOL_DEFINITIONS = [
         description: "Every scheduled brand-monitoring watch this user has: term, networks, cadence, cost per run, credits spent so far, runs made, next run due, and whether it is stopped and why. Read before creating a watch — a second watch on the same term is a second recurring charge for the same answer. No cost to call.",
         inputSchema: z.object({}).strict(),
     },
+    {
+        name: "mention_trend",
+        title: "Mention Trend",
+        description: "What a watch has SEEN OVER TIME, which no other tool here can answer — every read on this surface answers about now, and until the backend started keeping run history each sweep threw its numbers away. Takes `watchId` (or `term`) and an optional `days`. Returns one point per run: when it ran, how many mentions it found, how many were new, and both counts per network. On a competitor watch each point also carries the median that run measured. Also returns the mentions more than one run has seen. FREE: the sweeps were billed when they ran. Read the series yourself and say what changed.",
+        inputSchema: z.object({ watchId: z.string().optional(), term: z.string().optional(), days: z.number().int().optional() }).strict(),
+    },
+    {
+        name: "show_trend",
+        title: "Show Trend",
+        description: "Draw the trend you read out of mention_trend. Free, and makes no requests — it renders what you pass it: the series as a chart, per-network lines where you supply them, and your own read of what changed. Pass `tooShort` when the series has too few points to call a direction, and `edgeIsRecordStart` when the left edge is where the record begins rather than where the conversation did. Call this after you have decided what the numbers mean.",
+        inputSchema: z.object({ points: z.array(z.object({}).passthrough()).min(1).max(400), term: z.string().optional(), metric: z.string().optional(), verdict: z.string().optional(), tooShort: z.boolean().optional(), edgeIsRecordStart: z.boolean().optional() }).strict(),
+    },
     {
         name: "stop_brand_watch",
         title: "Stop Brand Watch",
@@ -342,6 +354,24 @@ export const TOOL_DEFINITIONS = [
         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.",
         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.",
+        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(),
+    },
+    {
+        name: "watchlist_standings",
+        title: "Watchlist Standings",
+        description: "The same comparison across everyone on your watchlist, answering 'who moved' in one call instead of one per creator. Each is scored against their own recent median, so the numbers are comparable between accounts of different sizes; the window size travels with each so a short one is not ranked as if it were a season. Reads the watchlist itself for free and fetches one post list per creator on it: 2 nooticr credits each, so the price is the size of your watchlist — it confirms before spending. Use for the weekly 'who is accelerating'; catch_up_watchlist is what is NEW rather than how it did.",
+        inputSchema: z.object({ limit: z.number().int().optional(), metric: z.string().optional() }).strict(),
+    },
+    {
+        name: "show_standings",
+        title: "Show Standings",
+        description: "Draw the standings you read out of compare_creators or watchlist_standings. Free, and makes no requests — it only renders what you pass it: one row per creator with their window, their own median, how often they beat it and how hard, and the post that did best. Pass `ranking` to say which axis you ordered on, and `tooThin` for the creators whose window was too short to rank — a table that hides that is the one mistake this view can make on your behalf. Call this after you have decided what the numbers mean, not instead of deciding.",
+        inputSchema: z.object({ creators: z.array(z.object({}).passthrough()).min(1).max(25), metric: z.string().optional(), ranking: z.string().optional(), verdict: z.string().optional(), tooThin: z.array(z.string()).optional() }).strict(),
+    },
     {
         name: "who_should_i_work_with",
         title: "Who Should I Work With",

package/dist/shared/tools.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.26";
+export const MCP_SERVER_VERSION = "1.26.28";
 /** MCP Apps extension identifier */
 const UI_EXTENSION = "io.modelcontextprotocol/ui";
 /** MIME type for MCP Apps HTML resources */
@@ -507,6 +507,9 @@ export function createMcpServer(rawMakeClient, opts) {
         // state tools have nothing to show and stay view-less, like nooticr_login.
         "catch_up_watchlist",
         "search_mentions",
+        // The series a watch keeps, and the free view for the read of it.
+        "mention_trend",
+        "show_trend",
         "show_comment_review",
         // Close the loop the evidence-only tools open: your own analysis/hooks/
         // variants/repurposing/comparison, drawn — same shape as
@@ -523,6 +526,11 @@ export function createMcpServer(rawMakeClient, opts) {
         "answer_my_audience",
         "show_audience_replies",
         "track_competitor",
+        // The comparison track_competitor 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",
+        "show_standings",
         "who_should_i_work_with",
         "why_did_this_underperform",
         "what_should_i_make_next",
@@ -1353,6 +1361,124 @@ export function createMcpServer(rawMakeClient, opts) {
     // ui-template.ts already renders (show_comparison → the comparison
     // scoreboard, show_analysis → analysisCard) or a new one added alongside
     // it (show_hooks, show_variants, show_repurposed_post).
+    server.registerTool("show_trend", {
+        title: "Show Trend",
+        description: "Draw the trend you read out of mention_trend. Free, and makes no requests — it renders what " +
+            "you pass it: the series as a chart, per-network lines where you supply them, and your own " +
+            "read of what changed. Pass `tooShort` when the series has too few points to call a " +
+            "direction, and `edgeIsRecordStart` when the left edge is where the record begins rather " +
+            "than where the conversation did — a chart that hides either is the one mistake this view " +
+            "can make on your behalf. Call this after you have decided what the numbers mean.",
+        _meta: {
+            ui: { resourceUri: uiResource("show_trend") },
+            "ui/resourceUri": uiResource("show_trend"),
+            "openai/outputTemplate": appsSdkResource("show_trend"),
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        outputSchema: OUTPUT_SCHEMAS.show_trend,
+        inputSchema: z
+            .object({
+            points: z
+                .array(anyObject())
+                .min(1)
+                .max(400)
+                .describe("The series, oldest first or newest first as you like — the same shape mention_trend " +
+                "returned (ranAt, found, reported, perPlatform, medianViews)."),
+            term: z.string().optional().describe("What is being watched."),
+            metric: z
+                .string()
+                .optional()
+                .describe('Which number the chart plots: "found" (default), "reported" or "medianViews".'),
+            verdict: z.string().optional().describe("Your read of what changed, in a sentence or two."),
+            tooShort: z
+                .boolean()
+                .optional()
+                .describe("True when there are too few points to call a direction. Drawn as a stated caveat rather " +
+                "than a trend line, because two points of scraped data are mostly the scrape."),
+            edgeIsRecordStart: z
+                .boolean()
+                .optional()
+                .describe("True when the earliest point is the start of the kept record or the watch's own age, " +
+                "not the start of the conversation. Marks the left edge so a flat start is not read as " +
+                "silence."),
+        })
+            .strict(),
+    }, async (args) => {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Showing a ${args.points.length}-point trend${args.term ? ` for "${args.term}"` : ""}.` +
+                        (args.verdict ? ` ${args.verdict}` : ""),
+                },
+            ],
+            structuredContent: {
+                points: args.points,
+                term: args.term ?? null,
+                metric: args.metric ?? "found",
+                verdict: args.verdict ?? null,
+                tooShort: args.tooShort ?? false,
+                edgeIsRecordStart: args.edgeIsRecordStart ?? false,
+                trend: true,
+            },
+        };
+    });
+    server.registerTool("show_standings", {
+        title: "Show Standings",
+        description: "Draw the standings you read out of compare_creators or watchlist_standings. Free, and makes " +
+            "no requests — it only renders what you pass it: one row per creator with their window, their " +
+            "own median, how often they beat it and how hard, and the post that did best. Pass `ranking` " +
+            "to say which axis you ordered on, and `tooThin` for the creators whose window was too short " +
+            "to rank — a table that hides that is the one mistake this view can make on your behalf. " +
+            "Call this after you have decided what the numbers mean, not instead of deciding.",
+        _meta: {
+            ui: { resourceUri: uiResource("show_standings") },
+            "ui/resourceUri": uiResource("show_standings"),
+            "openai/outputTemplate": appsSdkResource("show_standings"),
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        outputSchema: OUTPUT_SCHEMAS.show_standings,
+        inputSchema: z
+            .object({
+            creators: z
+                .array(anyObject())
+                .min(1)
+                .max(25)
+                .describe("The creator rows, in the order you decided on — the same shape compare_creators returned " +
+                "(handle, platform, window, baseline, hitRate, medianWinRatio, best, ...)."),
+            metric: z.string().optional().describe("Which stat the standings are on (views, likes, ...)."),
+            ranking: z
+                .string()
+                .optional()
+                .describe('What you ordered on and why — "how often they land one" and "how big it is when they do" ' +
+                "usually disagree, so the reader needs to know which they are looking at."),
+            verdict: z.string().optional().describe("Your read, in a sentence or two."),
+            tooThin: z
+                .array(z.string())
+                .optional()
+                .describe("Handles whose window was too short to rank. Drawn as unranked rather than bottom, " +
+                "because missing from a comparison is not the same as losing it."),
+        })
+            .strict(),
+    }, async (args) => {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Showing standings for ${args.creators.length} creator${args.creators.length === 1 ? "" : "s"}.` +
+                        (args.verdict ? ` ${args.verdict}` : ""),
+                },
+            ],
+            structuredContent: {
+                creators: args.creators,
+                metric: args.metric ?? "views",
+                ranking: args.ranking ?? null,
+                verdict: args.verdict ?? null,
+                tooThin: args.tooThin ?? [],
+                standings: true,
+            },
+        };
+    });
     server.registerTool("show_comparison", {
         title: "Show Comparison",
         description: "Display a comparison you wrote after compare_posts fetched the first post and you fetched " +

package/dist/shared/ui-template.js

@@ -3661,6 +3661,64 @@ export const NOOTICR_UI_TEMPLATE = `<!DOCTYPE html>
     if(d.posts&&Array.isArray(d.posts)){
       if(!d.posts.length){app.innerHTML='<div class="empty-state fade-in"><div class="icon">🔍</div><div class="text">No posts found</div></div>';return;}
       app.innerHTML=galleryWrap(d.posts.map(function(p){return postCard(p,false,true);}).join(""),d.posts.length)+pickBarHtml();initPicks();return;}
+    // Standings: creators on one normalised axis. A table, because the question
+    // is comparative — and every row carries the window it was scored over. A
+    // hit rate whose denominator is invisible cannot be told apart from one
+    // that means something, which is why these numbers were computed per
+    // creator and never put side by side before (issue #30).
+    if(Array.isArray(d.creators)&&(d.standings||d.tool==="compare_creators"||d.tool==="watchlist_standings")){
+      var thin=Array.isArray(d.tooThin)?d.tooThin:[];
+      var floor=typeof d.thinWindow==="number"?d.thinWindow:8;
+      var above=typeof d.aboveRatio==="number"?d.aboveRatio:1.25;
+      var met=esc(d.metric||"views");
+      var rows=d.creators.map(function(c){
+        var un=c.unavailable;
+        // A window shorter than the floor, or one the model flagged, is drawn
+        // unranked. Bottom of a table is a claim; unranked is the truth.
+        var short=!un&&(thin.indexOf(String(c.handle))>=0||(typeof c.window==="number"&&c.window<floor));
+        var med=c.baseline&&c.baseline.median!=null?fmtNum(c.baseline.median):"-";
+        var hit=c.hitRate!=null?Math.round(c.hitRate*100)+"%":"-";
+        var win=c.medianWinRatio!=null?(Math.round(c.medianWinRatio*100)/100)+"x":"-";
+        var best=c.best&&(c.best.title||c.best.caption)?String(c.best.title||c.best.caption):"";
+        return '<tr style="border-top:1px solid var(--border-soft)'+(un?";opacity:.6":"")+'">'
+          +'<td style="padding:9px 10px;font-weight:600;white-space:nowrap">@'+esc(c.handle)
+          +(c.platform?'<span style="font-weight:400;color:var(--muted)"> · '+esc(c.platform)+"</span>":"")
+          +(short?'<span style="margin-left:6px;font-size:10px;font-weight:700;color:var(--warn)">too thin to rank</span>':"")
+          +"</td>"
+          +(un
+            ?'<td colspan="4" style="padding:9px 10px;color:var(--muted);font-size:12.5px">'+esc(String(un))+"</td>"
+            :'<td style="padding:9px 10px;text-align:right;font-variant-numeric:tabular-nums">'+fmtNum(c.window||0)+"</td>"
+              +'<td style="padding:9px 10px;text-align:right;font-variant-numeric:tabular-nums">'+med+"</td>"
+              +'<td style="padding:9px 10px;text-align:right;font-variant-numeric:tabular-nums">'+hit+"</td>"
+              +'<td style="padding:9px 10px;text-align:right;font-variant-numeric:tabular-nums">'+win+"</td>")
+          +"</tr>"
+          +(best&&!un
+            ?'<tr><td colspan="5" style="padding:0 10px 9px 10px;color:var(--muted);font-size:12px">best: '+esc(best.slice(0,120))+"</td></tr>"
+            :"");
+      }).join("");
+      app.innerHTML='<div class="card card-wide fade-in"><div class="card-body">'
+        +'<div style="font-size:16px;font-weight:700">Standings</div>'
+        +'<div class="faint" style="font-size:11.5px;color:var(--muted);margin:2px 0 10px">'
+        +d.creators.length+" creator"+(d.creators.length===1?"":"s")+" · each against their OWN median "+met
+        +(d.watching!=null?" · watchlist of "+fmtNum(d.watching):"")+"</div>"
+        +(d.ranking?'<div style="font-size:12.5px;margin:0 0 8px">Ordered on: '+esc(String(d.ranking))+"</div>":"")
+        +'<div style="overflow-x:auto"><table style="width:100%;border-collapse:collapse;font-size:13px">'
+        +'<thead><tr style="text-align:left;color:var(--muted);font-size:11px;text-transform:uppercase;letter-spacing:.05em">'
+        +'<th style="padding:0 10px 6px">Creator</th>'
+        +'<th style="padding:0 10px 6px;text-align:right">Window</th>'
+        +'<th style="padding:0 10px 6px;text-align:right">Their median</th>'
+        +'<th style="padding:0 10px 6px;text-align:right">Beat it</th>'
+        +'<th style="padding:0 10px 6px;text-align:right">By</th>'
+        +"</tr></thead><tbody>"+rows+"</tbody></table></div>"
+        +(d.verdict?'<div style="font-size:13.5px;line-height:1.6;margin-top:12px">'+esc(String(d.verdict))+"</div>":"")
+        +'<div class="faint" style="font-size:11.5px;color:var(--muted);margin-top:10px;line-height:1.6">'
+        +'"Beat it" is the share of the window at or above '+above+"x that creator's own median. "
+        +"A raw view count mostly measures follower count, so nothing here compares raw numbers. "
+        +"A window under "+floor+" posts is one post either way, and no ratio here says whether a "
+        +"baseline is itself moving — that needs a second point in time."
+        +"</div></div></div>";
+      return;}
+
     // Creators
     if(d.creators&&Array.isArray(d.creators)){
       if(!d.creators.length){app.innerHTML='<div class="empty-state fade-in"><div class="icon">👤</div><div class="text">No creators found</div></div>';return;}
@@ -3689,6 +3747,46 @@ export const NOOTICR_UI_TEMPLATE = `<!DOCTYPE html>
         +"</div></div>";
       return;}
 
+    // A run series. Drawn as bars rather than a line: the points are sweeps on
+    // a cadence, not a continuous signal, and a line between two sweeps
+    // asserts the shape of something nobody measured. Both caveats the tool
+    // computes are drawn — a chart that hides "too few points" or "this is
+    // where the record starts, not where the conversation did" is the view
+    // making a claim the tool refused to (issue #28).
+    if(Array.isArray(d.points)&&(d.trend||d.tool==="mention_trend")){
+      var metric=String(d.metric||"found");
+      var pts=d.points.slice().sort(function(a,b){return String(a.ranAt||"")<String(b.ranAt||"")?-1:1;});
+      var vals=pts.map(function(p){var v=p[metric];return typeof v==="number"?v:0;});
+      var top=Math.max.apply(null,vals.concat([1]));
+      var bars=pts.map(function(p,i){
+        var v=vals[i];
+        var h=Math.max(2,Math.round((v/top)*90));
+        var when=String(p.ranAt||"").slice(0,10);
+        var label=when+" — "+fmtNum(v)+" "+metric+(p.reported!=null?" ("+fmtNum(p.reported)+" new)":"");
+        return '<div style="flex:1;min-width:3px;display:flex;flex-direction:column;justify-content:flex-end;align-items:center;gap:3px" title="'+esc(label)+'">'
+          +'<div style="width:100%;max-width:26px;height:'+h+'px;background:var(--brand);border-radius:3px 3px 0 0;opacity:'+(i===pts.length-1?"1":".62")+'"></div>'
+          +"</div>";
+      }).join("");
+      var first=pts.length?String(pts[0].ranAt||"").slice(0,10):"";
+      var last=pts.length?String(pts[pts.length-1].ranAt||"").slice(0,10):"";
+      app.innerHTML='<div class="card card-wide fade-in"><div class="card-body">'
+        +'<div style="font-size:16px;font-weight:700">'+(d.term?esc(String(d.term)):"Trend")+"</div>"
+        +'<div class="faint" style="font-size:11.5px;color:var(--muted);margin:2px 0 12px">'
+        +pts.length+" run"+(pts.length===1?"":"s")+" · "+esc(metric)+" per sweep</div>"
+        +(d.tooShort
+          ?'<div style="font-size:12.5px;color:var(--warn);font-weight:600;margin-bottom:8px">Too few points to call a direction</div>'
+          :"")
+        +'<div style="display:flex;align-items:flex-end;gap:2px;height:100px;border-bottom:1px solid var(--border)">'+bars+"</div>"
+        +'<div style="display:flex;justify-content:space-between;font-size:11px;color:var(--muted);margin-top:5px">'
+        +"<span>"+esc(first)+(d.edgeIsRecordStart?" · record starts here":"")+"</span><span>"+esc(last)+"</span></div>"
+        +(d.verdict?'<div style="font-size:13.5px;line-height:1.6;margin-top:12px">'+esc(String(d.verdict))+"</div>":"")
+        +'<div class="faint" style="font-size:11.5px;color:var(--muted);margin-top:10px;line-height:1.6">'
+        +"Each bar is one sweep, not a day"
+        +(d.edgeIsRecordStart?" — and the earliest bar is where the kept record begins, not where the conversation did":"")
+        +". A flat run of bars is a conversation that has stopped moving, which is not the same as one that has stopped."
+        +"</div></div></div>";
+      return;}
+
     // Trending hashtags. Two sources with different evidence behind them: the
     // TikTok trend board, which measures direction over time, and a count
     // across one niche sweep, which cannot. The header names which, and a

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nooticr/mcp",
   "mcpName": "com.nooticr/mcp",
-  "version": "1.26.26",
+  "version": "1.26.28",
   "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": {