moshcode 0.25.1 → 0.27.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
+  "name": "moshcode",
+  "description": "moshcode's own Claude Code plugins — the pit's slash commands, in your engine",
+  "owner": {
+    "name": "moshcoder",
+    "url": "https://moshcode.sh"
+  },
+  "plugins": [
+    {
+      "name": "ticker",
+      "description": "Equity research slash commands backed by advis0r.com: scored reports, extracted signals, transcript search, company-name lookup, and ranked watchlists.",
+      "source": "./plugins/ticker",
+      "category": "productivity",
+      "author": {
+        "name": "moshcoder",
+        "url": "https://moshcode.sh"
+      },
+      "homepage": "https://github.com/moshcoder/moshcode#ticker",
+      "keywords": ["stocks", "equity", "research", "markets", "advis0r"]
+    },
+    {
+      "name": "crypto",
+      "description": "Crypto market data slash commands backed by advis0r.com: live prices, technical scores, order books, OHLCV history and sparklines across Alpaca's US crypto venue.",
+      "source": "./plugins/crypto",
+      "category": "productivity",
+      "author": {
+        "name": "moshcoder",
+        "url": "https://moshcode.sh"
+      },
+      "homepage": "https://github.com/moshcoder/moshcode#crypto",
+      "keywords": ["crypto", "bitcoin", "markets", "prices", "advis0r"]
+    }
+  ]
+}

package/README.md

@@ -46,6 +46,9 @@ 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 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 |
 | `moshcode completion` | extend | print a shell completion script |
 | `moshcode run` | script | run a moshscript |
