@witchpot/gmc 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -2,6 +2,66 @@
 
 All notable changes to the Game Market Copilot CLI will be recorded here.
 
+## 0.11.0 - 2026-10-27
+
+- `gmc games follower-history <appid>`: observed Steam follower series (same window flags as `price-history`). MCP: `game_follower_history`.
+- `gmc games events <appid> [--include rank_series]`: Steam event participations with observed ranks and shelves. MCP: `game_steam_events`.
+- The bundled `gmc-analysis` skill 0.17.0 covers both commands, and the
+  optional `positiveReviews` field on `gmc games review-history` points (state
+  a rate as `positiveReviews / totalReviews` when it is present).
+
+- New `gmc games price-history <appid>` and `gmc games screenshot-labels
+  <appid>` commands (NAK-934, Provisional), the same plain-appid shape as
+  `gmc games ai-disclosure`. `price-history` returns the observed Steam
+  storefront price on every observed day (major currency units, with
+  discount, currency and store country) and takes `--range 7d|1m|1y|all`
+  (default `all`) or `--from`/`--to` (`YYYY-MM-DD`, real calendar dates,
+  `--from` on or before `--to`), never both; a bad window is a usage error
+  before any request. Days without an observation
+  are absent, never filled, and a price never implies sales.
+  `screenshot-labels` returns one set of visual labels per Steam store
+  screenshot and takes no flags. The labels are model output, not Steam
+  data. `docs/cli-use-cases.md` and `docs/agent-usage.md` cover both.
+
+- Not shipped here: the bundled `gmc-analysis` skill does not mention the
+  two new commands yet. It is a separately versioned artifact with its own
+  manifest gate, so its coverage follows in its own change.
+
+- New `gmc roblox saved | save | remove` commands (NAK-723, Provisional),
+  mapping the saved-experiences surface 0.10.0 recorded as "not yet
+  mapped". `gmc roblox saved --json` lists the workspace's saved
+  experiences resolved for one chart, country and cutoff (`--country`,
+  `--device`, `--sort`, `--as-of`, `--eligibility-days`); `gmc roblox save
+  <universeId>` and `gmc roblox remove <universeId>` change the set and
+  take no flags at all, refusing a scope flag rather than ignoring it.
+
+  Unlike the five read commands these are workspace-scoped: they need an
+  API key or CLI credential and answer 401 without one, which is not an
+  empty saved list. They charge no credits — saving is workspace metadata,
+  not analytics — and the paid-plan gate still applies.
+
+  Saved membership is scope-independent: the flags on `saved` decide which
+  of `in_scope` / `out_of_scope` / `not_tracked` each row is in, never
+  which rows are listed. Both writes are idempotent and report the state
+  that now holds, so `changed: false` is success rather than a write to
+  retry. Universe ids travel as decimal strings into the request body as
+  well as the path, and the CLI rejects a spelling the server would reject
+  before any request is sent.
+
+  `docs/cli-use-cases.md` (new case 70) and `docs/agent-usage.md` now cover
+  the saved commands alongside the read family.
+
+- The 0.10.0 entry below is left exactly as published. Its "not yet
+  mapped" line was true of 0.10.0 and is corrected by this entry rather
+  than edited in place, matching how 0.8.0 recorded the 0.7.0 registry gap:
+  a published entry describes the release users installed, so amending one
+  would make the repo disagree with the tarball already on npm.
+
+- Not shipped here: the bundled `gmc-analysis` skill still documents the
+  Roblox read family only. The skill is a separately versioned artifact
+  with its own manifest gate, so its Roblox-saved coverage and version bump
+  follow in their own change.
+
 ## 0.10.0 - 2026-09-22
 
 - New `gmc roblox` command family (NAK-715, Provisional): `charts` (one

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@witchpot/gmc",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "private": false,
   "description": "Command line tools for Game Market Copilot market research.",
   "license": "UNLICENSED",

package/skill/gmc-analysis/CHANGELOG.md

@@ -1,5 +1,27 @@
 # gmc-analysis skill changelog
 
+## 0.17.0 - 2026-10-08
+
+- Review-count history (NAK-934): each `series[]` point can carry the
+  optional `positiveReviews`, the positive-review count observed on the same
+  row, beside the optional `ratingPercent`. Both are absent, never zero, when
+  the row carried no usable value. New guardrail: state a rate as
+  `positiveReviews / totalReviews` when the count is present, because
+  `ratingPercent` is rounded to one decimal (1,999 of 2,000 reads 100.0);
+  without the count, a `100.0` on 2,000 or more reviews is possibly rounded
+  and is never reported as "no negative reviews".
+- New "Steam follower history" section: `gmc games follower-history <appid>`
+  (MCP: `game_follower_history`), its `--range` or `--from`/`--to` window
+  (never both), and the guardrails: observed days only, followers are not
+  wishlists or sales, `not_collected` is a collection state, truncation
+  drops the oldest points.
+- New "Steam event participation" section: `gmc games events <appid>
+  [--include rank_series]` (MCP: `game_steam_events`), with the guardrails:
+  ranks and shelves are observed event-page state, not an official ranking;
+  an absent block or an empty list is a collection state; the rank series is
+  raw and never resampled.
+- MCP-only mapping updated with both tools.
+
 ## 0.16.0 - 2026-09-16
 
 - New "Disclosure text and change history" subsection under "AI disclosure

package/skill/gmc-analysis/SKILL.md

@@ -8,7 +8,7 @@ description: >-
   or campaigns that GMC can answer — including turning results into
   publish-ready branded chart cards.
 metadata:
-  version: 0.16.0
+  version: 0.17.0
 ---
 
 # GMC Analysis
@@ -59,7 +59,9 @@ applies identically. Mechanics map as follows:
   its lifecycle/announcement/discount context (`games review-history`) ->
   `game_review_history`; per-title AI-disclosure text and change history
   (`games ai-disclosure`) -> `game_profile` with `ai_disclosure` in
-  `sections`.
+  `sections`; Steam follower history (`games follower-history`) ->
+  `game_follower_history`; Steam event participation (`games events`) ->
+  `game_steam_events` (`include: ["rank_series"]` for the rank series).
 - Per-family collection status ("has GMC actually collected X for this
   game?") has no CLI command yet and is MCP-only: `game_collection_status`
   (see the dedicated section below).
@@ -413,6 +415,13 @@ Field paths differ by surface: the CLI and REST wrap the payload, so read
 the same fields at the top level. The guardrails below name the CLI path;
 drop the `data.` prefix over MCP.
 
+Each `data.series[]` point carries `date` and `totalReviews`, and two
+OPTIONAL fields: `ratingPercent` (the positive-review percentage observed on
+that row, 0-100, rounded to one decimal) and `positiveReviews` (the
+positive-review count observed on that row, 0 to `totalReviews`). Absent
+means the row carried no usable value; neither is ever zero-filled, and a
+returned `0` is a real observation.
+
 Interpretation guardrails (honesty rules, not suggestions):
 
 - **Scale by date, never by array index.** Collection has real gaps, so two
@@ -439,9 +448,67 @@ Interpretation guardrails (honesty rules, not suggestions):
   day from it. `endDate: null` means no end has been observed yet;
   `discountPercent` is the opening observation, not the deepest or final
   depth.
+- **State a rate from the count when it is there.** `ratingPercent` is
+  rounded to one decimal, so 1,999 positive of 2,000 reads `100.0`. When
+  `positiveReviews` is present, compute the rate as
+  `positiveReviews / totalReviews`. When it is absent and `ratingPercent` is
+  `100.0` on `totalReviews` of 2,000 or more, treat the 100 as possibly
+  rounded (anything from 99.95% up): say "about 100% (rounded)", never "no
+  negative reviews". Below 2,000 reviews a `100.0` is exact, because one
+  negative review already reads 99.9 or less.
 - **Temporal comparison only.** "Reviews rose in the week after the update"
   is a claim you can make; "the update caused the rise" is not.
 
+## Steam follower history
+
+`gmc games follower-history <appid> [--range 7d|1m|1y|all] [--from YYYY-MM-DD] [--to YYYY-MM-DD] --json`
+(MCP: `game_follower_history` with `appid` and either `range` or
+`from`/`to`) returns one game's Steam Community group member count on every
+OBSERVED day: `data.series[]` of `date` and `followerCount`, plus
+`data.availability` and `data.seriesMeta`. It takes the appid alone (no
+`--source`). `--range` defaults to `all`, ending today (UTC); `--from` and
+`--to` are inclusive. `--range` cannot be combined with `--from`/`--to`:
+the CLI rejects that as a usage error before any request, so the failure is
+not transient.
+
+Interpretation guardrails:
+
+- **Observed days only.** Days without an observation are absent and never
+  filled or interpolated. Scale by date, never by array index.
+- **Followers are not wishlists.** They are Steam Community game-group
+  members, a public proxy for audience interest. Never report them as a
+  wishlist count and never as sales.
+- **`not_collected` is a collection state.** `data.availability:
+  not_collected` means followers were never collected, never zero followers.
+- **Truncation drops the oldest points.** When `data.seriesMeta.truncated`
+  is true the series still ends at the newest observation; say the early
+  history is cut.
+
+## Steam event participation
+
+`gmc games events <appid> [--include rank_series] --json` (MCP:
+`game_steam_events`, with `include: ["rank_series"]`) returns the
+Steam-run events the game took part in (Next Fest and others), newest
+first: each with its observed best rank, shelf exposure, demo review
+series, store follower series and social account deltas. `--include
+rank_series` adds `rankSeries[]` of `{ snapshotUtc, rank, sourceKey }` per
+event, bounded per event and per response (`rankSeriesTruncated` marks an
+event a cap cut).
+
+Interpretation guardrails:
+
+- **Observed state, not an official ranking.** Ranks and shelf values are
+  event-page state captured by the collector. Report them as observed
+  positions, never as Steam's own ranking.
+- **Absence is a collection state.** An absent block means that signal was
+  not collected for the event. An empty `data.events` means no observed
+  participation, not proof the game never took part.
+- **The rank series is raw.** `rankSeries` holds the observations themselves
+  (about every 30 minutes during a festival), never resampled; a gap is a
+  real collection gap.
+- **Temporal comparison only.** A follower or review change during an event
+  is something you observed beside it, never something the event caused.
+
 ## Per-family collection status
 
 `game_collection_status` (MCP-only, no CLI command) returns per-signal-family

package/skill/gmc-analysis.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.16.0",
-  "contentHash": "a751df9637a24adb16604c91f77618ba1af16ce191843d85d3d8f2e6ae4df363",
+  "version": "0.17.0",
+  "contentHash": "64d3e4ed54842f921cc532ac76c936fbd99619ceed13dc6fc9317fe56552df2d",
   "files": 7
 }

package/src/args.js

@@ -21,6 +21,12 @@ export function parseArgs(args) {
   const command = [];
   const positional = [];
   const options = {};
+  // Option names given more than once. Later values still win in `options`
+  // (every command's parsing is unchanged); a command that cannot take a list
+  // reads this to reject the repetition. Non-enumerable so it never shows up
+  // as an option.
+  const repeated = new Set();
+  Object.defineProperty(options, "repeatedOptions", { value: repeated, enumerable: false });
 
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
@@ -57,6 +63,7 @@ export function parseArgs(args) {
       }
 
       if (inlineValue == null) index += 1;
+      if (Object.prototype.hasOwnProperty.call(options, key)) repeated.add(key);
       options[key] = value;
       continue;
     }
@@ -114,7 +121,7 @@ function isCommandToken(command, token) {
     return ["install", "print", "status"].includes(token);
   }
   if (command[0] === "games") {
-    return ["search", "count", "aggregate", "resolve", "benchmark", "detail", "analysis", "compare", "topics", "language-topics", "review-history", "success-report", "more-like-this", "ai-disclosure"].includes(token);
+    return ["search", "count", "aggregate", "resolve", "benchmark", "detail", "analysis", "compare", "topics", "language-topics", "review-history", "success-report", "more-like-this", "ai-disclosure", "price-history", "follower-history", "events", "screenshot-labels"].includes(token);
   }
   if (command[0] === "reviews") {
     return token === "patterns";
@@ -144,7 +151,21 @@ function isCommandToken(command, token) {
     return ["tag-trends", "trend-stories"].includes(token);
   }
   if (command[0] === "roblox") {
-    return ["charts", "experiences", "experience", "history", "coverage"].includes(token);
+    // NAK-723 adds saved/save/remove. Same trap the read family documents, and
+    // worse for the two writes: a token missing from this list falls through to
+    // positional rather than erroring, so `gmc roblox save <universeId>` would
+    // parse as the unknown command `roblox` and exit 2 with a message naming
+    // the id rather than the subcommand.
+    return [
+      "charts",
+      "experiences",
+      "experience",
+      "history",
+      "coverage",
+      "saved",
+      "save",
+      "remove"
+    ].includes(token);
   }
   return false;
 }

package/src/constants.js

@@ -7,7 +7,7 @@ export const EXIT_CONFIG = 3;
 export const EXIT_API = 4;
 
 export const CLI_PACKAGE_NAME = "@witchpot/gmc";
-export const CLI_VERSION = "0.10.0";
+export const CLI_VERSION = "0.11.0";
 
 export const DEFAULT_API_BASE_URL = "https://gamemarketcopilot.com";
 export const DEFAULT_CONFIG_PATH = path.join(homedir(), ".config", "gmc", "config.json");
@@ -64,6 +64,11 @@ export const PROVISIONAL_BETA_COMMANDS = [
   // NAK-804. New command; starts Provisional per the closed-beta roadmap's
   // default for anything not yet through broader real-data smoke testing.
   "gmc games ai-disclosure <appid> --json",
+  // NAK-934. New commands; Provisional per the same closed-beta default.
+  "gmc games price-history <appid> --range 7d|1m|1y|all --json",
+  "gmc games follower-history <appid> --range 7d|1m|1y|all --json",
+  "gmc games events <appid> --include rank_series --json",
+  "gmc games screenshot-labels <appid> --json",
   // NAK-715/NAK-725. Enabled in production on 2026-09-22; stays Provisional
   // per the closed-beta roadmap's default until the surface has been through
   // a broader real-data smoke period (the NAK-804 rule), then graduates.
@@ -71,7 +76,15 @@ export const PROVISIONAL_BETA_COMMANDS = [
   "gmc roblox experiences --country all --limit 50 --json",
   "gmc roblox experience <universeId> --json",
   "gmc roblox history <universeId> --granularity daily|hourly --json",
-  "gmc roblox coverage --json"
+  "gmc roblox coverage --json",
+  // NAK-723. The workspace's saved Roblox experiences, mapping the REST
+  // surface that shipped with the pages. Provisional for the SAME reason the
+  // five read commands above are — they are one surface, gated by one flag,
+  // and graduating the saved commands ahead of the reads they resolve against
+  // would promise a stability the reads have not earned yet.
+  "gmc roblox saved --country all --json",
+  "gmc roblox save <universeId> --json",
+  "gmc roblox remove <universeId> --json"
 ];
 
 export const COMPARE_FOCUSES = ["overview", "market", "reviews", "marketing", "audience", "showcases"];

package/src/help.js

@@ -52,6 +52,10 @@ Usage:
   gmc games review-history --source steam <externalId> --json
   gmc games more-like-this --source steam <externalId> --country <country> --json
   gmc games ai-disclosure <appid> --json
+  gmc games price-history <appid> --range 1y --json
+  gmc games follower-history <appid> --range 1y --json
+  gmc games events <appid> --json
+  gmc games screenshot-labels <appid> --json
   gmc reviews patterns --source steam --tags <tag_slug[,tag_slug...]> --reviews-min <number> --json
   gmc reviews patterns --source steam --tags <tag_slug[,tag_slug...]> --sample-size <number> --preset summary --json
   gmc marketing patterns --source steam --tags <tag_slug[,tag_slug...]> --reviews-min <number> --json
@@ -75,6 +79,9 @@ Usage:
   gmc roblox experience <universeId> --json
   gmc roblox history <universeId> --granularity daily --json
   gmc roblox coverage --json
+  gmc roblox saved --country all --json
+  gmc roblox save <universeId> --json
+  gmc roblox remove <universeId> --json
 
 Tag taxonomy:
   gmc tags --json                    List the full tag dictionary (slug, name).
@@ -182,6 +189,77 @@ AI-disclosure text and history:
   Example:
     gmc games ai-disclosure 730 --json
 
+Observed price history:
+  gmc games price-history <appid> [--range <preset>] [--from <date>] [--to <date>] --json
+                                      One game's Steam storefront price on
+                                      every OBSERVED day: priceInitial,
+                                      priceFinal (major currency units),
+                                      discountPercent, currency, storeCountry.
+  --range <preset>                    7d | 1m | 1y | all, ending today (UTC).
+                                      Defaults to all.
+  --from <YYYY-MM-DD>                 Inclusive window start.
+  --to <YYYY-MM-DD>                   Inclusive window end; defaults to today.
+                                      --range cannot be combined with --from
+                                      or --to.
+
+  Collection is not daily for every game, so days without an observation are
+  absent and never filled; scale by date, never by array index. priceFinal 0
+  with a null priceInitial is a free game; a null priceFinal means no price
+  was shown that day. data.availability not_collected means no snapshot was
+  ever collected, never a free game. A price says nothing about units sold or
+  revenue.
+
+  Example:
+    gmc games price-history 730 --range 1y --json
+
+Steam follower history:
+  gmc games follower-history <appid> [--range <preset>] [--from <date>] [--to <date>] --json
+                                      Steam Community game-group members on
+                                      every OBSERVED day: date, followerCount.
+  --range <preset>                    7d | 1m | 1y | all, ending today (UTC).
+                                      Defaults to all. Cannot be combined with
+                                      --from or --to.
+
+  Followers are a public proxy for audience interest, never a wishlist count
+  and never sales. Days without an observation are absent and never filled.
+  data.availability not_collected means followers were never collected.
+
+  Example:
+    gmc games follower-history 730 --range 1y --json
+
+Steam event participation:
+  gmc games events <appid> [--include rank_series] --json
+                                      Steam-run events the game took part in
+                                      (Next Fest and others), newest first, with
+                                      observed best rank, shelf exposure, demo
+                                      reviews, store followers and social
+                                      deltas.
+  --include rank_series               Attach the observed ranking series per
+                                      event.
+
+  Ranks and shelves are observed event-page state, never an official Steam
+  ranking. An absent block means the signal was not collected.
+
+  Example:
+    gmc games events 730 --include rank_series --json
+
+Screenshot labels:
+  gmc games screenshot-labels <appid> --json
+                                      Visual labels for each Steam store
+                                      screenshot of one game (screen type,
+                                      camera, art style, lighting, colour, a
+                                      one-line observation), in store order.
+                                      There are no parameters beyond the appid.
+
+  The labels are MODEL OUTPUT (data.labels[].labeler), not Steam data and not
+  a human review, and they can be wrong. One label set is returned per
+  screenshot: the most recently labelled taxonomy version. data.availability
+  not_labelled means nothing has been labelled yet, never that the game has
+  no screenshots.
+
+  Example:
+    gmc games screenshot-labels 730 --json
+
 Steam tag trends:
   gmc steam tag-trends --view <view> --json
                                       Tag supply trends over one frozen monthly
@@ -248,6 +326,13 @@ Roblox:
                                       A bounded window of stored metric
                                       observations.
   gmc roblox coverage --json          What the surface has, per dimension.
+  gmc roblox saved --json             This WORKSPACE's saved experiences,
+                                      resolved for one cohort and cutoff.
+  gmc roblox save <universeId> --json
+                                      Save one experience to the workspace.
+  gmc roblox remove <universeId> --json
+                                      Remove one from the workspace's saved
+                                      set.
   --country <country>                 all | US | JP. Selects which CHART was
                                       read, never a regional metric scope.
   --device <device>                   computer.
@@ -255,8 +340,8 @@ Roblox:
                                       top-revisited | fun-with-friends.
   --as-of <instant>                   ISO 8601 cutoff; defaults to now. No
                                       observation after it is considered.
-  --eligibility-days <number>         experiences only, 1-30 (default 7). How
-                                      far back a chart appearance still counts.
+  --eligibility-days <number>         experiences and saved, 1-30 (default 7).
+                                      How far back a chart appearance counts.
   --min-player-count <number>         experiences only, on the resolved row.
   --max-rank <number>                 experiences only, on the resolved row.
   --genre <genre>                     experiences only, exact match.
@@ -295,11 +380,37 @@ Roblox:
   ROBLOX_UNAVAILABLE. That is the documented not-available state, not an
   outage and not worth retrying on a schedule.
 
+  Saved experiences (workspace-scoped, unlike the five reads above):
+    saved, save and remove carry one workspace's own data and need a
+    credential — a Game Market Copilot API key or a CLI credential. Without
+    one they answer 401, which is not an empty saved list.
+
+    Saved membership is scope-independent. --country, --device, --sort,
+    --as-of and --eligibility-days apply to "saved" alone and decide which of
+    three states each row is in, never which rows are listed: in_scope
+    carries the observation that scope recorded, out_of_scope is saved and
+    tracked with NO reading there (never back-filled from another cohort or
+    from after the cutoff, and never reportable as zero or as removed), and
+    not_tracked has nothing recorded at all. The two writes take no flags.
+
+    Both writes are idempotent and report the state that NOW holds, so
+    changed: false is success and must not be retried as a failure. Saving
+    records interest in a universe id — it never triggers collection, however
+    often it is called, and it refuses an id the tracked cohort has never
+    recorded (404 NOT_FOUND, a different fact from ROBLOX_UNAVAILABLE).
+    "remove" removes the id from this workspace's saved set only; it deletes
+    no data and removing something not saved is changed: false, not a 404.
+    The set is capped per workspace (savedLimit in every response); past it,
+    saving answers 409 CONFLICT.
+
   Examples:
     gmc roblox coverage --json
     gmc roblox charts --country JP --sort top-trending --json
     gmc roblox experiences --min-player-count 1000 --order-by player_count --json
     gmc roblox history <universeId> --granularity hourly --json
+    gmc roblox saved --country JP --sort top-trending --json
+    gmc roblox save <universeId> --json
+    gmc roblox remove <universeId> --json
 
 Binary aliases:
   gmcp and game-market-copilot run the same CLI. Use them when a shell

package/src/requests.js

@@ -410,6 +410,117 @@ export function buildRequest(command, options, positional) {
     };
   }
 
+  // NAK-934. Same route shape as `gmc games ai-disclosure`: a plain numeric
+  // appid, no --source. The window flags mirror the server grammar exactly
+  // (follower-history's `range` XOR `from`/`to`), and are validated here so a
+  // malformed window is a usage error rather than a charged 400. Omitted flags
+  // are omitted from the query so the server's `all` default stays its own.
+  if (matches(command, ["games", "price-history"])) {
+    const usage = "gmc games price-history <appid> [--range 7d|1m|1y|all] [--from YYYY-MM-DD] [--to YYYY-MM-DD] --json";
+    assertSupportedOptions(options, {
+      command: "gmc games price-history",
+      allowed: ["range", "from", "to"]
+    });
+    const appid = assertAppid(positional[0], usage);
+    assertNoExtraPositionals(positional, { expected: 1, usage });
+    if (options.range != null && (options.from != null || options.to != null)) {
+      writeJsonError({
+        code: "CLI_USAGE_ERROR",
+        message: "--range cannot be combined with --from or --to."
+      });
+      process.exit(EXIT_USAGE);
+    }
+    const range = options.range == null
+      ? undefined
+      : assertEnumQueryOption(options.range, "--range", HISTORY_RANGES);
+    if (options.from != null) assertCalendarDate(options.from, "--from");
+    if (options.to != null) assertCalendarDate(options.to, "--to");
+    // Both are zero-padded YYYY-MM-DD here, so string order is date order.
+    // Only an explicit pair is checked: an omitted --to is the SERVER's today,
+    // which the local clock must not second-guess.
+    if (options.from != null && options.to != null && String(options.from) > String(options.to)) {
+      writeJsonError({
+        code: "CLI_USAGE_ERROR",
+        message: "--from must be on or before --to."
+      });
+      process.exit(EXIT_USAGE);
+    }
+    return {
+      path: `/api/v1/steam/games/${encodeURIComponent(String(appid))}/price-history`,
+      query: {
+        ...(range ? { range } : {}),
+        ...(options.from != null ? { from: String(options.from) } : {}),
+        ...(options.to != null ? { to: String(options.to) } : {})
+      }
+    };
+  }
+
+  // NAK-934 specimen sheet. The follower-history route owns the window grammar
+  // price-history borrowed, so the flags and their local checks are identical.
+  if (matches(command, ["games", "follower-history"])) {
+    const usage = "gmc games follower-history <appid> [--range 7d|1m|1y|all] [--from YYYY-MM-DD] [--to YYYY-MM-DD] --json";
+    assertSupportedOptions(options, { command: "gmc games follower-history", allowed: ["range", "from", "to"] });
+    const appid = assertAppid(positional[0], usage);
+    assertNoExtraPositionals(positional, { expected: 1, usage });
+    if (options.range != null && (options.from != null || options.to != null)) {
+      writeJsonError({ code: "CLI_USAGE_ERROR", message: "--range cannot be combined with --from or --to." });
+      process.exit(EXIT_USAGE);
+    }
+    const range = options.range == null ? undefined : assertEnumQueryOption(options.range, "--range", HISTORY_RANGES);
+    if (options.from != null) assertCalendarDate(options.from, "--from");
+    if (options.to != null) assertCalendarDate(options.to, "--to");
+    if (options.from != null && options.to != null && String(options.from) > String(options.to)) {
+      writeJsonError({ code: "CLI_USAGE_ERROR", message: "--from must be on or before --to." });
+      process.exit(EXIT_USAGE);
+    }
+    return {
+      path: `/api/v1/steam/games/${encodeURIComponent(String(appid))}/follower-history`,
+      query: {
+        ...(range ? { range } : {}),
+        ...(options.from != null ? { from: String(options.from) } : {}),
+        ...(options.to != null ? { to: String(options.to) } : {})
+      }
+    };
+  }
+
+  // NAK-934 specimen sheet. include is the route's opt-in list; its only value
+  // is rank_series, checked locally so a typo is a usage error.
+  if (matches(command, ["games", "events"])) {
+    const usage = "gmc games events <appid> [--include rank_series] --json";
+    assertSupportedOptions(options, { command: "gmc games events", allowed: ["include"] });
+    if (options.repeatedOptions?.has("include")) {
+      writeJsonError({
+        code: "CLI_USAGE_ERROR",
+        message: "--include may be given once; its only value is rank_series",
+        usage
+      });
+      process.exit(EXIT_USAGE);
+    }
+    const appid = assertAppid(positional[0], usage);
+    assertNoExtraPositionals(positional, { expected: 1, usage });
+    const include = options.include == null ? undefined : assertEnumQueryOption(options.include, "--include", STEAM_EVENTS_INCLUDE);
+    return {
+      path: `/api/v1/steam/games/${encodeURIComponent(String(appid))}/events`,
+      query: include ? { include } : {}
+    };
+  }
+
+  // NAK-934. No query parameters at all (the ai-disclosure shape), so any
+  // flag is a usage error rather than a silently ignored narrowing.
+  if (matches(command, ["games", "screenshot-labels"])) {
+    const usage = "gmc games screenshot-labels <appid> --json";
+    assertSupportedOptions(options, {
+      command: "gmc games screenshot-labels",
+      allowed: []
+    });
+    const appid = assertAppid(positional[0], usage);
+    assertNoExtraPositionals(positional, { expected: 1, usage });
+    return {
+      path: `/api/v1/steam/games/${encodeURIComponent(String(appid))}/screenshot-labels`,
+      query: {}
+    };
+  }
+
   if (matches(command, ["reviews", "patterns"])) {
     assertSource(options.source);
     const isCompare = positional[0] === "compare";
@@ -781,6 +892,84 @@ export function buildRequest(command, options, positional) {
     };
   }
 
+  // NAK-723. The saved-experiences surface: the only WORKSPACE-SCOPED Roblox
+  // commands. The five reads above are anonymous and shared-cacheable; these
+  // three carry one workspace's own data and resolve through the same unified
+  // auth `gmc lists` uses, so they are modelled on that family rather than on
+  // the Roblox read family beside them.
+  //
+  // THE SCOPE FLAGS BELONG TO `saved` ALONE, and the two writes take none. A
+  // `--country` on a save is refused here rather than dropped, matching both
+  // the REST allowlist (`SAVED_MUTATION_PARAMS` is empty) and the MCP tool's
+  // per-action allowlist: a save that quietly ignored a scope flag would look
+  // correct while answering a question the caller did not ask.
+  //
+  // SAVED MEMBERSHIP IS SCOPE-INDEPENDENT. The flags on `saved` decide which
+  // of `in_scope` / `out_of_scope` / `not_tracked` each saved experience is
+  // in, never which experiences are listed — so no flag here can add or drop
+  // a row, and an `out_of_scope` row is saved and tracked, not missing.
+  if (matches(command, ["roblox", "saved"])) {
+    assertSupportedOptions(options, {
+      command: "gmc roblox saved",
+      allowed: ["country", "device", "sort", "as-of", "eligibility-days"]
+    });
+    assertNoExtraPositionals(positional, { expected: 0, usage: "gmc roblox saved --json" });
+    return {
+      path: "/api/v1/roblox/saved",
+      // Deliberately no --limit and no --cursor: the saved set is capped per
+      // workspace and one response always holds all of it. Accepting either
+      // would imply the list can hide part of itself.
+      query: pickQuery(options, {
+        country: "country",
+        device: "device",
+        sort: "sort",
+        "as-of": "as_of",
+        "eligibility-days": "eligibility_days"
+      })
+    };
+  }
+
+  // Both writes are IDEMPOTENT and report the state that now holds. A repeat
+  // answers `changed: false` with the same body and is success, not a failure
+  // to retry — nothing here turns that into a non-zero exit.
+  //
+  // The id reaches the wire as the decimal STRING `assertUniverseId` returned.
+  // Coercing it to a number would both lose precision above 2^53 and trip the
+  // server's own `requireSavedUniverseId`, which refuses a JSON number outright
+  // because a number is exactly what a caller sends when it has routed a Steam
+  // appid into this path.
+  if (matches(command, ["roblox", "save"])) {
+    assertSupportedOptions(options, { command: "gmc roblox save", allowed: [] });
+    const universeId = assertUniverseId(positional[0], "gmc roblox save <universeId> --json");
+    assertNoExtraPositionals(positional, {
+      expected: 1,
+      usage: "gmc roblox save <universeId> --json"
+    });
+    return {
+      path: "/api/v1/roblox/saved",
+      method: "POST",
+      query: {},
+      body: { universeId }
+    };
+  }
+
+  // Removes the id from THIS WORKSPACE's saved set. It does not delete an
+  // experience, does not touch collection, and removing something that is not
+  // saved is `changed: false` rather than a 404.
+  if (matches(command, ["roblox", "remove"])) {
+    assertSupportedOptions(options, { command: "gmc roblox remove", allowed: [] });
+    const universeId = assertUniverseId(positional[0], "gmc roblox remove <universeId> --json");
+    assertNoExtraPositionals(positional, {
+      expected: 1,
+      usage: "gmc roblox remove <universeId> --json"
+    });
+    return {
+      path: `/api/v1/roblox/saved/${encodeURIComponent(universeId)}`,
+      method: "DELETE",
+      query: {}
+    };
+  }
+
   return null;
 }
 
