moshcode 0.27.0 → 0.29.0

package/.claude-plugin/marketplace.json

@@ -8,15 +8,15 @@
   },
   "plugins": [
     {
-      "name": "ticker",
+      "name": "stocks",
       "description": "Equity research slash commands backed by advis0r.com: scored reports, extracted signals, transcript search, company-name lookup, and ranked watchlists.",
-      "source": "./plugins/ticker",
+      "source": "./plugins/stocks",
       "category": "productivity",
       "author": {
         "name": "moshcoder",
         "url": "https://moshcode.sh"
       },
-      "homepage": "https://github.com/moshcoder/moshcode#ticker",
+      "homepage": "https://github.com/moshcoder/moshcode#stocks",
       "keywords": ["stocks", "equity", "research", "markets", "advis0r"]
     },
     {

package/README.md

@@ -46,7 +46,7 @@ or miss one that does. A test fails the build when it drifts.
 | `moshcode engines` | engines | list engines and installation status |
 | `moshcode tools` | tools | list workflow tools and installation status |
 | `moshcode trade` | tools | look up markets and trade through Alpaca |
-| `moshcode ticker` <br>`advisor` | tools | equity research from advis0r.com |
+| `moshcode stocks` <br>`advisor` | tools | equity research from advis0r.com |
 | `moshcode crypto` <br>`coins` | tools | crypto market data from advis0r.com |
 | `moshcode plugin` <br>`plugins` | extend | install moshcode's slash commands into Claude Code |
 | `moshcode commands` | script | list built-in moshscript commands |
@@ -214,34 +214,34 @@ Alpaca's CLI has no confirmation prompts; `--submit` intentionally removes
 MoshCode's preview guard. Live trading additionally requires Alpaca's `--live`
 opt-in or corresponding environment setting.
 
-### Equity research (`moshcode ticker`)
+### Equity research (`moshcode stocks`)
 
-Where `trade` is Alpaca's order book, `ticker` is the research desk:
+Where `trade` is Alpaca's order book, `stocks` is the research desk:
 [advis0r.com](https://advis0r.com/api)'s public read-only API, rendered in the
 pit. No key, no login, no write routes, no binary to install:
 
 ```sh
-moshcode ticker NVDA               # score, technicals, fundamentals, thesis, signals
-moshcode ticker lookup rivian      # company name → RIVN
-moshcode ticker signals AAPL       # what was said, quoted and sourced
-moshcode ticker search "data center"  # across every indexed transcript
-moshcode ticker reports --limit 10 # the stored index, best score first
-moshcode ticker discover fusion    # a ranked watchlist (slow — analyzes each candidate)
-moshcode ticker open NVDA          # the shareable report page
+moshcode stocks NVDA               # score, technicals, fundamentals, thesis, signals
+moshcode stocks lookup rivian      # company name → RIVN
+moshcode stocks signals AAPL       # what was said, quoted and sourced
+moshcode stocks search "data center"  # across every indexed transcript
+moshcode stocks reports --limit 10 # the stored index, best score first
+moshcode stocks discover fusion    # a ranked watchlist (slow — analyzes each candidate)
+moshcode stocks open NVDA          # the shareable report page
 ```
 
-Add `--json` to any of them for the raw response. The same facade is `/ticker …`
+Add `--json` to any of them for the raw response. The same facade is `/stocks …`
 in the pit, and `MOSHCODE_ADVISOR_URL` points it at another instance.
 
 Reports are **stored snapshots**, not live quotes: every response carries
 `reportGeneratedAt` and every renderer prints it, alongside whether the price is
 delayed and which feed produced it. Scores labelled `offline` come from
 deterministic rules rather than a model. It is a research aid, not advice, and
-nothing under `ticker` can place an order.
+nothing under `stocks` can place an order.
 
 ### Crypto market data (`moshcode crypto`)
 
-`crypto` is `ticker`'s sibling on the same host: advis0r's read-only crypto
+`crypto` is `stocks`'s sibling on the same host: advis0r's read-only crypto
 routes over Alpaca's US crypto venue, which trades 24/7 and needs no extra
 subscription.
 
@@ -260,7 +260,7 @@ Pairs are accepted as `BTC`, `BTC-USD`, `BTC/USD` or `BTCUSD` — a bare asset
 resolves to that asset's USD pair. `--json` gives the raw response, `/crypto …`
 is the same facade in the pit, and `MOSHCODE_ADVISOR_URL` points it elsewhere.
 
-Unlike a `ticker` report, this is a **live venue read**, not a stored snapshot —
+Unlike a `stocks` report, this is a **live venue read**, not a stored snapshot —
 there are no transcripts, no filings and no signals behind a crypto pair, and
 the failure mode runs the other way: the price is accurate to the second and
 stale by the time you act on it. Every response stamps when it was fetched.
@@ -268,7 +268,7 @@ stale by the time you act on it. Every response stamps when it was fetched.
 The technical score counts venue-local liquidity, so it is **not comparable** to
 an equity's score, and each response ships the `caveats` that say so. Prices are
 Alpaca's US venue alone and can differ materially from other exchanges. Research
-aid, not advice — and like `ticker`, nothing under `crypto` can place an order.
+aid, not advice — and like `stocks`, nothing under `crypto` can place an order.
 
 ### Social posting from the pit
 
@@ -371,12 +371,12 @@ inside your engine too:
 
 ```sh
 moshcode plugin list              # what the marketplace ships, and who can take it
-moshcode plugin install           # add the marketplace + install `ticker`
+moshcode plugin install           # add the marketplace + install `stocks`
 moshcode plugin install crypto    # add the marketplace + install `crypto`
-moshcode plugin remove ticker     # take it back off
+moshcode plugin remove stocks     # take it back off
 ```
 
-`ticker@moshcode` adds `/ticker`, `/signals`, `/research`, `/lookup`,
+`stocks@moshcode` adds `/stocks`, `/signals`, `/research`, `/lookup`,
 `/reports`, and `/discover` — the same advis0r research surface described above,
 driven from inside a coding session.
 
@@ -392,10 +392,24 @@ The equivalent by hand:
 
 ```sh
 claude plugin marketplace add moshcoder/moshcode
-claude plugin install ticker@moshcode
+claude plugin install stocks@moshcode
 claude plugin install crypto@moshcode
 ```
 
+### Upgrading from `ticker@moshcode`
+
+`stocks` was called `ticker` before v0.29.0. Installing the new id does **not**
+replace the old one — engines install plugins side by side, so `/stocks` would
+come from two plugins at once. Remove the old id first:
+
+```sh
+moshcode plugin remove ticker
+moshcode plugin install stocks
+```
+
+`remove ticker` keeps working for exactly that reason, even though
+`install ticker` no longer does.
+
 Claude Code is currently the only engine with a plugin primitive. The others are
 reported as skipped with a reason, the same way they are for skills, rather than
 being left out of the summary. `MOSHCODE_PLUGIN_SOURCE=.` installs from a local

package/bin/moshcode.mjs

@@ -20,7 +20,7 @@ import { runUpgrade } from "../src/upgrade.mjs";
 import { selfUpdateCommand } from "../src/selfupdate.mjs";
 import { describeUninstall, uninstallPlan } from "../src/uninstall.mjs";
 import { mcpCommand, pluginCommand, skillCommand } from "../src/integrations.mjs";
-import { tickerCommand } from "../src/advisor.mjs";
+import { stocksCommand } from "../src/advisor.mjs";
 import { cryptoCommand } from "../src/crypto.mjs";
 import { canOpenBrowser, openBrowser } from "../src/open-url.mjs";
 import { locate, tilde } from "../src/pwd.mjs";
@@ -347,8 +347,8 @@ async function main() {
     propagateExit(r.code, r.signal);
     return;
   }
-  if (cmd === "ticker" || cmd === "advisor") {
-    const code = await tickerCommand(rest, {
+  if (cmd === "stocks" || cmd === "advisor") {
+    const code = await stocksCommand(rest, {
       openUrl: (url) => canOpenBrowser() && openBrowser(url),
     });
     if (code) process.exitCode = code;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moshcode",
-  "version": "0.27.0",
+  "version": "0.29.0",
   "type": "module",
   "description": "moshcode — a metal wrapper for coding engines and native UGig/CoinPay workflow CLIs, with OpenPRD and moshscript",
   "repository": {

package/plugins/crypto/README.md

@@ -41,10 +41,10 @@ command falls back to `curl` against the same endpoints.
 
 Point the commands at another instance with `MOSHCODE_ADVISOR_URL`.
 
-## Why this is separate from `ticker`
+## Why this is separate from `stocks`
 
 They answer different questions from different data, and share only a hostname.
-A `/ticker` report is a **stored snapshot** built from transcripts, SEC
+A `/stocks` report is a **stored snapshot** built from transcripts, SEC
 fundamentals and extracted signals — its risk is a stale price read as a live
 one. A `/crypto` report is a **live venue read** with no transcripts, no
 filings and no signals — its risk is the opposite: a price that is accurate to

package/plugins/crypto/commands/crypto.md

@@ -42,9 +42,9 @@ resolves to that asset's USD pair.
 - Crypto trades 24/7 with no circuit breakers and no market close. Never
   describe a crypto price as "at the close" or "premarket".
 - State `generatedAt` / `fetchedAt`. This is a live read, so it goes stale in
-  seconds, not days — the opposite failure mode from a stored `/ticker` report.
+  seconds, not days — the opposite failure mode from a stored `/stocks` report.
 - The score's liquidity component counts venue-local volume only, so it is
-  **not comparable** to an equity's score from `/ticker`. Do not rank the two
+  **not comparable** to an equity's score from `/stocks`. Do not rank the two
   against each other.
 - End with the response's own `disclaimer`. This is research, not advice.
 - Link the shareable page: `https://advis0r.com/crypto/<PAIR>`.

package/plugins/{ticker → stocks}/.claude-plugin/plugin.json

@@ -1,13 +1,13 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
-  "name": "ticker",
+  "name": "stocks",
   "description": "Equity research slash commands backed by advis0r.com: scored reports, extracted signals, transcript search, company-name lookup, and ranked watchlists.",
   "version": "0.1.0",
   "author": {
     "name": "moshcoder",
     "url": "https://moshcode.sh"
   },
-  "homepage": "https://github.com/moshcoder/moshcode#ticker",
+  "homepage": "https://github.com/moshcoder/moshcode#stocks",
   "license": "MIT",
   "keywords": ["stocks", "equity", "research", "markets", "advis0r"]
 }

package/plugins/{ticker → stocks}/README.md

@@ -1,4 +1,4 @@
-# ticker — equity research in your engine 🤘
+# stocks — equity research in your engine 🤘
 
 Slash commands backed by [advis0r.com](https://advis0r.com/api): scored research
 reports, extracted signals with sources, transcript search, company-name lookup,
@@ -6,13 +6,31 @@ and ranked watchlists.
 
 | command | what it does |
 | --- | --- |
-| `/ticker NVDA` | score, technicals, fundamentals, thesis, signals, sources |
+| `/stocks NVDA` | score, technicals, fundamentals, thesis, signals, sources |
 | `/signals AAPL` | what was actually said, quoted and sourced |
 | `/research data center` | full-text search across every indexed transcript |
 | `/lookup rivian` | company name → `RIVN` |
 | `/reports` | every stored report, best score first |
 | `/discover fusion` | a ranked watchlist for a topic (slow) |
 
+## Upgrading from `ticker@moshcode`
+
+This plugin used to be called `ticker`. Both it and its headline command were
+renamed so the name says which market it covers, now that `/crypto` sits beside
+it.
+
+Installing the new one does **not** replace the old one — engines install
+plugins side by side, so `/stocks` would come from two plugins at once. Remove
+the old id first:
+
+```bash
+moshcode plugin remove ticker
+moshcode plugin install stocks
+```
+
+`moshcode plugin remove ticker` keeps working for exactly this reason, even
+though `moshcode plugin install ticker` no longer does.
+
 ## Install
 
 ```bash
@@ -23,7 +41,7 @@ Or straight from Claude Code:
 
 ```bash
 claude plugin marketplace add moshcoder/moshcode
-claude plugin install ticker@moshcode
+claude plugin install stocks@moshcode
 ```
 
 Restart the engine afterwards — a newly installed plugin is not live in a
@@ -31,7 +49,7 @@ session that is already running.
 
 ## How it works
 
-Each command shells out to `moshcode ticker …`, which calls advis0r's public,
+Each command shells out to `moshcode stocks …`, which calls advis0r's public,
 read-only API. No key, no login, no write routes. With `moshcode` absent, every
 command falls back to `curl` against the same endpoints.
 

package/plugins/{ticker → stocks}/commands/discover.md

@@ -1,7 +1,7 @@
 ---
 description: Build a ranked watchlist for a topic (slow — it analyzes each candidate).
 argument-hint: "[topic]"
-allowed-tools: Bash(moshcode ticker:*), Bash(curl -sS https://advis0r.com/api/:*)
+allowed-tools: Bash(moshcode stocks:*), Bash(curl -sS https://advis0r.com/api/:*)
 ---
 
 ## Task
@@ -9,7 +9,7 @@ allowed-tools: Bash(moshcode ticker:*), Bash(curl -sS https://advis0r.com/api/:*
 Rank candidates for `$ARGUMENTS` (no topic → the default watchlist).
 
 ```bash
-moshcode ticker discover $ARGUMENTS --limit 10 --json
+moshcode stocks discover $ARGUMENTS --limit 10 --json
 ```
 
 Fallback: `curl -sS --max-time 180 "https://advis0r.com/api/discover?topic=<url-encoded>&provider=offline&horizon=2&limit=10"`

package/plugins/{ticker → stocks}/commands/lookup.md

@@ -1,7 +1,7 @@
 ---
 description: Find a ticker symbol by company name (rivian → RIVN).
 argument-hint: <company name>
-allowed-tools: Bash(moshcode ticker:*), Bash(curl -sS https://advis0r.com/api/:*)
+allowed-tools: Bash(moshcode stocks:*), Bash(curl -sS https://advis0r.com/api/:*)
 ---
 
 ## Task
@@ -9,7 +9,7 @@ allowed-tools: Bash(moshcode ticker:*), Bash(curl -sS https://advis0r.com/api/:*
 Resolve `$ARGUMENTS` to a ticker symbol.
 
 ```bash
-moshcode ticker lookup $ARGUMENTS --limit 10 --json
+moshcode stocks lookup $ARGUMENTS --limit 10 --json
 ```
 
 Fallback: `curl -sS "https://advis0r.com/api/lookup?q=<url-encoded>&limit=10"`
@@ -22,6 +22,6 @@ Fallback: `curl -sS "https://advis0r.com/api/lookup?q=<url-encoded>&limit=10"`
 ## Rules
 
 - Show every match with its exchange — "Delta" is an airline and a faucet company.
-- Mark which ones have a report, and offer `/ticker <SYMBOL>` for those.
+- Mark which ones have a report, and offer `/stocks <SYMBOL>` for those.
 - One unambiguous match: say the symbol and go straight to offering the report.
 - No match: say the *directory* has no match, and do not invent a symbol.

package/plugins/{ticker → stocks}/commands/reports.md

@@ -1,7 +1,7 @@
 ---
 description: Every stored advis0r research report, best score first.
 argument-hint: "[--limit n] [--sort recent|score|ticker]"
-allowed-tools: Bash(moshcode ticker:*), Bash(curl -sS https://advis0r.com/api/:*)
+allowed-tools: Bash(moshcode stocks:*), Bash(curl -sS https://advis0r.com/api/:*)
 ---
 
 ## Task
@@ -9,7 +9,7 @@ allowed-tools: Bash(moshcode ticker:*), Bash(curl -sS https://advis0r.com/api/:*
 List the stored reports.
 
 ```bash
-moshcode ticker reports $ARGUMENTS --json
+moshcode stocks reports $ARGUMENTS --json
 ```
 
 Fallback: `curl -sS "https://advis0r.com/api/reports?sort=score&limit=25"`
@@ -26,5 +26,5 @@ generatedAt }`, and `total` is how many exist.
 - **`generatedAt` per row, always.** These are snapshots taken at different
   times; a table that hides that reads as one consistent as-of date.
 - A row with no `aiProvider` was scored deterministically, not by a model.
-- Offer `/ticker <SYMBOL>` for anything worth a closer look.
+- Offer `/stocks <SYMBOL>` for anything worth a closer look.
 - This is a coverage list, not a recommendation list. Rank order is score order.

package/plugins/{ticker → stocks}/commands/research.md

@@ -1,7 +1,7 @@
 ---
 description: Full-text search across every indexed earnings transcript and article.
 argument-hint: <words to search for>
-allowed-tools: Bash(moshcode ticker:*), Bash(curl -sS https://advis0r.com/api/:*)
+allowed-tools: Bash(moshcode stocks:*), Bash(curl -sS https://advis0r.com/api/:*)
 ---
 
 ## Task
@@ -9,7 +9,7 @@ allowed-tools: Bash(moshcode ticker:*), Bash(curl -sS https://advis0r.com/api/:*
 Search the transcript index for `$ARGUMENTS`.
 
 ```bash
-moshcode ticker search $ARGUMENTS --limit 20 --json
+moshcode stocks search $ARGUMENTS --limit 20 --json
 ```
 
 Fallback: `curl -sS "https://advis0r.com/api/search?q=<url-encoded>&limit=20"`

package/plugins/{ticker → stocks}/commands/signals.md

@@ -1,7 +1,7 @@
 ---
 description: What was actually said about a ticker — extracted signals with quotes and sources.
 argument-hint: <SYMBOL>
-allowed-tools: Bash(moshcode ticker:*), Bash(curl -sS https://advis0r.com/api/:*)
+allowed-tools: Bash(moshcode stocks:*), Bash(curl -sS https://advis0r.com/api/:*)
 ---
 
 ## Task
@@ -9,7 +9,7 @@ allowed-tools: Bash(moshcode ticker:*), Bash(curl -sS https://advis0r.com/api/:*
 List the extracted signals for `$ARGUMENTS`.
 
 ```bash
-moshcode ticker signals $ARGUMENTS --json
+moshcode stocks signals $ARGUMENTS --json
 ```
 
 Fallback: `curl -sS "https://advis0r.com/api/signals?ticker=$ARGUMENTS"`

package/plugins/{ticker/commands/ticker.md → stocks/commands/stocks.md}

@@ -1,7 +1,7 @@
 ---
 description: Research one ticker — score, technicals, fundamentals, thesis, signals, and sources.
 argument-hint: <SYMBOL>
-allowed-tools: Bash(moshcode ticker:*), Bash(curl -sS https://advis0r.com/api/:*)
+allowed-tools: Bash(moshcode stocks:*), Bash(curl -sS https://advis0r.com/api/:*)
 ---
 
 ## Task
@@ -11,7 +11,7 @@ Pull the stored research report for `$ARGUMENTS` and summarize it for the user.
 Run:
 
 ```bash
-moshcode ticker $ARGUMENTS --json
+moshcode stocks $ARGUMENTS --json
 ```
 
 If `moshcode` is not installed, fall back to the API directly:

package/src/advisor.mjs

@@ -1,4 +1,4 @@
-// `moshcode ticker` — equity research from advis0r.com, in the pit.
+// `moshcode stocks` — equity research from advis0r.com, in the pit.
 //
 // Same split as src/trade.mjs: argument translation is pure and testable, the
 // network call is injectable, and rendering is a function of the decoded JSON.
@@ -18,7 +18,7 @@ export function advisorBase(env = process.env) {
   return (raw || DEFAULT_ADVISOR_URL).replace(/\/+$/, "");
 }
 
-const USAGE = `usage: moshcode ticker <symbol|verb> [args…]
+const USAGE = `usage: moshcode stocks <symbol|verb> [args…]
 
   <symbol>                       the stored research report for one ticker
   report <symbol>                same thing, when a symbol looks like a verb
@@ -40,17 +40,17 @@ const USAGE = `usage: moshcode ticker <symbol|verb> [args…]
 Research aid, not advice. Every route is public, read-only, and served from
 stored snapshots — see the generated-at stamp printed with each report.`;
 
-export function tickerUsage() {
+export function stocksUsage() {
   return USAGE;
 }
 
-/** Verb names, in help order. cli-schema's TICKER_VERBS must match (drift test). */
-export const TICKER_VERB_NAMES = [
+/** Verb names, in help order. cli-schema's STOCKS_VERBS must match (drift test). */
+export const STOCKS_VERB_NAMES = [
   "report", "signals", "search", "lookup", "reports", "discover", "tickers", "stats", "open",
 ];
 
-// Aliases exist because muscle memory differs: `/ticker news AAPL` and
-// `/ticker quotes AAPL` should not be errors when the intent is obvious.
+// Aliases exist because muscle memory differs: `/stocks news AAPL` and
+// `/stocks quotes AAPL` should not be errors when the intent is obvious.
 const VERB_ALIASES = {
   signal: "signals", news: "signals",
   find: "search", grep: "search", q: "search",
@@ -66,7 +66,7 @@ const VERB_ALIASES = {
 /** Resolve a first argument to a canonical verb, or null when it is a symbol. */
 export function resolveVerb(word) {
   const key = String(word ?? "").toLowerCase();
-  if (TICKER_VERB_NAMES.includes(key)) return key;
+  if (STOCKS_VERB_NAMES.includes(key)) return key;
   return VERB_ALIASES[key] ?? null;
 }
 
@@ -114,13 +114,13 @@ function positiveInt(value, { max }) {
 const SORTS = ["recent", "score", "ticker"];
 
 /**
- * Translate `ticker` arguments into a request the caller can execute.
+ * Translate `stocks` arguments into a request the caller can execute.
  *
  * Returns one of `{ usage }`, `{ error }`, or
  * `{ verb, path, query, json, open? }` — never performs IO, so the whole
  * argument surface is testable without a network.
  */
-export function tickerArgs(input = []) {
+export function stocksArgs(input = []) {
   const args = input.map(String);
   const jsonFlag = takeFlag(args, "--json", { boolean: true });
   let rest = jsonFlag.rest;
@@ -131,26 +131,26 @@ export function tickerArgs(input = []) {
   const horizonFlag = takeFlag(rest, "--horizon"); rest = horizonFlag.rest;
   const providerFlag = takeFlag(rest, "--provider"); rest = providerFlag.rest;
 
-  if (limitFlag.missing) return { error: "ticker --limit requires a positive number" };
-  if (sortFlag.missing) return { error: `ticker --sort requires one of ${SORTS.join(", ")}` };
-  if (horizonFlag.missing) return { error: "ticker --horizon requires 1 or 2" };
-  if (providerFlag.missing) return { error: "ticker --provider requires a name" };
+  if (limitFlag.missing) return { error: "stocks --limit requires a positive number" };
+  if (sortFlag.missing) return { error: `stocks --sort requires one of ${SORTS.join(", ")}` };
+  if (horizonFlag.missing) return { error: "stocks --horizon requires 1 or 2" };
+  if (providerFlag.missing) return { error: "stocks --provider requires a name" };
 
   // A limit above the server's own cap is silently clamped there; clamping here
   // too keeps `--limit 9999` from reading like a promise the API never made.
   const limit = limitFlag.value == null ? null : positiveInt(limitFlag.value, { max: 50 });
   if (limitFlag.value != null && limit == null) {
-    return { error: "ticker --limit requires a positive number" };
+    return { error: "stocks --limit requires a positive number" };
   }
   if (sortFlag.value != null && !SORTS.includes(sortFlag.value.toLowerCase())) {
-    return { error: `ticker --sort must be one of ${SORTS.join(", ")}` };
+    return { error: `stocks --sort must be one of ${SORTS.join(", ")}` };
   }
   if (horizonFlag.value != null && !["1", "2"].includes(String(horizonFlag.value))) {
-    return { error: "ticker --horizon must be 1 or 2" };
+    return { error: "stocks --horizon must be 1 or 2" };
   }
 
   const stray = rest.find((arg) => arg.startsWith("-") && arg !== "-");
-  if (stray) return { error: `unknown ticker flag ${JSON.stringify(stray)}` };
+  if (stray) return { error: `unknown stocks flag ${JSON.stringify(stray)}` };
 
   const [first, ...tail] = rest;
   if (!first) return { usage: true };
@@ -158,16 +158,16 @@ export function tickerArgs(input = []) {
   const verb = resolveVerb(first);
   const words = verb ? tail : rest;
 
-  // No verb → the first word is the ticker. `/ticker AAPL` is the headline
+  // No verb → the first word is the ticker. `/stocks AAPL` is the headline
   // case and must stay the shortest thing anyone types.
   const wantsReport = verb == null || verb === "report" || verb === "open";
   if (wantsReport) {
     const raw = words[0];
-    if (!raw) return { error: `ticker ${verb === "open" ? "open" : "report"} requires a ticker symbol` };
+    if (!raw) return { error: `stocks ${verb === "open" ? "open" : "report"} requires a ticker symbol` };
     const symbol = normalizeSymbol(raw);
     if (!symbol) {
       return {
-        error: `${JSON.stringify(String(raw))} is not a ticker symbol — try: moshcode ticker lookup ${String(raw)}`,
+        error: `${JSON.stringify(String(raw))} is not a ticker symbol — try: moshcode stocks lookup ${String(raw)}`,
       };
     }
     if (verb === "open") return { verb: "open", symbol, open: `/ticker/${encodeURIComponent(symbol)}`, json };
@@ -176,16 +176,16 @@ export function tickerArgs(input = []) {
 
   if (verb === "signals") {
     const symbol = normalizeSymbol(words[0]);
-    if (!words[0]) return { error: "ticker signals requires a ticker symbol" };
+    if (!words[0]) return { error: "stocks signals requires a ticker symbol" };
     if (!symbol) {
-      return { error: `${JSON.stringify(String(words[0]))} is not a ticker symbol — try: moshcode ticker lookup ${words[0]}` };
+      return { error: `${JSON.stringify(String(words[0]))} is not a ticker symbol — try: moshcode stocks lookup ${words[0]}` };
     }
     return { verb, symbol, path: "/api/signals", query: { ticker: symbol }, json };
   }
 
   if (verb === "search" || verb === "lookup") {
     const q = words.join(" ").trim();
-    if (!q) return { error: `ticker ${verb} requires something to look for` };
+    if (!q) return { error: `stocks ${verb} requires something to look for` };
     const path = verb === "search" ? "/api/search" : "/api/lookup";
     return { verb, path, query: { q, ...(limit ? { limit: String(limit) } : {}) }, json };
   }
@@ -221,7 +221,7 @@ export function tickerArgs(input = []) {
   if (verb === "tickers") return { verb, path: "/api/tickers", query: {}, json };
   if (verb === "stats") return { verb, path: "/api/stats", query: {}, json };
 
-  return { error: `unknown ticker command ${JSON.stringify(String(first))}` };
+  return { error: `unknown stocks command ${JSON.stringify(String(first))}` };
 }
 
 /** Build the absolute URL for a translated request. */
@@ -248,7 +248,7 @@ export async function fetchAdvisor(request, { fetchImpl = globalThis.fetch, base
   try {
     const res = await fetchImpl(url, {
       signal: controller.signal,
-      headers: { accept: "application/json", "user-agent": "moshcode-ticker" },
+      headers: { accept: "application/json", "user-agent": "moshcode-stocks" },
     });
     const text = await res.text();
     let data;
@@ -468,7 +468,7 @@ function renderLookup(d) {
     const report = m.hasReport ? acid("  ✓ report") : ash("  · no report yet");
     lines.push(`  ${acid(String(m.symbol).padEnd(8))}${bone(clip(m.name, 44).padEnd(46))}${ash(String(m.exchange ?? ""))}${report}`);
   }
-  lines.push("", `  ${ash("then:")} ${bone(`moshcode ticker ${matches[0].symbol}`)}`);
+  lines.push("", `  ${ash("then:")} ${bone(`moshcode stocks ${matches[0].symbol}`)}`);
   return lines.join("\n");
 }
 
@@ -484,7 +484,7 @@ function renderReports(d) {
       `${bone(money(r.lastPrice).padStart(11))}  ${ash(clip(r.companyName, 28).padEnd(29))}${ash(day(r.generatedAt))}`,
     );
   }
-  lines.push("", `  ${ash("detail:")} ${bone(`moshcode ticker ${reports[0].ticker}`)}`);
+  lines.push("", `  ${ash("detail:")} ${bone(`moshcode stocks ${reports[0].ticker}`)}`);
   return lines.join("\n");
 }
 
@@ -550,12 +550,12 @@ export function renderAdvisor(verb, data, { columns } = {}) {
 }
 
 /**
- * Run a `ticker` invocation end to end. Returns a process exit code.
+ * Run a `stocks` invocation end to end. Returns a process exit code.
  *
  * `deps` exists so tests drive the whole command — parse, fetch, render — with
  * no network and no stdout.
  */
-export async function tickerCommand(argv = [], deps = {}) {
+export async function stocksCommand(argv = [], deps = {}) {
   const {
     out = (s) => console.log(s),
     fail = (s) => console.error(s),
@@ -565,8 +565,8 @@ export async function tickerCommand(argv = [], deps = {}) {
     columns = process.stdout.columns,
   } = deps;
 
-  const request = tickerArgs(argv);
-  if (request.usage) { out(tickerUsage()); return 0; }
+  const request = stocksArgs(argv);
+  if (request.usage) { out(stocksUsage()); return 0; }
   if (request.error) { fail(danger(`✗ ${request.error}`)); return 1; }
 
   if (request.verb === "open") {
@@ -587,7 +587,7 @@ export async function tickerCommand(argv = [], deps = {}) {
     if (request.json) { out(JSON.stringify(res.data, null, 2)); return 1; }
     fail(danger(`✗ ${message}`));
     if (res.data?.didYouMean?.symbol) {
-      fail(`  ${ash("try:")} ${bone(`moshcode ticker ${res.data.didYouMean.symbol}`)}`);
+      fail(`  ${ash("try:")} ${bone(`moshcode stocks ${res.data.didYouMean.symbol}`)}`);
     }
     return 1;
   }

package/src/cli-schema.mjs

@@ -290,14 +290,14 @@ export const CORE_CLI_COMMANDS = [
     note: "buy/sell inject --dry-run unless --submit is present. Alpaca defaults to paper trading; live trading requires its separate --live opt-in.",
   },
   {
-    name: "ticker",
+    name: "stocks",
     group: "tools",
     description: "equity research from advis0r.com",
     synopsis: [
-      ["moshcode ticker <symbol>", "the stored research report for one ticker"],
-      ["moshcode ticker <verb> [args…]", ""],
+      ["moshcode stocks <symbol>", "the stored research report for one ticker"],
+      ["moshcode stocks <verb> [args…]", ""],
     ],
-    verbs: "TICKER_VERBS",
+    verbs: "STOCKS_VERBS",
     flags: [
       ["--json", "print the raw API response", ""],
       ["--limit <n>", "cap results (search/lookup/reports/discover)", "the API's own default"],
@@ -306,16 +306,16 @@ export const CORE_CLI_COMMANDS = [
       ["--provider <p>", "discover: analysis provider", "offline"],
     ],
     examples: [
-      ["moshcode ticker NVDA", "score, technicals, thesis, signals, sources"],
-      ["moshcode ticker lookup rivian", "company name → RIVN"],
-      ["moshcode ticker signals AAPL", "what was actually said, with sources"],
-      ["moshcode ticker search 'data center'", "across every indexed transcript"],
-      ["moshcode ticker reports --limit 10", "the stored index, best score first"],
+      ["moshcode stocks NVDA", "score, technicals, thesis, signals, sources"],
+      ["moshcode stocks lookup rivian", "company name → RIVN"],
+      ["moshcode stocks signals AAPL", "what was actually said, with sources"],
+      ["moshcode stocks search 'data center'", "across every indexed transcript"],
+      ["moshcode stocks reports --limit 10", "the stored index, best score first"],
     ],
     seeAlso: ["trade", "plugin", "tools"],
     note: "research aid, not advice — reports are stored snapshots and every one prints when it was generated. Set MOSHCODE_ADVISOR_URL to point at another instance.",
   },
-  { name: "advisor", aliasOf: "ticker", description: "alias for ticker" },
+  { name: "advisor", aliasOf: "stocks", description: "alias for stocks" },
   {
     name: "crypto",
     group: "tools",
@@ -342,7 +342,7 @@ export const CORE_CLI_COMMANDS = [
       ["moshcode crypto bars ETH --timeframe 1Hour", "historical OHLCV"],
       ["moshcode crypto book BTC-USD --depth 5", "top of book, both sides"],
     ],
-    seeAlso: ["ticker", "trade", "plugin"],
+    seeAlso: ["stocks", "trade", "plugin"],
     note: "research aid, not advice — prices are Alpaca's US crypto venue alone and can differ materially from other exchanges. Crypto trades 24/7 with no circuit breakers. Set MOSHCODE_ADVISOR_URL to point at another instance.",
   },
   { name: "coins", aliasOf: "crypto", description: "alias for crypto" },
@@ -357,7 +357,7 @@ export const CORE_CLI_COMMANDS = [
       ["moshcode plugin install", "add the marketplace and install ticker"],
       ["moshcode plugin list", "what this marketplace ships, and what is installed"],
     ],
-    seeAlso: ["skill", "mcp", "ticker"],
+    seeAlso: ["skill", "mcp", "stocks"],
     note: "Claude Code is the only engine with a plugin primitive; the others are reported as skipped, exactly as they are for skills.",
   },
   { name: "plugins", aliasOf: "plugin", description: "alias for plugin" },
@@ -539,42 +539,42 @@ export const DNS_VERBS = [
 ];
 
 /**
- * `ticker`'s verbs.
+ * `stocks`'s verbs.
  *
  * `report` exists so a symbol that collides with a verb name still has an
  * unambiguous spelling; without it, the bare-symbol shortcut would have no
  * escape hatch. src/advisor.mjs owns the parser and test/advisor.test.mjs
  * fails when the two lists disagree.
  */
-export const TICKER_VERBS = [
-  { name: "report", description: "the stored research report for one ticker", synopsis: [["moshcode ticker report <symbol>", "same as `moshcode ticker <symbol>`"]] },
-  { name: "signals", description: "every extracted signal for a ticker", synopsis: [["moshcode ticker signals <symbol>", ""]] },
+export const STOCKS_VERBS = [
+  { name: "report", description: "the stored research report for one ticker", synopsis: [["moshcode stocks report <symbol>", "same as `moshcode stocks <symbol>`"]] },
+  { name: "signals", description: "every extracted signal for a ticker", synopsis: [["moshcode stocks signals <symbol>", ""]] },
   {
     name: "search", description: "full-text search across indexed transcripts",
-    synopsis: [["moshcode ticker search <words…> [--limit n]", ""]],
+    synopsis: [["moshcode stocks search <words…> [--limit n]", ""]],
   },
   {
     name: "lookup", description: "find a ticker by company name",
-    synopsis: [["moshcode ticker lookup <company…> [--limit n]", "rivian → RIVN"]],
+    synopsis: [["moshcode stocks lookup <company…> [--limit n]", "rivian → RIVN"]],
   },
   {
     name: "reports", description: "every stored report",
-    synopsis: [["moshcode ticker reports [--sort recent|score|ticker] [--limit n]", ""]],
+    synopsis: [["moshcode stocks reports [--sort recent|score|ticker] [--limit n]", ""]],
   },
   {
     name: "discover", description: "a ranked watchlist for a topic",
-    synopsis: [["moshcode ticker discover [topic…] [--horizon 1|2] [--provider p] [--limit n]", ""]],
+    synopsis: [["moshcode stocks discover [topic…] [--horizon 1|2] [--provider p] [--limit n]", ""]],
     note: "ranks by analyzing each candidate — this one takes minutes, not milliseconds.",
   },
-  { name: "tickers", description: "every ticker present in the index", synopsis: [["moshcode ticker tickers", ""]] },
-  { name: "stats", description: "index coverage counts", synopsis: [["moshcode ticker stats", ""]] },
-  { name: "open", description: "open the shareable report page in a browser", synopsis: [["moshcode ticker open <symbol>", ""]] },
+  { name: "tickers", description: "every ticker present in the index", synopsis: [["moshcode stocks tickers", ""]] },
+  { name: "stats", description: "index coverage counts", synopsis: [["moshcode stocks stats", ""]] },
+  { name: "open", description: "open the shareable report page in a browser", synopsis: [["moshcode stocks open <symbol>", ""]] },
 ];
 
 /**
  * `crypto`'s verbs.
  *
- * `report` earns its place for the same reason ticker's does — a bare pair is
+ * `report` earns its place for the same reason stocks's does — a bare pair is
  * the shortcut, so a pair that collides with a verb name needs a spelling that
  * cannot be mistaken for one. src/crypto.mjs owns the parser and
  * test/crypto.test.mjs fails when the two lists disagree.
@@ -626,7 +626,7 @@ export const VERB_TABLES = {
   UPGRADE_TARGETS,
   DNS_VERBS,
   TRADE_VERBS,
-  TICKER_VERBS,
+  STOCKS_VERBS,
   CRYPTO_VERBS,
   PLUGIN_VERBS,
 };
@@ -655,7 +655,7 @@ export const PIT_COMMANDS = [
     description: "list workflow tools, or run one" },
   { name: "trade", args: "<verb> [args…]", cli: "trade",
     description: "look up markets and preview/place Alpaca orders" },
-  { name: "ticker", aliases: ["advisor"], args: "<symbol|verb> [args…]", cli: "ticker",
+  { name: "stocks", aliases: ["advisor"], args: "<symbol|verb> [args…]", cli: "stocks",
     description: "equity research from advis0r.com" },
   { name: "crypto", aliases: ["coins"], args: "<pair|verb> [args…]", cli: "crypto",
     description: "crypto market data from advis0r.com" },

package/src/crypto.mjs

@@ -5,8 +5,8 @@
 // function of the decoded JSON. Every route is public and read-only, so there
 // is no login verb and no write verb — `moshcode trade` is where orders live.
 //
-// This is a *sibling* of `ticker`, not a mode of it, because the two answer
-// different questions from different data. A ticker report is a stored snapshot
+// This is a *sibling* of `stocks`, not a mode of it, because the two answer
+// different questions from different data. A stocks report is a stored snapshot
 // built from transcripts, SEC fundamentals and extracted signals. A crypto
 // report is a live read of Alpaca's US crypto venue: no transcripts, no
 // filings, no signals, and a `fetchedAt` measured in seconds rather than days.
@@ -50,7 +50,7 @@ export const CRYPTO_VERB_NAMES = [
   "report", "quote", "snapshot", "technicals", "bars", "book", "spark", "assets", "lookup", "open",
 ];
 
-// The same reasoning as ticker's alias table: `/crypto price BTC` and
+// The same reasoning as stocks's alias table: `/crypto price BTC` and
 // `/crypto candles BTC` should not be errors when the intent is obvious.
 // `search` maps to lookup rather than erroring — crypto has no transcript
 // index to search, and a directory lookup is what the word means here.
@@ -83,7 +83,7 @@ export function resolveVerb(word) {
  * the API resolves it to that asset's USD pair, and inventing the `-USD` here
  * would silently break the day a base has no USD pair.
  *
- * Deliberately narrow, like ticker's: the whole job of the check is to tell
+ * Deliberately narrow, like stocks's: the whole job of the check is to tell
  * `BTC` from `bitcoin` and send the second one to lookup with a useful message
  * instead of a 400. Bases run to five characters (SUSHI, MATIC, TRUMP), so six
  * leaves room for the concatenated `BTCUSD` spelling without swallowing words.
@@ -293,7 +293,7 @@ export function cryptoUrl(request, { base = advisorBase() } = {}) {
  * Execute a translated request. `fetchImpl` is injectable for tests.
  *
  * Every crypto route is a live venue read, so one timeout fits all of them —
- * unlike ticker, which has to budget separately for `discover`'s per-candidate
+ * unlike stocks, which has to budget separately for `discover`'s per-candidate
  * analysis.
  */
 export async function fetchCrypto(request, { fetchImpl = globalThis.fetch, base = advisorBase(), timeoutMs = 45_000 } = {}) {

package/src/help.mjs

@@ -103,6 +103,18 @@ function distance(a, b) {
   return prev[b.length];
 }
 
+/**
+ * Commands that were renamed, and what they became.
+ *
+ * Edit distance cannot help here — `ticker` is nowhere near `stocks` — so a
+ * rename that isn't recorded leaves people with a bare "unknown command" for a
+ * verb that worked yesterday. This is deliberately *not* an alias table: the
+ * old name stays dead, it just says where its replacement went.
+ */
+export const RENAMED_COMMANDS = {
+  ticker: "stocks",
+};
+
 /**
  * The nearest command to something that is not one, or null.
  *
@@ -114,6 +126,8 @@ function distance(a, b) {
 export function suggest(input, extra = []) {
   const typed = String(input ?? "").toLowerCase();
   if (!typed) return null;
+  // A known rename beats any distance match — it is not a guess.
+  if (RENAMED_COMMANDS[typed]) return RENAMED_COMMANDS[typed];
   const candidates = [...CORE_CLI_COMMANDS.map((c) => c.name), ...extra]
     .filter((n) => !n.startsWith("-"));
 

package/src/integrations.mjs

@@ -10,7 +10,7 @@ import {
 } from "./skills.mjs";
 import {
   MARKETPLACE_NAME, PLUGINS, PLUGIN_ENGINES, marketplaceSource, planPluginCommand,
-  pluginId, resolvePlugin, runPluginCommand,
+  pluginId, resolvePlugin, resolveRetiredPlugin, runPluginCommand,
 } from "./plugins.mjs";
 import { catalogList, resolveCatalog } from "./mcp-catalog.mjs";
 import { MCP_VERBS, PLUGIN_VERBS, SKILL_VERBS } from "./cli-schema.mjs";
@@ -315,10 +315,22 @@ export async function pluginCommand(tokens, { run, installedSet } = {}) {
   const stray = rest.find((t) => String(t).startsWith("-"));
   if (stray) { console.log(err(`unknown plugin flag "${stray}"`)); return 1; }
 
-  const plugin = resolvePlugin(rest[0]);
+  let plugin = resolvePlugin(rest[0]);
   if (!plugin) {
-    console.log(err(`unknown plugin "${rest[0]}" — this marketplace ships ${PLUGINS.map((p) => p.name).join(", ")}`));
-    return 1;
+    // A retired name still has to be removable: the old plugin is installed in
+    // someone's engine right now, and installing its replacement puts a second
+    // copy of the same slash commands beside it rather than replacing it.
+    const retired = resolveRetiredPlugin(rest[0]);
+    if (retired && verb === "remove") {
+      plugin = { name: retired.name, description: `retired — renamed to ${retired.renamedTo}`, commands: [] };
+    } else if (retired) {
+      console.log(err(`"${retired.name}" is now "${retired.renamedTo}" — install ${bone(pluginId(retired.renamedTo))}`));
+      console.log(info(`already have the old one? ${bone(`moshcode plugin remove ${retired.name}`)} first`));
+      return 1;
+    } else {
+      console.log(err(`unknown plugin "${rest[0]}" — this marketplace ships ${PLUGINS.map((p) => p.name).join(", ")}`));
+      return 1;
+    }
   }
 
   const source = marketplaceSource();

package/src/plugins.mjs

@@ -29,9 +29,9 @@ export function marketplaceSource(env = process.env) {
 /** The plugins this marketplace ships. Mirrors .claude-plugin/marketplace.json. */
 export const PLUGINS = [
   {
-    name: "ticker",
+    name: "stocks",
     description: "equity research slash commands backed by advis0r.com",
-    commands: ["/ticker", "/signals", "/research", "/lookup", "/reports", "/discover"],
+    commands: ["/stocks", "/signals", "/research", "/lookup", "/reports", "/discover"],
   },
   {
     name: "crypto",
@@ -42,12 +42,38 @@ export const PLUGINS = [
 
 export const DEFAULT_PLUGIN = PLUGINS[0].name;
 
+/**
+ * Plugins this marketplace no longer ships, and what replaced them.
+ *
+ * A renamed plugin is not the same problem as a renamed command. The old
+ * command simply stops existing; an old *plugin* is still sitting installed in
+ * someone's engine, still serving its slash commands, and the new one installs
+ * alongside it rather than over it — so `/stocks` would resolve to two plugins
+ * at once. Removal therefore has to keep reaching a name that install refuses.
+ */
+export const RETIRED_PLUGINS = [
+  { name: "ticker", renamedTo: "stocks" },
+];
+
 export function resolvePlugin(name) {
   if (!name) return PLUGINS.find((p) => p.name === DEFAULT_PLUGIN) ?? null;
   const key = String(name).toLowerCase().replace(/@.*$/, "");
   return PLUGINS.find((p) => p.name === key) ?? null;
 }
 
+/**
+ * A retired plugin by its old name, or null.
+ *
+ * Deliberately separate from resolvePlugin: `remove ticker` must work so the
+ * stale install can be cleaned up, and `install ticker` must not, or the rename
+ * never actually happens.
+ */
+export function resolveRetiredPlugin(name) {
+  if (!name) return null;
+  const key = String(name).toLowerCase().replace(/@.*$/, "");
+  return RETIRED_PLUGINS.find((p) => p.name === key) ?? null;
+}
+
 /** Fully-qualified plugin id, the form `claude plugin install` disambiguates with. */
 export function pluginId(name) {
   return `${name}@${MARKETPLACE_NAME}`;

package/src/tui.mjs

@@ -20,12 +20,12 @@ import { fetchMotdAd } from "./ads.mjs";
 import { runScript } from "./runtime.mjs";
 import { moshVocabulary } from "./commands.mjs";
 import { mcpCommand, pluginCommand, skillCommand } from "./integrations.mjs";
-import { tickerCommand } from "./advisor.mjs";
+import { stocksCommand } from "./advisor.mjs";
 import { cryptoCommand } from "./crypto.mjs";
 import { canOpenBrowser, openBrowser } from "./open-url.mjs";
 import { banner, hr, acid, ash, bone, dim, ok, err, warn, info, moshcodeVersion } from "./ui.mjs";
 import { CORE_CLI_COMMAND_NAMES } from "./cli-schema.mjs";
-import { findPitCommand, pitHelpModel, renderPitCommand, suggest, wantsHelp } from "./help.mjs";
+import { RENAMED_COMMANDS, findPitCommand, pitHelpModel, renderPitCommand, suggest, wantsHelp } from "./help.mjs";
 import { openNewTab } from "./tabs.mjs";
 
 const PROMPT = () => acid("mosh ") + dim("▸ ");
@@ -673,13 +673,13 @@ export async function tui() {
       rl = mkrl();
       continue;
     }
-    // `/ticker` renders in the pit rather than handing the terminal to a tool:
+    // `/stocks` renders in the pit rather than handing the terminal to a tool:
     // there is no advis0r binary to launch, only a public read-only API.
-    if (cmd === "ticker" || cmd === "advisor") {
-      await tickerCommand(rest, { openUrl: (url) => canOpenBrowser() && openBrowser(url) });
+    if (cmd === "stocks" || cmd === "advisor") {
+      await stocksCommand(rest, { openUrl: (url) => canOpenBrowser() && openBrowser(url) });
       continue;
     }
-    // `/crypto` renders in the pit for the same reason `/ticker` does: there is
+    // `/crypto` renders in the pit for the same reason `/stocks` does: there is
     // no crypto binary to hand the terminal to, only a public read-only API.
     if (cmd === "crypto" || cmd === "coins") {
       await cryptoCommand(rest, { openUrl: (url) => canOpenBrowser() && openBrowser(url) });
@@ -722,7 +722,12 @@ export async function tui() {
       rl = mkrl();
       continue;
     }
-    console.log(err(`unknown command "${line}". /help for the list.`));
+    // A renamed verb gets pointed at its replacement; `/ticker` was a pit
+    // command for a release, so a bare "unknown command" is a dead end here.
+    const renamed = RENAMED_COMMANDS[cmd];
+    console.log(err(renamed
+      ? `unknown command "${line}" — /${cmd} is now /${renamed}.`
+      : `unknown command "${line}". /help for the list.`));
   }
 
   try { rl.close(); } catch { /* noop */ }