@@ -211,6 +214,80 @@ 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`)
+
+Where `trade` is Alpaca's order book, `ticker` 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
+```
+
+Add `--json` to any of them for the raw response. The same facade is `/ticker …`
+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.
+
+### Crypto market data (`moshcode crypto`)
+
+`crypto` is `ticker`'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.
+
+```sh
+moshcode crypto BTC                     # price, technicals, score, supply, order book
+moshcode crypto lookup bitcoin          # asset name → BTC/USD
+moshcode crypto quote ETH-USD           # latest trade + quote, spread in bps
+moshcode crypto spark BTC ETH SOL       # recent moves across pairs, as sparklines
+moshcode crypto bars ETH-USD --timeframe 1Hour   # historical OHLCV
+moshcode crypto book BTC-USD --depth 5  # top of book, both sides
+moshcode crypto assets                  # every supported pair
+moshcode crypto open BTC                # the shareable page
+```
+
+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 —
+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.
+
+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.
+
+### Social posting from the pit
+
+The pit can hand a prepared post to Bluesky or Nostr without storing either
+account's credentials in MoshCode:
+
+```text
+/socials
+/post bsky "shipped it 🤘"
+/post nostr "shipped it 🤘"
+```
+
+Bluesky opens its official compose intent. Nostr opens the MoshCode composer,
+connects to a NIP-07 browser signer (or a NIP-46 bunker through
+[`window.nostr.js`](https://github.com/fiatjaf/window.nostr.js)), signs a kind-1
+event, and publishes it to the displayed relays. Both flows leave the final
+confirmation in the browser. If the pit is remote or headless, `/post` prints
+the composer URL instead.
+
 ## Browser terminal (`moshcode console`)
 
 A real terminal in the browser — arrow keys, history, full-screen TUIs — because
@@ -287,6 +364,43 @@ from and five to rotate. Porkbun's API access is off by default and enabled
 per-domain — and its documentation tools work with no keys at all, which is a
 sensible way to try the server before trusting it with DNS writes.
 
+## Claude Code plugins
+
+MoshCode publishes its own plugin marketplace, so the pit's slash commands work
+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 crypto    # add the marketplace + install `crypto`
+moshcode plugin remove ticker     # take it back off
+```
+
+`ticker@moshcode` adds `/ticker`, `/signals`, `/research`, `/lookup`,
+`/reports`, and `/discover` — the same advis0r research surface described above,
+driven from inside a coding session.
+
+`crypto@moshcode` adds `/crypto`, `/quote`, `/book`, `/bars`, `/spark`,
+`/pairs`, and `/coin`. It ships separately because it is a different surface,
+not a mode of the first: live venue reads instead of stored snapshots, and a
+score that must not be ranked against an equity's.
+
+Restart the engine after installing either; a newly installed plugin is not live
+in a session that is already running.
+
+The equivalent by hand:
+
+```sh
+claude plugin marketplace add moshcoder/moshcode
+claude plugin install ticker@moshcode
+claude plugin install crypto@moshcode
+```
+
+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
+checkout instead of GitHub, which is how you try an unreleased plugin.
+
 ## Upgrade everything
 
 ```sh

package/bin/moshcode.mjs

@@ -19,7 +19,10 @@ import { tradeArgs, tradeUsage } from "../src/trade.mjs";
 import { runUpgrade } from "../src/upgrade.mjs";
 import { selfUpdateCommand } from "../src/selfupdate.mjs";
 import { describeUninstall, uninstallPlan } from "../src/uninstall.mjs";
-import { mcpCommand, skillCommand } from "../src/integrations.mjs";
+import { mcpCommand, pluginCommand, skillCommand } from "../src/integrations.mjs";
+import { tickerCommand } 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";
 import { createPrd, listPrds, authoringPrompt } from "../src/prd.mjs";
 import { loginAuto, whoami, logout } from "../src/auth.mjs";
@@ -344,6 +347,25 @@ async function main() {
     propagateExit(r.code, r.signal);
     return;
   }
+  if (cmd === "ticker" || cmd === "advisor") {
+    const code = await tickerCommand(rest, {
+      openUrl: (url) => canOpenBrowser() && openBrowser(url),
+    });
+    if (code) process.exitCode = code;
+    return;
+  }
+  if (cmd === "crypto" || cmd === "coins") {
+    const code = await cryptoCommand(rest, {
+      openUrl: (url) => canOpenBrowser() && openBrowser(url),
+    });
+    if (code) process.exitCode = code;
+    return;
+  }
+  if (cmd === "plugin" || cmd === "plugins") {
+    const code = await pluginCommand(rest);
+    if (code) process.exitCode = code;
+    return;
+  }
   if (cmd === "console") {
     const code = await consoleCommand(rest);
     if (code) process.exitCode = code;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moshcode",
-  "version": "0.25.1",
+  "version": "0.27.0",
   "type": "module",
   "description": "moshcode — a metal wrapper for coding engines and native UGig/CoinPay workflow CLIs, with OpenPRD and moshscript",
   "repository": {
@@ -25,6 +25,8 @@
     "src",
     "examples",
     "prd",
+    ".claude-plugin",
+    "plugins",
     "install.sh",
     "README.md"
   ],

package/plugins/crypto/.claude-plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
+  "name": "crypto",
+  "description": "Crypto market data slash commands backed by advis0r.com: live prices, technical scores, order books, OHLCV history and sparklines across Alpaca's US crypto venue.",
+  "version": "0.1.0",
+  "author": {
+    "name": "moshcoder",
+    "url": "https://moshcode.sh"
+  },
+  "homepage": "https://github.com/moshcoder/moshcode#crypto",
+  "license": "MIT",
+  "keywords": ["crypto", "bitcoin", "markets", "prices", "advis0r"]
+}

package/plugins/crypto/README.md

@@ -0,0 +1,66 @@
+# crypto — market data in your engine 🤘
+
+Slash commands backed by [advis0r.com](https://advis0r.com/api/crypto): live
+prices, technical scores, order books, OHLCV history and multi-pair sparklines
+across Alpaca's US crypto venue.
+
+| command | what it does |
+| --- | --- |
+| `/crypto BTC` | price, technicals, score, supply, order book |
+| `/quote ETH-USD` | latest trade and quote, with the spread in bps |
+| `/book BTC-USD` | top of the order book, both sides |
+| `/bars ETH-USD` | historical OHLCV at any supported timeframe |
+| `/spark BTC ETH SOL` | recent moves across pairs, ranked |
+| `/pairs` | every supported pair, grouped by quote asset |
+| `/coin bitcoin` | asset name → `BTC/USD` |
+
+Pairs are accepted as `BTC`, `BTC-USD`, `BTC/USD` or `BTCUSD`. A bare asset
+resolves to that asset's USD pair.
+
+## Install
+
+```bash
+moshcode plugin install crypto
+```
+
+Or straight from Claude Code:
+
+```bash
+claude plugin marketplace add moshcoder/moshcode
+claude plugin install crypto@moshcode
+```
+
+Restart the engine afterwards — a newly installed plugin is not live in a
+session that is already running.
+
+## How it works
+
+Each command shells out to `moshcode crypto …`, 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.
+
+Point the commands at another instance with `MOSHCODE_ADVISOR_URL`.
+
+## Why this is separate from `ticker`
+
+They answer different questions from different data, and share only a hostname.
+A `/ticker` 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
+the second and stale by the time you act on it.
+
+The scores are not comparable either. The crypto technical score counts
+venue-local liquidity, so ranking a coin against an equity by score is
+meaningless. Both surfaces ship their own `caveats`, and both commands are
+instructed to print them.
+
+## What this is not
+
+A 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 — there is no close, no premarket, and no halt.
+
+Trading lives behind a different verb: `moshcode trade` wraps Alpaca, previews
+orders by default, and requires an explicit `--submit`. Nothing in this plugin
+can place an order.

package/plugins/crypto/commands/bars.md

@@ -0,0 +1,35 @@
+---
+description: Historical crypto OHLCV for one pair, at any supported timeframe.
+argument-hint: <PAIR> [timeframe]
+allowed-tools: Bash(moshcode crypto:*), Bash(curl -sS https://advis0r.com/api/crypto/:*)
+---
+
+## Task
+
+Pull historical bars for `$ARGUMENTS`.
+
+```bash
+moshcode crypto bars $ARGUMENTS --timeframe 1Day --limit 30 --json
+```
+
+Timeframes: `1Min`, `5Min`, `15Min`, `1Hour`, `1Day`, `1Week`. Add
+`--start`/`--end` (ISO dates) to pin a window.
+
+Fallback: `curl -sS "https://advis0r.com/api/crypto/bars?symbol=<PAIR>&timeframe=1Day&limit=30"`
+
+## Reading the response
+
+`bars` is keyed by canonical symbol (`"BTC/USD"`), each value an ascending array
+of `{ timestamp, open, high, low, close, volume, vwap }`.
+
+## Rules
+
+- **`limit` is upstream's page size, not a cap on what returns.** The response
+  can hold more bars than you asked for. If you show a subset, say which subset
+  — "the 5 most recent of 17", never a silent truncation.
+- Bars are ascending by time. Confirm the direction before calling a move.
+- `volume` is base-asset units on Alpaca's US venue alone, not aggregate market
+  volume. Do not compare it to a CoinGecko or exchange-aggregate figure.
+- Crypto bars are calendar-based and continuous — no gaps, no sessions, no
+  weekends. A "20-day" window here is not 20 trading sessions.
+- End with the response's own `disclaimer`.

package/plugins/crypto/commands/book.md

@@ -0,0 +1,31 @@
+---
+description: Top of the crypto order book, both sides, with the spread.
+argument-hint: <PAIR>
+allowed-tools: Bash(moshcode crypto:*), Bash(curl -sS https://advis0r.com/api/crypto/:*)
+---
+
+## Task
+
+Show the order book for `$ARGUMENTS`.
+
+```bash
+moshcode crypto book $ARGUMENTS --depth 10 --json
+```
+
+Fallback: `curl -sS "https://advis0r.com/api/crypto/orderbook?symbol=$ARGUMENTS&depth=10"`
+
+## Reading the response
+
+`orderbooks[]` each carry a `timestamp`, `bids[]` and `asks[]`, every level a
+`{ price, size }`. Bids descend from the best bid; asks ascend from the best ask.
+
+## Rules
+
+- Report the spread in basis points, not just in dollars — a $50 spread means
+  something different on BTC than on ETH.
+- **Size is depth on one venue, not the market.** Do not describe the book as
+  "the market's" depth, and do not extrapolate what a large order would fill at.
+- A book is a snapshot of an instant. Timestamp it.
+- If one side is much thinner than the other, say so plainly rather than
+  reading it as a directional signal — it is a liquidity observation.
+- End with the response's own `disclaimer`.

package/plugins/crypto/commands/coin.md

@@ -0,0 +1,31 @@
+---
+description: Find a crypto pair by asset name (bitcoin → BTC/USD).
+argument-hint: <asset name>
+allowed-tools: Bash(moshcode crypto:*), Bash(curl -sS https://advis0r.com/api/crypto/:*)
+---
+
+## Task
+
+Resolve `$ARGUMENTS` to a tradable pair.
+
+```bash
+moshcode crypto lookup $ARGUMENTS --limit 10 --json
+```
+
+Fallback: `curl -sS "https://advis0r.com/api/crypto/lookup?q=<url-encoded>&limit=10"`
+
+## Reading the response
+
+`matches` is a list of `{ symbol, slug, base, quote, name }`.
+
+## Rules
+
+- One coin usually returns several pairs — `BTC/USD`, `BTC/USDC`, `BTC/USDT`.
+  Show them all and say which quote asset each settles in; default to the USD
+  pair unless the user asked otherwise.
+- Watch for name collisions: a query can match a different coin whose name
+  merely contains the words ("bitcoin" also returns Bitcoin Cash). Say which
+  match is the one they meant.
+- No match: say this venue lists no such pair, and do not invent a symbol. The
+  coin may exist and simply not be listed here — those are different answers.
+- Offer `/crypto <PAIR>` for the match you land on.

package/plugins/crypto/commands/crypto.md

@@ -0,0 +1,50 @@
+---
+description: Research one crypto pair — price, technicals, score, supply and order book.
+argument-hint: <PAIR>
+allowed-tools: Bash(moshcode crypto:*), Bash(curl -sS https://advis0r.com/api/crypto/:*)
+---
+
+## Task
+
+Pull the full report for `$ARGUMENTS` and summarize it for the user.
+
+Run:
+
+```bash
+moshcode crypto $ARGUMENTS --json
+```
+
+If `moshcode` is not installed, fall back to the API directly:
+
+```bash
+curl -sS "https://advis0r.com/api/crypto/report?symbol=$ARGUMENTS"
+```
+
+Pairs are accepted as `BTC`, `BTC-USD`, `BTC/USD` or `BTCUSD`. A bare asset
+resolves to that asset's USD pair.
+
+## Reading the response
+
+- `snapshot` is the live read: `latestTrade`, `latestQuote` (bid/ask),
+  `dailyBar`, `prevDailyBar`, and a `change` against yesterday's close.
+- `technical` holds sma / ema / rsi14 / macd / bollinger / atr14 /
+  `relativeVolume` / `momentum` / `trend` / `volatilityRegime`.
+- `technicalScore.score` is 0–100 with a `breakdown`. It is **technical only** —
+  there is no thesis, no transcript and no filing behind a crypto pair.
+- `fundamentals` is CoinGecko supply data: market cap, rank, circulating and max
+  supply, 24h volume, all-time high. It is absent for many pairs.
+- `caveats` are per-response and specific. Read them before quoting the score.
+
+## Rules
+
+- **These prices are Alpaca's US crypto venue alone.** Say so. They can differ
+  materially from Coinbase, Binance, or an aggregate index.
+- 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.
+- 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
+  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/crypto/commands/pairs.md

@@ -0,0 +1,31 @@
+---
+description: Every crypto pair advis0r can price, and which are trading.
+allowed-tools: Bash(moshcode crypto:*), Bash(curl -sS https://advis0r.com/api/crypto/:*)
+---
+
+## Task
+
+List the supported pairs.
+
+```bash
+moshcode crypto assets --json
+```
+
+Fallback: `curl -sS "https://advis0r.com/api/crypto/assets"`
+
+## Reading the response
+
+`assets[]` are `{ symbol, slug, base, quote, name, status }`. `slug` is the
+URL-safe spelling (`BTC-USD`) used in paths; `symbol` is canonical (`BTC/USD`).
+`status` is `live` or `idle`.
+
+## Rules
+
+- Group by `quote` asset. The same coin priced in USD, USDT and BTC are three
+  different markets with three different liquidity profiles.
+- **`idle` means listed but not currently printing trades** — it is not the same
+  as unsupported. Show idle pairs, marked, rather than filtering them out.
+- If the user was looking for a specific coin, use `/coin <name>` instead of
+  scanning this list for them.
+- This is the coverage of one venue, not of crypto. A coin missing here is
+  missing *from Alpaca's US venue*.

package/plugins/crypto/commands/quote.md

@@ -0,0 +1,31 @@
+---
+description: The latest crypto trade and quote, with the bid/ask spread.
+argument-hint: <PAIR>
+allowed-tools: Bash(moshcode crypto:*), Bash(curl -sS https://advis0r.com/api/crypto/:*)
+---
+
+## Task
+
+Get the current quote for `$ARGUMENTS`.
+
+```bash
+moshcode crypto quote $ARGUMENTS --json
+```
+
+Fallback: `curl -sS "https://advis0r.com/api/crypto/quote?symbol=$ARGUMENTS"`
+
+## Reading the response
+
+`quotes[]` each carry `latestTrade` (price, size, timestamp), `latestQuote`
+(bidPrice/bidSize/askPrice/askSize), `spread`, `spreadBps`, and `mid`.
+
+## Rules
+
+- Give the price at the precision the pair trades at. SHIB near $0.000006
+  rounded to two decimals is "$0.00", which is wrong, not concise.
+- **`spreadBps` is the cost of crossing.** A wide spread means thin liquidity on
+  this venue — report it alongside the price rather than burying it.
+- `latestTrade.timestamp` and `latestQuote.timestamp` can differ. If the last
+  trade is old, the mid is a quote, not evidence of a trade at that level.
+- Prices are Alpaca's US crypto venue and trade 24/7 — never "at the close".
+- End with the response's own `disclaimer`.

package/plugins/crypto/commands/spark.md

@@ -0,0 +1,36 @@
+---
+description: Compare recent moves across several crypto pairs at once.
+argument-hint: <PAIR> [PAIR…]
+allowed-tools: Bash(moshcode crypto:*), Bash(curl -sS https://advis0r.com/api/crypto/:*)
+---
+
+## Task
+
+Compare recent price action across `$ARGUMENTS`.
+
+```bash
+moshcode crypto spark $ARGUMENTS --period 24h --json
+```
+
+`--period` is `24h` or `7d`. Up to 20 pairs per call. With no pairs given, ask
+which ones — or offer the majors (BTC, ETH, SOL).
+
+Fallback: `curl -sS "https://advis0r.com/api/crypto/sparklines?symbols=BTC-USD,ETH-USD&period=24h"`
+
+## Reading the response
+
+`series` is keyed by canonical symbol, each with `points[]` (closes, ascending),
+`first`, `last`, `changePercent`, and the `start`/`end` of the window.
+
+## Rules
+
+- Lead with `changePercent` per pair and rank them — that is the question a
+  multi-pair call is asking.
+- **Each series is scaled to itself.** A dramatic-looking shape on one pair and
+  a flat one on another can be the same percentage move; compare the numbers,
+  not the shapes.
+- Name the window (`start` → `end`) and the period. "Up 5%" over 24h and over 7d
+  are different claims.
+- Do not extrapolate a trend from 24 points, and do not call a direction
+  "momentum" without the technicals to back it — `/crypto <PAIR>` has those.
+- End with the response's own `disclaimer`.

package/plugins/ticker/.claude-plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
+  "name": "ticker",
+  "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",
+  "license": "MIT",
+  "keywords": ["stocks", "equity", "research", "markets", "advis0r"]
+}

package/plugins/ticker/README.md

@@ -0,0 +1,49 @@
+# ticker — 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,
+and ranked watchlists.
+
+| command | what it does |
+| --- | --- |
+| `/ticker 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) |
+
+## Install
+
+```bash
+moshcode plugin install
+```
+
+Or straight from Claude Code:
+
+```bash
+claude plugin marketplace add moshcoder/moshcode
+claude plugin install ticker@moshcode
+```
+
+Restart the engine afterwards — a newly installed plugin is not live in a
+session that is already running.
+
+## How it works
+
+Each command shells out to `moshcode ticker …`, 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.
+
+Point the commands at another instance with `MOSHCODE_ADVISOR_URL`.
+
+## What this is not
+
+A research aid, not advice. Reports are **stored snapshots** — every response
+carries `reportGeneratedAt`, and every command is instructed to print it, because
+a stale price presented as a live one is the one failure mode that actually costs
+someone money. Scores marked `offline` come from deterministic rules, not a model.
+
+Trading lives behind a different verb: `moshcode trade` wraps Alpaca, previews
+orders by default, and requires an explicit `--submit`. Nothing in this plugin
+can place an order.

package/plugins/ticker/commands/discover.md

@@ -0,0 +1,37 @@
+---
+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/:*)
+---
+
+## Task
+
+Rank candidates for `$ARGUMENTS` (no topic → the default watchlist).
+
+```bash
+moshcode ticker 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"`
+
+**This route runs an analysis per candidate and can take minutes.** Tell the
+user it is working before you start, and do not retry on a timeout — re-running
+it costs the same minutes again.
+
+## Reading the response
+
+`candidates` is ranked, each with `rank`, `ticker`, `companyName`, `lastPrice`,
+`overallScore`, `confidence`, `classification`, `thesis`, `primaryCatalyst`,
+`mainRisk`, `independentConfirmation`, plus liquidity fields
+(`bidAskSpreadPercent`, `avgVolume`, `float`, `marketCap`).
+
+## Rules
+
+- Lead with `rank`, `ticker`, `overallScore`, and `classification`.
+- **Print `mainRisk` next to every thesis.** A ranked list that shows only the
+  bull case is a pitch, not research.
+- `provider: offline` means these scores are deterministic rules, not a model.
+  Say which provider produced the ranking.
+- Flag illiquidity: a wide `bidAskSpreadPercent` or thin `avgVolume` matters
+  more than the score for anything small-cap.
+- End with the response's own `disclaimer`.