@@ -1141,6 +1330,11 @@ function assertSource(source = "steam") {
   }
 }
 
+// Mirrors GAME_FOLLOWER_HISTORY_RANGE_PRESETS on the server, which the
+// price-history endpoint reuses (NAK-934). The server remains the authority.
+const HISTORY_RANGES = ["7d", "1m", "1y", "all"];
+const STEAM_EVENTS_INCLUDE = ["rank_series"];
+
 function assertDate(value, optionName) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(String(value))) {
     writeJsonError({
@@ -1151,6 +1345,30 @@ function assertDate(value, optionName) {
   }
 }
 
+// `assertDate` plus a real-calendar check, mirroring the server's
+// `parseCalendarDateParam` (follower-history.ts) so `2026-02-30` is a usage
+// error here instead of a request. Kept separate from `assertDate`, whose
+// other caller (--deadline-before) is not in scope for this rule.
+function assertCalendarDate(value, optionName) {
+  assertDate(value, optionName);
+  const [year, month, day] = String(value).split("-").map(Number);
+  const probe = new Date(Date.UTC(year, month - 1, day));
+  // Date.UTC maps years 0-99 into the 1900s; restore the year so the check
+  // is about the DAY being real, as on the server.
+  probe.setUTCFullYear(year);
+  if (
+    probe.getUTCFullYear() !== year ||
+    probe.getUTCMonth() !== month - 1 ||
+    probe.getUTCDate() !== day
+  ) {
+    writeJsonError({
+      code: "CLI_USAGE_ERROR",
+      message: `${optionName} must be a real calendar date`
+    });
+    process.exit(EXIT_USAGE);
+  }
+}
+
 function assertPositiveIntegerOption(value, optionName) {
   const number = Number(value);
   if (!Number.isInteger(number) || number < 1) {
@@ -1315,10 +1533,17 @@ const GLOBAL_CLI_OPTIONS = new Set(["json", "help", "version", "fields", "preset
 function assertSupportedOptions(options, { command, allowed }) {
   for (const key of Object.keys(options)) {
     if (GLOBAL_CLI_OPTIONS.has(key) || allowed.includes(key)) continue;
-    const supported = allowed.map((name) => `--${name}`).join(", ");
+    // NAK-723: an empty allowlist rendered as "Supported options: ." — which
+    // reads like a message with its list missing rather than like a command
+    // that takes no options. `gmc roblox save`/`remove` are the second and
+    // third such command (after `gmc games ai-disclosure`), so it is spelled
+    // out here once, in the MCP tool's own wording for the same case.
+    const supported = allowed.length
+      ? `Supported options: ${allowed.map((name) => `--${name}`).join(", ")}.`
+      : "This command takes no options.";
     writeJsonError({
       code: "CLI_USAGE_ERROR",
-      message: `--${key} is not supported by ${command}. Supported options: ${supported}. The endpoint does not accept it, so it would be ignored rather than applied.`
+      message: `--${key} is not supported by ${command}. ${supported} The endpoint does not accept it, so it would be ignored rather than applied.`
     });
     process.exit(EXIT_USAGE);
   }
@@ -1376,7 +1601,11 @@ function assertAppid(value, usage) {
 
 /**
  * NAK-715. Validates the universeId positional for the Roblox per-experience
- * commands, mirroring the path-parameter check the app applies.
+ * commands, mirroring the path-parameter check the app applies. NAK-723 shares
+ * it with `roblox save` / `roblox remove`, where the same string is also the
+ * request BODY's `universeId` — the regex below is character-for-character the
+ * server's own `parseRobloxId`, so the two surfaces accept and reject the same
+ * spellings.
  *
  * It returns a STRING and never a number, which is the point: a Roblox
  * universe id is a 64-bit value, and `Number.parseInt` would round anything
@@ -1389,6 +1618,14 @@ function assertAppid(value, usage) {
  *
  * A Roblox universe id is NOT a Steam appid: the two id spaces are unrelated
  * and this value never reaches a Steam route.
+ *
+ * What this CANNOT catch, deliberately: a bare Steam appid like `730` is a
+ * lexically valid universe id, on this side and on the server's. It is
+ * forwarded, and the server's tracked-cohort gate answers NOT_FOUND naming
+ * exactly that — "not in the tracked cohort, so saving it would create a row
+ * nothing could explain". Guessing here from the id's magnitude instead would
+ * invent a rule the server does not have and would reject real small universe
+ * ids, which is a worse failure than the precise 404.
  */
 function assertUniverseId(value, usage) {
   const raw = value == null ? "" : String(value).trim();

package/src/requests.test.js

@@ -514,6 +514,111 @@ test("games ai-disclosure is listed as Provisional (NAK-804)", () => {
   assert.ok(PROVISIONAL_BETA_COMMANDS.includes("gmc games ai-disclosure <appid> --json"));
 });
 
+// --- gmc games price-history / screenshot-labels (NAK-934) ----------------
+//
+// The ai-disclosure route shape: a plain numeric appid, no --source.
+
+test("games price-history targets the steam route and leaves the window to the server by default", () => {
+  const request = buildRequestFromArgv(["games", "price-history", "730", "--json"]);
+
+  assert.equal(request.path, "/api/v1/steam/games/730/price-history");
+  assert.deepEqual(request.query, {});
+});
+
+test("games price-history forwards --range, or --from/--to, verbatim", () => {
+  assert.deepEqual(
+    buildRequestFromArgv(["games", "price-history", "730", "--range", "1y", "--json"]).query,
+    { range: "1y" }
+  );
+  assert.deepEqual(
+    buildRequestFromArgv([
+      "games", "price-history", "730", "--from", "2026-01-01", "--to", "2026-03-31", "--json"
+    ]).query,
+    { from: "2026-01-01", to: "2026-03-31" }
+  );
+});
+
+test("games price-history rejects a bad window before any request", () => {
+  for (const [argv, message] of [
+    [["--range", "90d"], /--range must be one of: 7d, 1m, 1y, all/],
+    [["--range", "1y", "--from", "2026-01-01"], /--range cannot be combined with --from or --to/],
+    [["--from", "2026/01/01"], /--from must use YYYY-MM-DD/],
+    [["--to", "yesterday"], /--to must use YYYY-MM-DD/],
+    // Real calendar dates only, as on the server (NAK-934 review).
+    [["--from", "2026-02-30"], /--from must be a real calendar date/],
+    [["--to", "2025-02-29"], /--to must be a real calendar date/],
+    [["--from", "2026-13-01"], /--from must be a real calendar date/],
+    [["--to", "2026-04-00"], /--to must be a real calendar date/],
+    // An explicit pair must be ordered.
+    [["--from", "2026-05-01", "--to", "2026-04-01"], /--from must be on or before --to/],
+    [["--country", "jp"], /--country is not supported by gmc games price-history/],
+    [["--source", "steam"], /--source is not supported by gmc games price-history/]
+  ]) {
+    const { output, exitCode } = captureUsageFailure(() =>
+      buildRequestFromArgv(["games", "price-history", "730", ...argv, "--json"])
+    );
+    assert.equal(exitCode, 2, argv.join(" "));
+    assert.equal(output.error.code, "CLI_USAGE_ERROR");
+    assert.match(output.error.message, message);
+  }
+});
+
+test("games price-history accepts a leap day, a single-day window and a lone --from", () => {
+  assert.deepEqual(
+    buildRequestFromArgv(["games", "price-history", "730", "--from", "2024-02-29", "--json"]).query,
+    { from: "2024-02-29" }
+  );
+  assert.deepEqual(
+    buildRequestFromArgv([
+      "games", "price-history", "730", "--from", "2026-04-01", "--to", "2026-04-01", "--json"
+    ]).query,
+    { from: "2026-04-01", to: "2026-04-01" }
+  );
+});
+
+test("games price-history rejects a malformed appid and an extra positional", () => {
+  for (const argv of [["0x2da"], ["730", "440"], []]) {
+    const { output, exitCode } = captureUsageFailure(() =>
+      buildRequestFromArgv(["games", "price-history", ...argv, "--json"])
+    );
+    assert.equal(exitCode, 2, argv.join(" "));
+    assert.equal(output.error.code, "CLI_USAGE_ERROR");
+  }
+});
+
+test("games screenshot-labels targets the steam route and takes no options", () => {
+  const request = buildRequestFromArgv(["games", "screenshot-labels", "730", "--fields", "labels", "--json"]);
+  assert.equal(request.path, "/api/v1/steam/games/730/screenshot-labels");
+  assert.deepEqual(request.query, {});
+
+  const { output, exitCode } = captureUsageFailure(() =>
+    buildRequestFromArgv(["games", "screenshot-labels", "730", "--limit", "5", "--json"])
+  );
+  assert.equal(exitCode, 2);
+  assert.match(output.error.message, /--limit is not supported by gmc games screenshot-labels/);
+});
+
+test("help documents the NAK-934 commands and lists them as Provisional", () => {
+  const chunks = [];
+  const original = process.stdout.write;
+  process.stdout.write = (chunk) => {
+    chunks.push(String(chunk));
+    return true;
+  };
+  try {
+    printHelp();
+  } finally {
+    process.stdout.write = original;
+  }
+  const help = chunks.join("");
+
+  assert.ok(help.includes("gmc games price-history <appid> [--range <preset>]"));
+  assert.ok(help.includes("gmc games screenshot-labels <appid> --json"));
+  assert.ok(help.includes("MODEL OUTPUT"));
+  assert.ok(PROVISIONAL_BETA_COMMANDS.includes("gmc games price-history <appid> --range 7d|1m|1y|all --json"));
+  assert.ok(PROVISIONAL_BETA_COMMANDS.includes("gmc games screenshot-labels <appid> --json"));
+});
+
 // --- gmc games language-topics (NAK-455) ---------------------------------
 
 test("games language-topics targets the canonical route and sends no invented parameters", () => {
@@ -1468,3 +1573,272 @@ test("(NAK-715) the roblox commands are published as provisional in --help", ()
     );
   }
 });
+
+/**
+ * NAK-723: `gmc roblox saved | save | remove`.
+ *
+ * The saved surface is workspace-scoped and MUTATING, so these tests pin what
+ * the read tests above do not have to: which flags belong to the list and not
+ * to the writes, that the two writes carry the right HTTP method and path,
+ * and that the id reaches the BODY as a decimal string rather than a number.
+ */
+test("(NAK-723) roblox saved reads the bare endpoint and lets the server pick the scope", () => {
+  assert.deepEqual(buildRequestFromArgv(["roblox", "saved", "--json"]), {
+    path: "/api/v1/roblox/saved",
+    // Empty, not {country: "all"}: a default copied here could drift from the
+    // server's, exactly as on the read family.
+    query: {}
+  });
+});
+
+test("(NAK-723) roblox saved maps every scope flag to its query parameter", () => {
+  const request = buildRequestFromArgv([
+    "roblox", "saved",
+    "--country", "JP",
+    "--device", "computer",
+    "--sort", "top-trending",
+    "--as-of", "2026-09-20T00:00:00.000Z",
+    "--eligibility-days", "30",
+    "--json"
+  ]);
+
+  assert.equal(request.path, "/api/v1/roblox/saved");
+  assert.equal(request.method, undefined);
+  assert.deepEqual(request.query, {
+    country: "JP",
+    device: "computer",
+    sort: "top-trending",
+    as_of: "2026-09-20T00:00:00.000Z",
+    eligibility_days: "30"
+  });
+});
+
+/**
+ * The saved set is capped per workspace and one response always holds all of
+ * it. Accepting a pager would imply the list can hide part of itself, and the
+ * REST allowlist rejects both.
+ */
+test("(NAK-723) roblox saved is not paginated and refuses a pager rather than dropping it", () => {
+  for (const flag of ["--limit", "--cursor", "--offset"]) {
+    const { output, exitCode } = captureUsageFailure(() =>
+      buildRequestFromArgv(["roblox", "saved", flag, "10", "--json"])
+    );
+    assert.equal(exitCode, 2, `expected ${flag} to be refused`);
+    assert.match(output.error.message, /is not supported by gmc roblox saved/);
+  }
+});
+
+test("(NAK-723) roblox save posts the id as a decimal string body", () => {
+  const request = buildRequestFromArgv(["roblox", "save", "4924922222", "--json"]);
+
+  assert.equal(request.path, "/api/v1/roblox/saved");
+  assert.equal(request.method, "POST");
+  assert.deepEqual(request.query, {});
+  assert.deepEqual(request.body, { universeId: "4924922222" });
+  // The server refuses a JSON number outright, because a number is what a
+  // caller sends when it has routed a Steam appid into this path.
+  assert.equal(typeof request.body.universeId, "string");
+});
+
+/**
+ * Above 2^53 a number would round into a DIFFERENT experience's id, and the
+ * body is where that would silently succeed.
+ */
+test("(NAK-723) a large universe id keeps every digit through the save body", () => {
+  const request = buildRequestFromArgv(["roblox", "save", "9007199254740993", "--json"]);
+  assert.deepEqual(request.body, { universeId: "9007199254740993" });
+  assert.notEqual(String(Number("9007199254740993")), request.body.universeId);
+});
+
+test("(NAK-723) roblox remove deletes the per-id path", () => {
+  const request = buildRequestFromArgv(["roblox", "remove", "4924922222", "--json"]);
+
+  assert.equal(request.path, "/api/v1/roblox/saved/4924922222");
+  assert.equal(request.method, "DELETE");
+  assert.deepEqual(request.query, {});
+  assert.equal(request.body, undefined);
+});
+
+/**
+ * The scope flags belong to `saved` alone. A save that quietly ignored
+ * --country would look correct while answering a question nobody asked, and
+ * the identical REST request is a 400.
+ */
+test("(NAK-723) the writes take no flags, so a scope flag is a usage error", () => {
+  for (const subcommand of ["save", "remove"]) {
+    for (const [flag, value] of [["--country", "JP"], ["--as-of", "2026-09-20T00:00:00.000Z"]]) {
+      const { output, exitCode } = captureUsageFailure(() =>
+        buildRequestFromArgv(["roblox", subcommand, "4924922222", flag, value, "--json"])
+      );
+      assert.equal(exitCode, 2, `expected ${subcommand} ${flag} to be refused`);
+      assert.equal(output.error.code, "CLI_USAGE_ERROR");
+      assert.match(output.error.message, new RegExp(`is not supported by gmc roblox ${subcommand}`));
+      // A command with an empty allowlist says so, rather than rendering
+      // "Supported options: ." and reading like a truncated message.
+      assert.match(output.error.message, /This command takes no options\./);
+    }
+  }
+});
+
+/**
+ * The same lexical contract the read commands enforce, applied before any
+ * request is built: a spelling the server's `parseRobloxId` rejects must not
+ * reach the wire looking fine, and the message must name the Steam-appid
+ * confusion rather than only "invalid id".
+ */
+test("(NAK-723) a malformed universe id fails fast on both writes", () => {
+  for (const subcommand of ["save", "remove"]) {
+    for (const bad of ["730.0", "0x2da", "7e2", "-1", "0", "007", "abc"]) {
+      const { output, exitCode } = captureUsageFailure(() =>
+        buildRequestFromArgv(["roblox", subcommand, bad, "--json"])
+      );
+      assert.equal(exitCode, 2, `expected ${subcommand} ${bad} to be refused`);
+      assert.equal(output.error.code, "CLI_USAGE_ERROR");
+      assert.match(output.error.message, /not a Steam appid/);
+      assert.match(output.error.message, new RegExp(`gmc roblox ${subcommand} <universeId>`));
+    }
+
+    const missing = captureUsageFailure(() => buildRequestFromArgv(["roblox", subcommand, "--json"]));
+    assert.equal(missing.exitCode, 2, `expected a missing id on ${subcommand} to be refused`);
+  }
+});
+
+/**
+ * A bare Steam appid is a LEXICALLY valid universe id on both sides, so it is
+ * forwarded and the server's tracked-cohort gate answers NOT_FOUND naming that
+ * fact. Guessing from the id's magnitude here would invent a rule the server
+ * does not have and would reject real small universe ids.
+ */
+test("(NAK-723) a lexically valid small id is forwarded for the server's cohort gate to judge", () => {
+  assert.deepEqual(buildRequestFromArgv(["roblox", "save", "730", "--json"]).body, {
+    universeId: "730"
+  });
+});
+
+test("(NAK-723) a stray positional on a write is a usage error, not a second id", () => {
+  for (const subcommand of ["save", "remove"]) {
+    const { exitCode } = captureUsageFailure(() =>
+      buildRequestFromArgv(["roblox", subcommand, "4924922222", "4924922223", "--json"])
+    );
+    assert.equal(exitCode, 2, `expected a second id on ${subcommand} to be refused`);
+  }
+});
+
+/**
+ * A token missing from the args.js whitelist falls through to positional, so
+ * `gmc roblox save <id>` would parse as the unknown command `roblox` — the same
+ * trap `lists materialize` documents, and worse here because both are writes.
+ */
+test("(NAK-723) saved, save and remove are real command tokens, not positionals", () => {
+  for (const subcommand of ["saved", "save", "remove"]) {
+    const { command, positional } = parseArgs(["roblox", subcommand, "4924922222", "--json"]);
+    assert.deepEqual(command, ["roblox", subcommand]);
+    // The id is the command's own positional, so the branch above receives it
+    // rather than the subcommand name landing here as a stray argument.
+    assert.deepEqual(positional, ["4924922222"]);
+  }
+
+  // And `saved` takes none, so the same token there is an extra argument
+  // rather than a silently ignored one.
+  assert.equal(
+    captureUsageFailure(() => buildRequestFromArgv(["roblox", "saved", "4924922222", "--json"])).exitCode,
+    2
+  );
+});
+
+test("(NAK-723) the saved commands are published as provisional in --help", () => {
+  for (const command of [
+    "gmc roblox saved --country all --json",
+    "gmc roblox save <universeId> --json",
+    "gmc roblox remove <universeId> --json"
+  ]) {
+    assert.ok(
+      PROVISIONAL_BETA_COMMANDS.includes(command),
+      `${command} must stay listed as provisional`
+    );
+  }
+
+  const chunks = [];
+  const original = process.stdout.write;
+  process.stdout.write = (chunk) => {
+    chunks.push(String(chunk));
+    return true;
+  };
+  try {
+    printHelp();
+  } finally {
+    process.stdout.write = original;
+  }
+  const help = chunks.join("");
+
+  assert.ok(help.includes("gmc roblox saved --country all --json"));
+  assert.ok(help.includes("gmc roblox save <universeId> --json"));
+  assert.ok(help.includes("gmc roblox remove <universeId> --json"));
+  // The two facts an agent most needs from the help text, and the two most
+  // expensive to get wrong: a repeat write is success, and an out-of-scope row
+  // is still saved.
+  assert.match(help, /changed: false is success/);
+  assert.match(help, /out_of_scope is saved and\s+tracked/);
+});
+
+// --- gmc games follower-history / events (NAK-934) -------------------------
+
+test("games follower-history targets the steam route and leaves the window to the server by default", () => {
+  const request = buildRequestFromArgv(["games", "follower-history", "2436940", "--json"]);
+  assert.equal(request.path, "/api/v1/steam/games/2436940/follower-history");
+  assert.deepEqual(request.query, {});
+});
+
+test("games follower-history passes a preset or an explicit window", () => {
+  assert.deepEqual(buildRequestFromArgv(["games", "follower-history", "730", "--range", "1y", "--json"]).query, { range: "1y" });
+  assert.deepEqual(
+    buildRequestFromArgv(["games", "follower-history", "730", "--from", "2026-01-01", "--to", "2026-06-30", "--json"]).query,
+    { from: "2026-01-01", to: "2026-06-30" }
+  );
+});
+
+test("games follower-history rejects a bad window before any request", () => {
+  for (const [argv, message] of [
+    [["--range", "1y", "--from", "2026-01-01"], /--range cannot be combined with --from or --to/],
+    [["--range", "90d"], /--range must be one of: 7d, 1m, 1y, all/],
+    [["--from", "2026/01/01"], /--from must use YYYY-MM-DD/],
+    [["--from", "2026-02-30"], /--from must be a real calendar date/],
+    [["--from", "2026-05-01", "--to", "2026-04-01"], /--from must be on or before --to/],
+    [["--country", "jp"], /--country is not supported by gmc games follower-history/]
+  ]) {
+    const { output, exitCode } = captureUsageFailure(() =>
+      buildRequestFromArgv(["games", "follower-history", "730", ...argv, "--json"])
+    );
+    assert.equal(exitCode, 2, argv.join(" "));
+    assert.equal(output.error.code, "CLI_USAGE_ERROR");
+    assert.match(output.error.message, message);
+  }
+});
+
+test("games events targets the steam route, with rank_series opt-in", () => {
+  assert.equal(buildRequestFromArgv(["games", "events", "3364220", "--json"]).path, "/api/v1/steam/games/3364220/events");
+  assert.deepEqual(buildRequestFromArgv(["games", "events", "3364220", "--json"]).query, {});
+  assert.deepEqual(buildRequestFromArgv(["games", "events", "3364220", "--include", "rank_series", "--json"]).query, { include: "rank_series" });
+});
+
+test("games events rejects an unknown include value and unsupported flags", () => {
+  for (const [argv, message] of [
+    [["--include", "ranks"], /--include must be one of: rank_series/],
+    [["--include", "bad", "--include", "rank_series"], /--include may be given once; its only value is rank_series/],
+    [["--include", "rank_series", "--include=rank_series"], /--include may be given once/],
+    [["--range", "1y"], /--range is not supported by gmc games events/]
+  ]) {
+    const { output, exitCode } = captureUsageFailure(() =>
+      buildRequestFromArgv(["games", "events", "730", ...argv, "--json"])
+    );
+    assert.equal(exitCode, 2, argv.join(" "));
+    assert.equal(output.error.code, "CLI_USAGE_ERROR");
+    assert.match(output.error.message, message);
+  }
+});
+
+test("the new commands are listed and documented", async () => {
+  const { PROVISIONAL_BETA_COMMANDS } = await import("./constants.js");
+  assert.ok(PROVISIONAL_BETA_COMMANDS.some((command) => command.startsWith("gmc games follower-history ")));
+  assert.ok(PROVISIONAL_BETA_COMMANDS.some((command) => command.startsWith("gmc games events ")));
+});