moshcode 0.25.0 → 0.26.0

package/src/cli-schema.mjs

@@ -289,6 +289,48 @@ export const CORE_CLI_COMMANDS = [
     seeAlso: ["tools", "install"],
     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",
+    group: "tools",
+    description: "equity research from advis0r.com",
+    synopsis: [
+      ["moshcode ticker <symbol>", "the stored research report for one ticker"],
+      ["moshcode ticker <verb> [args…]", ""],
+    ],
+    verbs: "TICKER_VERBS",
+    flags: [
+      ["--json", "print the raw API response", ""],
+      ["--limit <n>", "cap results (search/lookup/reports/discover)", "the API's own default"],
+      ["--sort <s>", "reports order: recent | score | ticker", "score"],
+      ["--horizon <n>", "discover: quarters to look ahead (1 or 2)", "2"],
+      ["--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"],
+    ],
+    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: "plugin",
+    group: "extend",
+    description: "install moshcode's slash commands into Claude Code",
+    synopsis: [["moshcode plugin <verb> [name]", ""]],
+    verbs: "PLUGIN_VERBS",
+    flags: [["--json", "machine-readable", ""]],
+    examples: [
+      ["moshcode plugin install", "add the marketplace and install ticker"],
+      ["moshcode plugin list", "what this marketplace ships, and what is installed"],
+    ],
+    seeAlso: ["skill", "mcp", "ticker"],
+    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" },
   {
     name: "commands",
     group: "script",
@@ -466,6 +508,51 @@ export const DNS_VERBS = [
   { name: "trust", description: "trust one name's certificate, after checking it against the registry pin" },
 ];
 
+/**
+ * `ticker`'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>", ""]] },
+  {
+    name: "search", description: "full-text search across indexed transcripts",
+    synopsis: [["moshcode ticker search <words…> [--limit n]", ""]],
+  },
+  {
+    name: "lookup", description: "find a ticker by company name",
+    synopsis: [["moshcode ticker lookup <company…> [--limit n]", "rivian → RIVN"]],
+  },
+  {
+    name: "reports", description: "every stored report",
+    synopsis: [["moshcode ticker 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]", ""]],
+    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>", ""]] },
+];
+
+export const PLUGIN_VERBS = [
+  {
+    name: "install", description: "add the marketplace and install a plugin",
+    synopsis: [
+      ["moshcode plugin install", "the default plugin (ticker)"],
+      ["moshcode plugin install <name>", ""],
+    ],
+  },
+  { name: "list", description: "show what the marketplace ships and what is installed", synopsis: [["moshcode plugin list [--json]", ""]] },
+  { name: "remove", description: "uninstall a plugin from Claude Code", synopsis: [["moshcode plugin remove <name>", ""]] },
+];
+
 /** Sub-verb tables, by the name a command's `verbs` field refers to. */
 export const VERB_TABLES = {
   MCP_VERBS,
@@ -473,6 +560,8 @@ export const VERB_TABLES = {
   UPGRADE_TARGETS,
   DNS_VERBS,
   TRADE_VERBS,
+  TICKER_VERBS,
+  PLUGIN_VERBS,
 };
 
 /**
@@ -499,6 +588,14 @@ 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",
+    description: "equity research from advis0r.com" },
+  { name: "plugin", aliases: ["plugins"], args: "<verb> [name]", cli: "plugin",
+    description: "install moshcode's slash commands into Claude Code" },
+  { name: "socials", aliases: ["social"], pitOnly: true,
+    description: "list social networks available for posting" },
+  { name: "post", args: '<social> "message"', pitOnly: true,
+    description: "open a social composer with a prepared post" },
   { name: "install", args: "<engine|tool>", cli: "install",
     description: "install an engine or workflow tool" },
   { name: "upgrade", aliases: ["update"], args: "[name…]", cli: "upgrade",

package/src/engines.mjs

@@ -5,11 +5,11 @@
 //
 // `agentsView` (optional) is the exact argv that opens the engine's native
 // agent list/view — used by `/agents <name>` when the engine actually has one
-// (claude, opencode). It's the FULL leading args (subcommand + any flags that
-// subcommand accepts), because not every agents-subcommand takes the engine's
-// bypass flag (e.g. `opencode agent list` takes none). Engines without an
-// `agentsView` fall back to `agentArgs` — an autonomous session with native
-// approvals bypassed/auto-approved.
+// (currently claude). It's the FULL leading args (subcommand + any flags that
+// subcommand accepts). Engines without an `agentsView` fall back to
+// `agentArgs` — an autonomous session with native approvals
+// bypassed/auto-approved. Do not use a machine-readable, one-shot list command
+// as an agents view: `/agents` promises to hand the terminal to a live session.
 import { spawn } from "node:child_process";
 import { existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
@@ -22,17 +22,19 @@ export const ENGINES = {
     desc: "opencode — the open-source coding agent (SST/anomalyco)",
     bin: "opencode",
     agentArgs: ["--auto"],
-    agentsView: ["agent", "list"], // `opencode agent list` — lists agents; the `agent` subcommand takes no bypass flag
     install: { cmd: "bash", args: ["-c", "curl -fsSL https://opencode.ai/install | bash"] },
     upgrade: { cmd: "opencode", args: ["upgrade"] },
+    // The installer appends this directory to a shell profile. The moshcode
+    // process that ran it cannot see that PATH change, so search it directly.
+    binDirs: [path.join(homedir(), ".opencode", "bin")],
   },
   privacycode: {
     desc: "privacycode — privacy-first coding agent (profullstack)",
     bin: "privacycode",
     // An opencode derivative, so it speaks the same flags/subcommands.
     agentArgs: ["--auto"],
-    agentsView: ["agent", "list"],
     install: { cmd: "sh", args: ["-c", "curl -fsSL https://getprivacycode.com/install | sh"] },
+    binDirs: [path.join(homedir(), ".privacycode", "bin")],
     // Deliberately no native updater. `privacycode upgrade` is opencode's, and
     // it works out how to update itself by recognising where it was installed —
     // it knows opencode's own locations, not this fork's ~/.privacycode/bin. It
@@ -263,9 +265,10 @@ export function pickAiEngine(preferred) {
 
 /** Engine entries annotated with install status. */
 export function engineStatus() {
-  // Search each engine's own install dir as well as PATH — kimi's installer only
-  // adds ~/.kimi-code/bin to your shell rc, so PATH alone reports it missing in
-  // the very session that installed it. (Inert for engines without binDirs.)
+  // Search each engine's own install dir as well as PATH — several curl-based
+  // installers only add their bin directory to a shell rc, so PATH alone
+  // reports them missing in the very session that installed them. (Inert for
+  // engines without binDirs.)
   return Object.entries(ENGINES).map(([key, e]) => ({ key, ...e, installed: isInstalled(e.bin, e.binDirs) }));
 }
 

package/src/integrations.mjs

@@ -8,8 +8,12 @@ import {
 import {
   SKILL_ENGINES, planSkillInstall, runSkillInstall, skillName,
 } from "./skills.mjs";
+import {
+  MARKETPLACE_NAME, PLUGINS, PLUGIN_ENGINES, marketplaceSource, planPluginCommand,
+  pluginId, resolvePlugin, runPluginCommand,
+} from "./plugins.mjs";
 import { catalogList, resolveCatalog } from "./mcp-catalog.mjs";
-import { MCP_VERBS, SKILL_VERBS } from "./cli-schema.mjs";
+import { MCP_VERBS, PLUGIN_VERBS, SKILL_VERBS } from "./cli-schema.mjs";
 import { acid, ash, bone, ok, err, info } from "./ui.mjs";
 
 function splitKV(pair) {
@@ -180,7 +184,7 @@ export function printSkillTargets(json = false) {
 
 function summarize(results) {
   for (const r of results) {
-    if (r.status === "added" || r.status === "installed") console.log(line(r.key, ok(r.status)));
+    if (r.status === "added" || r.status === "installed" || r.status === "removed") console.log(line(r.key, ok(r.status)));
     else if (r.status === "failed") console.log(line(r.key, err(`failed${r.code != null ? ` (code ${r.code})` : r.signal ? ` (${r.signal})` : ""}`)));
     else if (r.status === "not-installed") console.log(line(r.key, ash("not installed — /install " + r.key)));
     else console.log(line(r.key, ash(`skipped — ${r.reason}`)));
@@ -263,3 +267,73 @@ export async function skillCommand(tokens, { run, installedSet } = {}) {
   summarize(results);
   return anyFailed(results) ? 1 : 0;
 }
+
+/**
+ * `/plugin list` — what this marketplace ships, and which engines can take it.
+ *
+ * Two tables rather than one: the plugin list is a property of moshcode, the
+ * engine support is a property of this machine, and merging them into a single
+ * list is how "installed" and "installable" get confused.
+ */
+export function printPluginTargets(json = false, { installedSet } = {}) {
+  const targets = integrationTargetStatus(PLUGIN_ENGINES, { installedSet }).map((t) => ({
+    ...t, supported: PLUGIN_ENGINES.includes(t.name),
+  }));
+  if (json) {
+    console.log(JSON.stringify({
+      marketplace: { name: MARKETPLACE_NAME, source: marketplaceSource() },
+      plugins: PLUGINS,
+      engines: targets,
+    }, null, 2));
+    return;
+  }
+  console.log(bone("  plugins") + ash("  — install moshcode's slash commands with ") + acid("/plugin install"));
+  for (const plugin of PLUGINS) {
+    console.log(`   ${acid(pluginId(plugin.name).padEnd(18))}${ash(plugin.description)}`);
+    console.log(`   ${" ".repeat(18)}${ash(plugin.commands.join("  "))}`);
+  }
+  console.log("");
+  for (const target of targets) {
+    const dot = target.supported && target.installed ? DOT.installed : DOT.missing;
+    console.log(`   ${dot} ${bone(target.name.padEnd(9))} ${ash(target.supported ? "plugins supported" : "no plugin primitive")}`);
+  }
+}
+
+/** Run `/plugin …`. `tokens` are the words after `plugin`. */
+export async function pluginCommand(tokens, { run, installedSet } = {}) {
+  const verb = tokens[0];
+  if (!verb || verb === "list") {
+    printPluginTargets(tokens.slice(1).includes("--json"), { installedSet });
+    return 0;
+  }
+  if (verb !== "install" && verb !== "remove") {
+    console.log(err(`unknown plugin verb "${verb}" — try ${PLUGIN_VERBS.map(({ name }) => name).join(", ")}`));
+    return 1;
+  }
+
+  const rest = tokens.slice(1).filter((t) => t !== "--json");
+  const stray = rest.find((t) => String(t).startsWith("-"));
+  if (stray) { console.log(err(`unknown plugin flag "${stray}"`)); return 1; }
+
+  const plugin = resolvePlugin(rest[0]);
+  if (!plugin) {
+    console.log(err(`unknown plugin "${rest[0]}" — this marketplace ships ${PLUGINS.map((p) => p.name).join(", ")}`));
+    return 1;
+  }
+
+  const source = marketplaceSource();
+  console.log(verb === "install"
+    ? info(`installing ${bone(pluginId(plugin.name))} ${ash(`from ${source}`)} across plugin engines…`)
+    : info(`removing ${bone(pluginId(plugin.name))} from plugin engines…`));
+
+  const plan = planPluginCommand({ plugin, source }, { installedSet, verb });
+  const results = await runPluginCommand(plan, { verb, ...(run ? { run } : {}) });
+  summarize(results);
+
+  // A newly installed plugin is not live in an already-running engine, and the
+  // first thing anyone does is type the slash command and conclude it failed.
+  if (!anyFailed(results) && verb === "install" && results.some((r) => r.status === "installed")) {
+    console.log(info(`restart the engine, then try ${acid(`${plugin.commands[0]} NVDA`)}`));
+  }
+  return anyFailed(results) ? 1 : 0;
+}

package/src/plugins.mjs

@@ -0,0 +1,121 @@
+// `moshcode plugin` — install moshcode's own slash commands into an engine.
+//
+// The same shape as src/skills.mjs, for the same reason: one source, a plan of
+// per-engine actions, and a summary that names the engines it *skipped* as well
+// as the ones it touched. An engine silently missing from the summary reads as
+// "installed everywhere", which is exactly the confusion prd/0003 R8 exists to
+// prevent.
+//
+// Claude Code is currently the only engine with a plugin primitive. That is a
+// fact about the engines, not an assumption baked into the fan-out — adding a
+// second one means adding a case to pluginInstallActions, nothing else.
+import { ENGINES, isInstalled, ranOk, runCmd } from "./engines.mjs";
+
+/** Engines with a plugin primitive. */
+export const PLUGIN_ENGINES = ["claude"];
+
+/** The marketplace this repo publishes (see .claude-plugin/marketplace.json). */
+export const MARKETPLACE_NAME = "moshcode";
+
+/**
+ * Where the marketplace is fetched from. A GitHub `owner/repo` by default;
+ * point it at a checkout to test an unreleased plugin:
+ *   MOSHCODE_PLUGIN_SOURCE=. moshcode plugin install
+ */
+export function marketplaceSource(env = process.env) {
+  return String(env.MOSHCODE_PLUGIN_SOURCE || "moshcoder/moshcode").trim() || "moshcoder/moshcode";
+}
+
+/** The plugins this marketplace ships. Mirrors .claude-plugin/marketplace.json. */
+export const PLUGINS = [
+  {
+    name: "ticker",
+    description: "equity research slash commands backed by advis0r.com",
+    commands: ["/ticker", "/signals", "/research", "/lookup", "/reports", "/discover"],
+  },
+];
+
+export const DEFAULT_PLUGIN = PLUGINS[0].name;
+
+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;
+}
+
+/** Fully-qualified plugin id, the form `claude plugin install` disambiguates with. */
+export function pluginId(name) {
+  return `${name}@${MARKETPLACE_NAME}`;
+}
+
+/**
+ * The commands one engine needs to install a plugin.
+ *
+ * Adding the marketplace is idempotent and separate from installing, so it runs
+ * every time: a machine that added the marketplace before this plugin existed
+ * would otherwise fail the install with "not found in any marketplace".
+ */
+export function pluginInstallActions(key, { plugin, source, scope }) {
+  switch (key) {
+    case "claude":
+      return [
+        { cmd: "claude", args: ["plugin", "marketplace", "add", source, ...(scope ? ["--scope", scope] : [])] },
+        { cmd: "claude", args: ["plugin", "install", pluginId(plugin.name), ...(scope ? ["--scope", scope] : [])] },
+      ];
+    default:
+      return { skip: "no plugin primitive" };
+  }
+}
+
+export function pluginRemoveActions(key, { plugin }) {
+  switch (key) {
+    case "claude":
+      return [{ cmd: "claude", args: ["plugin", "uninstall", pluginId(plugin.name)] }];
+    default:
+      return { skip: "no plugin primitive" };
+  }
+}
+
+/**
+ * Plan the fan-out: one entry per engine, with its actions or its skip reason.
+ * Derived from ENGINES so an engine added later cannot fall out of the summary.
+ */
+export function planPluginCommand(spec, { installedSet, verb = "install" } = {}) {
+  const build = verb === "remove" ? pluginRemoveActions : pluginInstallActions;
+  const rest = Object.keys(ENGINES).filter((key) => !PLUGIN_ENGINES.includes(key));
+  return [...PLUGIN_ENGINES, ...rest].map((key) => {
+    const bin = ENGINES[key].bin;
+    const installed = installedSet ? installedSet.has(key) : isInstalled(bin, ENGINES[key].binDirs);
+    const actions = build(key, spec);
+    return Array.isArray(actions)
+      ? { key, bin, installed, actions }
+      : { key, bin, installed, ...actions };
+  });
+}
+
+/**
+ * Execute a plan. Returns [{ key, status, reason?, code? }] with
+ * status one of installed | removed | skipped | failed | not-installed.
+ * `run` is injectable for tests.
+ */
+export async function runPluginCommand(plan, { run = runCmd, verb = "install" } = {}) {
+  const done = verb === "remove" ? "removed" : "installed";
+  const results = [];
+  for (const item of plan) {
+    if (item.skip) { results.push({ key: item.key, status: "skipped", reason: item.skip }); continue; }
+    if (!item.installed) { results.push({ key: item.key, status: "not-installed" }); continue; }
+    let last = null;
+    let failed = false;
+    for (const action of item.actions) {
+      last = await run(action.cmd, action.args);
+      if (!ranOk(last)) { failed = true; break; }
+    }
+    results.push({
+      key: item.key,
+      status: failed ? "failed" : done,
+      code: last?.code ?? null,
+      signal: last?.signal ?? null,
+    });
+  }
+  return results;
+}

package/src/socials.mjs

@@ -0,0 +1,72 @@
+import { canOpenBrowser, openBrowser } from "./open-url.mjs";
+
+const DEFAULT_APP = "https://app.moshcode.sh";
+
+export const SOCIALS = [
+  {
+    name: "bluesky",
+    aliases: ["bsky"],
+    description: "official Bluesky browser composer",
+  },
+  {
+    name: "nostr",
+    aliases: [],
+    description: "NIP-07/NIP-46 browser signer + relay publish",
+  },
+];
+
+export function resolveSocial(name) {
+  const wanted = String(name ?? "").trim().toLowerCase();
+  return SOCIALS.find((social) =>
+    social.name === wanted || social.aliases.includes(wanted)) ?? null;
+}
+
+function appOrigin(env = process.env) {
+  return String(env.MOSHCODE_API || DEFAULT_APP).replace(/\/+$/, "");
+}
+
+/**
+ * Build the browser hand-off without opening anything. Nostr keeps the draft
+ * in the fragment so it never reaches app.moshcode.sh access logs or Referer
+ * headers; the composer reads it entirely in the browser.
+ */
+export function socialPostUrl(name, message, { env = process.env } = {}) {
+  const social = resolveSocial(name);
+  if (!social) return null;
+  const text = String(message ?? "");
+  if (social.name === "bluesky") {
+    return `https://bsky.app/intent/compose?${new URLSearchParams({ text })}`;
+  }
+  return `${appOrigin(env)}/socials/nostr#${new URLSearchParams({ text })}`;
+}
+
+export function socialRoster() {
+  return SOCIALS.map((social) => ({ ...social, aliases: [...social.aliases] }));
+}
+
+/**
+ * Open a provider composer. Posting remains an explicit browser confirmation:
+ * Bluesky requires it, and Nostr asks the browser signer before relay publish.
+ */
+export function postSocial(args, {
+  env = process.env,
+  canOpen = canOpenBrowser,
+  open = openBrowser,
+} = {}) {
+  const [requested, ...words] = Array.isArray(args) ? args : [];
+  const social = resolveSocial(requested);
+  if (!requested) return { ok: false, error: 'usage: /post <social> "message"' };
+  if (!social) {
+    return {
+      ok: false,
+      error: `unknown social "${requested}". try: ${SOCIALS.map((entry) => entry.name).join(", ")}`,
+    };
+  }
+
+  const message = words.join(" ").trim();
+  if (!message) return { ok: false, error: 'usage: /post <social> "message"' };
+
+  const url = socialPostUrl(social.name, message, { env });
+  const opened = Boolean(canOpen() && open(url));
+  return { ok: true, social: social.name, message, url, opened };
+}

package/src/tui.mjs

@@ -10,6 +10,7 @@ import path from "node:path";
 import { ENGINES, agentLaunchArgs, resolveEngine, engineStatus, openSession } from "./engines.mjs";
 import { TOOLS, resolveTool, toolStatus, openTool } from "./tools.mjs";
 import { tradeArgs, tradeUsage } from "./trade.mjs";
+import { postSocial, socialRoster } from "./socials.mjs";
 import { runUpgrade } from "./upgrade.mjs";
 import { locate, tilde } from "./pwd.mjs";
 import { createPrd, listPrds, authoringPrompt } from "./prd.mjs";
@@ -18,7 +19,9 @@ import { createMirror, teeOutput } from "./mirror.mjs";
 import { fetchMotdAd } from "./ads.mjs";
 import { runScript } from "./runtime.mjs";
 import { moshVocabulary } from "./commands.mjs";
-import { mcpCommand, skillCommand } from "./integrations.mjs";
+import { mcpCommand, pluginCommand, skillCommand } from "./integrations.mjs";
+import { tickerCommand } from "./advisor.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";
@@ -156,6 +159,15 @@ function printTools() {
   console.log(ash("   → ") + acid("https://dev.profullstack.com/"));
 }
 
+function printSocials() {
+  console.log(bone("  socials") + ash("  — compose with ") + acid('/post <social> "message"'));
+  for (const social of socialRoster()) {
+    const aliases = social.aliases.length ? ` (${social.aliases.join(", ")})` : "";
+    console.log(`   ${acid("●")} ${bone(social.name.padEnd(9))} ${ash(social.description + aliases)}`);
+  }
+  console.log(ash("   the browser always asks you to confirm before anything is published"));
+}
+
 /**
  * The moshscript vocabulary, split the way the CLI's help splits it.
  *
@@ -660,6 +672,31 @@ export async function tui() {
       rl = mkrl();
       continue;
     }
+    // `/ticker` 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) });
+      continue;
+    }
+    if (cmd === "plugin" || cmd === "plugins") {
+      await pluginCommand(rest);
+      continue;
+    }
+    if (cmd === "socials" || cmd === "social") {
+      printSocials();
+      continue;
+    }
+    if (cmd === "post") {
+      const result = postSocial(rest);
+      if (!result.ok) { console.log(err(result.error)); continue; }
+      if (result.opened) {
+        console.log(ok(`opened the ${result.social} composer — confirm the post in your browser 🤘`));
+      } else {
+        console.log(info(`open this ${result.social} composer in a browser:`));
+        console.log(`  ${result.url}`);
+      }
+      continue;
+    }
     // Bare engine name → open it.
     const resolved = resolveEngine(cmd);
     if (resolved) {