sella-cli 0.8.0 → 0.9.1

package/README.md

@@ -71,7 +71,7 @@ npx sella-cli sandbox "web search"
   <img src="https://sellag.vercel.app/readme/cli-sandbox.svg" alt="sella sandbox returns live marketplace results: Exa, Tavily and more, with no account" width="740" />
 </p>
 
-What's in there: a catalogue of 1,100+ machine-payable API providers, plus first-party datasets, workflows, and Sella Native products such as Cradle. Free previews let your agent check quality before it pays.
+What's in there: a catalogue of 1,500+ machine-payable API providers with 8,000+ verified callable endpoints, plus first-party datasets, workflows, and Sella Native products such as Cradle. Free previews let your agent check quality before it pays.
 
 ## What you get
 
@@ -96,6 +96,7 @@ What's in there: a catalogue of 1,100+ machine-payable API providers, plus first
 | `sella businesses` | Your agent's named runs, newest first: status, spend, tool calls, and the outcome it wrote. `--active` or `--closed` filters. |
 | `sella fund` | Per-chain USDC deposit addresses, plus the funding page with QR codes and a fiat on-ramp. |
 | `sella mcp` | Run a local stdio MCP server that proxies Sella with your stored key, for clients that cannot use a remote endpoint. |
+| `sella skill` | Show the cached agent instruction bundle and its version. `sella skill update` refreshes it. A pinned local copy means two runs of the same prompt read the same instructions, instead of re-fetching 25 KB that can change mid-task. |
 | `sella publish init <file.csv>` | Scaffold `sella-dataset.json` and pre-check the CSV structure. |
 | `sella publish push` | Publish the dataset through the same route the web dashboard uses. |
 

package/dist/chains.js

@@ -47,8 +47,17 @@ export async function fetchChainRegistry(apiBase, fetchImpl = fetch) {
  * What can the agent actually do with funds on this chain *today*?
  *  - `live`         — Sella can settle an outbound provider payment from here → spendable now.
  *  - `deposit-only` — accepts deposits, but outbound settle isn't proven yet (fund it, can't spend).
- *  - `inbound-only` — settles inbound (agents paying Sella) with no agent-wallet spend, e.g. Stellar.
+ *  - `inbound-only` — settles inbound (agents paying Sella) with no agent-wallet spend.
  *  - `unknown`      — chain not in the registry (or registry unreachable).
+ *
+ * `inbound-only` used to name Stellar as its example. Stellar was removed from the registry on
+ * 2026-08-03 and there is no replacement to name: as of 2026-08-31 NO chain carries
+ * `settle.inbound: true`, so this branch is unreachable through the registry alone.
+ *
+ * That is not a bug in either place. Inbound is switched on per deployment by
+ * `X402_INBOUND_NETWORKS`, while the registry flag records only what has been PROVEN on-chain,
+ * which is deliberately slower-moving. The branch stays because a row can set the flag at any time,
+ * and reporting `unknown` for such a chain would be worse than reporting `inbound-only`.
  */
 export function chainCapability(info) {
     if (!info)

package/dist/clients.js

@@ -193,7 +193,7 @@ export function installSellaIntoClient(id, opts) {
                 doc = JSON.parse(raw);
             }
             catch {
-                throw new Error(`${spec.name} config at ${configPath} is not valid JSON — fix or remove it, then re-run.`);
+                throw new Error(`${spec.name} config at ${configPath} is not valid JSON. Fix or remove it, then re-run.`);
             }
         }
     }

package/dist/credentials.js

@@ -45,7 +45,7 @@ export function saveCredentials(payload, opts) {
         files.push(p);
     }
     const custodyNote = keychainOk
-        ? `API key stored in the macOS keychain (service "${KEYCHAIN_SERVICE}"). Wallet files are owner-read-only; client configs carry the key in plaintext — that is how MCP clients read headers today.`
-        : `Secrets stored as owner-read-only files (0600)${env.platform === 'win32' ? ' — on Windows, protect your user profile' : ''}. Client configs carry the key in plaintext — that is how MCP clients read headers today. Never commit or share these files.`;
+        ? `API key stored in the macOS keychain (service "${KEYCHAIN_SERVICE}"). Wallet files are owner-read-only; client configs carry the key in plaintext, which is how MCP clients read headers today.`
+        : `Secrets stored as owner-read-only files (0600)${env.platform === 'win32' ? '. On Windows, protect your user profile' : ''}. Client configs carry the key in plaintext, which is how MCP clients read headers today. Never commit or share these files.`;
     return { files, keyStorage: keychainOk ? 'keychain' : 'file', custodyNote };
 }

package/dist/doctor.js

@@ -55,8 +55,8 @@ export async function runDoctor(opts) {
             id: 'endpoint',
             label: 'Sella MCP endpoint reachable',
             ok: toolNames.length > 0,
-            detail: `${opts.mcpUrl} — ${toolNames.length} tools advertised`,
-            ...(toolNames.length === 0 ? { fix: 'The server answered but advertised no tools — check SELLA_MCP_URL points at /api/mcp.' } : {}),
+            detail: `${opts.mcpUrl}: ${toolNames.length} tools advertised`,
+            ...(toolNames.length === 0 ? { fix: 'The server answered but advertised no tools. Check SELLA_MCP_URL points at /api/mcp.' } : {}),
         });
     }
     catch (err) {
@@ -76,7 +76,7 @@ export async function runDoctor(opts) {
             label: 'Onboarding tools advertised',
             ok: hasBootstrap,
             detail: hasBootstrap ? 'sella_setup_claim + sella_auth_* available' : `advertised: ${toolNames.slice(0, 6).join(', ')}…`,
-            ...(hasBootstrap ? {} : { fix: 'The endpoint is not a Sella MCP server — fix SELLA_MCP_URL.' }),
+            ...(hasBootstrap ? {} : { fix: 'The endpoint is not a Sella MCP server. Fix SELLA_MCP_URL.' }),
         });
     }
     // 3. credentials — stored key present
@@ -122,7 +122,7 @@ export async function runDoctor(opts) {
     try {
         JSON.parse(fs.readFileSync(walletPath, 'utf8'));
         walletOk = true;
-        walletDetail = `${walletPath} ok${fs.existsSync(agentWalletPath) ? ' · AgentWallet config ok' : ' · AgentWallet config absent (proxy payments off — re-run `sella pair` later)'}`;
+        walletDetail = `${walletPath} ok${fs.existsSync(agentWalletPath) ? ' · AgentWallet config ok' : ' · AgentWallet config absent (proxy payments off, re-run `sella pair` later)'}`;
     }
     catch {
         /* stays missing/corrupt */
@@ -132,7 +132,7 @@ export async function runDoctor(opts) {
         label: 'Wallet config files',
         ok: walletOk,
         detail: walletDetail,
-        ...(walletOk ? {} : { fix: 'Run `sella pair` — wallet keys are delivered once at pairing.' }),
+        ...(walletOk ? {} : { fix: 'Run `sella pair`. Wallet keys are delivered once at pairing.' }),
     });
     // 6. quote — paid-call economics computable (price + platform fee + settleable chains)
     try {
@@ -147,7 +147,7 @@ export async function runDoctor(opts) {
             detail: quote
                 ? `${slug}: $${quote.totalUSD} total (${quote.feeBps} bps fee) on ${quote.payChains?.join('/') || 'no chains'}`
                 : 'catalog reachable but no quote returned',
-            ...(quote ? {} : { fix: 'Catalog/quote API unavailable — paid calls may still work; check the server logs.' }),
+            ...(quote ? {} : { fix: 'Catalog/quote API unavailable. Paid calls may still work; check the server logs.' }),
         });
     }
     catch (err) {
@@ -156,7 +156,7 @@ export async function runDoctor(opts) {
             label: 'x402 pay quote',
             ok: false,
             detail: err instanceof Error ? err.message : 'quote fetch failed',
-            fix: 'Could not fetch a pay quote from the catalog API — check the marketplace is up.',
+            fix: 'Could not fetch a pay quote from the catalog API. Check the marketplace is up.',
         });
     }
     return { ok: checks.every((c) => c.ok), checks };

package/dist/index.js

@@ -1,19 +1,48 @@
 #!/usr/bin/env node
 import * as readline from 'node:readline/promises';
 import * as path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import { detectClients, installSellaIntoClient, defaultEnv } from './clients.js';
 import { pair } from './pairing.js';
 import { runDoctor, runStatus, loadStoredKey } from './doctor.js';
 import { runMcpBridge } from './mcp-bridge.js';
 import { scaffoldCard, pushDataset, CARD_FILENAME } from './publish.js';
 import { sandboxSearch, listBusinesses } from './api.js';
+import { skillStatus, syncSkillBundle } from './skill.js';
 import { getFundingInfo, annotateFunding } from './fund.js';
 import { capabilityLabel } from './chains.js';
 import { defaultIo, Printer } from './output.js';
 import { Ui } from './ui.js';
 import { recordCliEvent, saveTelemetryDecision, shouldPromptTelemetry } from './telemetry.js';
 const DEFAULT_MCP_URL = 'https://sellag.vercel.app/api/mcp';
-const VERSION = '0.8.0';
+/**
+ * Read from package.json rather than hardcoded.
+ *
+ * It was hardcoded, and it drifted: this constant still said 0.8.0 while package.json and npm both
+ * served 0.9.0. `sella --version` therefore reported the wrong version on every install for weeks,
+ * the banner printed it, and `recordCliEvent` shipped it, so telemetry attributed 0.9.0 runs to
+ * 0.8.0. A version string that has to be bumped in two places is a version string that will be
+ * bumped in one.
+ *
+ * `../package.json` resolves correctly from both dist/index.js and src/index.ts, and npm always
+ * includes package.json in the tarball regardless of the `files` list, so it is there at runtime.
+ * Read with fs rather than a JSON import: import attributes are not available across the whole
+ * `engines: >=18` range this package claims to support.
+ */
+const VERSION = (() => {
+    try {
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        const raw = readFileSync(path.join(here, '..', 'package.json'), 'utf8');
+        const v = JSON.parse(raw)?.version;
+        return typeof v === 'string' && v ? v : 'unknown';
+    }
+    catch {
+        // Never let a missing or unreadable manifest take down the CLI: the version is informational
+        // everywhere it is used.
+        return 'unknown';
+    }
+})();
 function parseFlags(argv) {
     const flags = {
         json: false, yes: false, noColor: false, dryRun: false, noKeychain: false,
@@ -50,7 +79,7 @@ function parseFlags(argv) {
     }
     return flags;
 }
-const HELP = `sella — the Sella onboarding CLI
+const HELP = `sella: the Sella onboarding CLI
 
 Usage: sella <command> [options]
 
@@ -58,11 +87,12 @@ Commands:
   init       Guided onboarding: install the Sella MCP server, pair, verify
              (also runs when you invoke \`sella\` with no command and no credentials yet)
   pair       Pair this machine only (setup code or email + OTP)
-  sandbox    Try Sella with no signup — search the live marketplace (rate-limited)
+  sandbox    Try Sella with no signup. Search the live marketplace (rate-limited)
   clients    List detected agent clients (--install to write configs)
   doctor     Verify the install: endpoint, credentials, auth, wallets, pay-quote
   status     Show your key + AgentWallet balances
   businesses Show your agent's named runs: spend, tool calls, outcome
+  skill      Show the cached agent instruction bundle; 'skill update' refreshes it
   fund       Show deposit addresses + funding links to add USDC to your agent wallet
   mcp        Run as a local stdio MCP server that proxies Sella with your stored key
   publish    Publish a dataset from a CSV: 'publish init <file.csv>' then 'publish push'
@@ -152,12 +182,12 @@ async function runPair(ctx, flags, emit, extra = {}) {
         emit.error(outcome.error);
         return { code: outcome.exitCode, summary: { paired: false, error: outcome.error } };
     }
-    emit.ok(`Paired via ${outcome.method} — status: ${outcome.payload.status || 'ok'}`);
+    emit.ok(`Paired via ${outcome.method}. Status: ${outcome.payload.status || 'ok'}`);
     for (const file of outcome.save.files)
         emit.ok(`wrote ${file}`);
     emit.info(outcome.save.custodyNote);
     if (outcome.payload.agentWallet?.status === 'unavailable') {
-        emit.warn(`AgentWallet not provisioned (${outcome.payload.agentWallet.reason || 'backend unavailable'}) — MCP access still works; re-run \`sella pair\` later.`);
+        emit.warn(`AgentWallet not provisioned (${outcome.payload.agentWallet.reason || 'backend unavailable'}). MCP access still works; re-run \`sella pair\` later.`);
     }
     return {
         code: 0,
@@ -191,7 +221,7 @@ async function collectPairChoice(ui, flags, ctx) {
     if (method === 'setup-code') {
         const code = await ui.text('Paste your setup code', {
             placeholder: 'SELLA-XXXX-XXXX-XXXX-XXXX',
-            validate: (v) => (v ? undefined : 'A setup code is required — mint one on the dashboard (Connect your agent).'),
+            validate: (v) => (v ? undefined : 'A setup code is required. Mint one on the dashboard (Connect your agent).'),
         });
         return { setupCode: code };
     }
@@ -280,16 +310,27 @@ async function cmdInit(ctx, flags, printer) {
             (verify.ok ? sp.succeed : sp.succeed)(`${passed}/${verify.checks.length} checks passed`);
             ui.checkStrip(verify.checks.map((c) => ({ id: c.id, ok: c.ok })));
             for (const check of verify.checks.filter((c) => !c.ok)) {
-                ui.warn(`${check.label} — ${check.detail}`);
+                ui.warn(`${check.label}: ${check.detail}`);
                 if (check.fix)
                     ui.detail(`fix: ${check.fix}`);
             }
             verifySummary = { ok: verify.ok, passed, total: verify.checks.length };
         }
         catch (err) {
-            sp.fail('Verify could not run (network?) — try `sella doctor` later.');
+            sp.fail('Verify could not run (network?). Try `sella doctor` later.');
             verifySummary = { ok: false, error: err instanceof Error ? err.message : String(err) };
         }
+        // Cache the agent instruction bundle alongside the credentials, so the agent reads its
+        // instructions from disk instead of re-fetching them every session. Best effort on purpose:
+        // onboarding must not fail because a documentation download did, and `sella skill update`
+        // fixes it later.
+        try {
+            const bundle = await syncSkillBundle({ env: ctx.env, origin });
+            ui.detail(`Skill bundle ${bundle.version} cached at ${bundle.dir}`);
+        }
+        catch {
+            ui.detail('Skill bundle not cached (network?). Run `sella skill update` later.');
+        }
     }
     if (paired.code === 0) {
         const awStatus = String(paired.summary?.agentWallet || 'none');
@@ -299,7 +340,7 @@ async function cmdInit(ctx, flags, printer) {
             'Health check: sella doctor',
         ];
         if (awStatus === 'unavailable') {
-            lines.push('AgentWallet pending (backend not configured) — re-run `sella pair` later.');
+            lines.push('AgentWallet pending (backend not configured). Re-run `sella pair` later.');
         }
         ui.note('Sella is connected', lines, flags.dryRun ? 'plain' : awStatus === 'unavailable' ? 'warn' : 'ok');
         // RFI: ready-to-send prompts for real agent tasks — the "now what?" answer.
@@ -307,9 +348,9 @@ async function cmdInit(ctx, flags, printer) {
         ui.bar();
         ui.step('Ideas to try with your agent (each is a ready-to-send prompt):');
         ui.rows([
-            { tag: 'invest', text: `Validate a startup idea for $25 — ${rfi}?uc=twenty-five-dollar-study`, tone: 'brand' },
-            { tag: 'daily', text: `Get a daily morning brief — ${rfi}?uc=morning-brief`, tone: 'ok' },
-            { tag: 'free', text: `Test Sella without spending — ${rfi}?uc=zero-dollar-demo`, tone: 'dim' },
+            { tag: 'invest', text: `Validate a startup idea for $25: ${rfi}?uc=twenty-five-dollar-study`, tone: 'brand' },
+            { tag: 'daily', text: `Get a daily morning brief: ${rfi}?uc=morning-brief`, tone: 'ok' },
+            { tag: 'free', text: `Test Sella without spending: ${rfi}?uc=zero-dollar-demo`, tone: 'dim' },
         ]);
         ui.detail(`Browse all ideas: ${rfi}`);
         // One-time telemetry choice: only a human at a TTY is ever asked, and only once.
@@ -323,10 +364,10 @@ async function cmdInit(ctx, flags, printer) {
             ui.detail(share === 'share' ? 'Thanks. Opt out anytime: SELLA_TELEMETRY=0' : 'Nothing will be sent. Opt in later: SELLA_TELEMETRY=1');
         }
         const took = Math.max(1, Math.round((Date.now() - startedAt) / 1000));
-        ui.outro(flags.dryRun ? 'Dry run complete — nothing was written.' : `Done in ${took}s — your agents can now buy on Sella.`);
+        ui.outro(flags.dryRun ? 'Dry run complete. Nothing was written.' : `Done in ${took}s. Your agents can now buy on Sella.`);
     }
     else {
-        ui.outro('Pairing incomplete — fix the issue above, then re-run `sella init`.');
+        ui.outro('Pairing incomplete. Fix the issue above, then re-run `sella init`.');
     }
     printer.jsonOut({ installed: install.results, pairing: paired.summary, reinstalled, verify: verifySummary });
     return install.failed ? 1 : paired.code;
@@ -353,7 +394,7 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
         // --json/--yes runs — automation must not fall into an interactive flow.
         const interactive = io.isTTY && Boolean(process.stdin.isTTY) && !flags.json && !flags.yes;
         if (interactive && !loadStoredKey(ctx.env)) {
-            printer.info('No Sella credentials on this machine yet — starting onboarding (Ctrl+C to abort, `sella --help` for commands).');
+            printer.info('No Sella credentials on this machine yet. Starting onboarding (Ctrl+C to abort, `sella --help` for commands).');
             return await cmdInit(ctx, flags, printer);
         }
         io.stdout(HELP);
@@ -397,7 +438,7 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
                 if (choice.email)
                     ui.step(`Requesting a verification code for ${choice.email}…`);
                 const paired = await runPair(ctx, flags, emit, { ...choice, ask: wizardAsk(ui, ctx) });
-                ui.outro(paired.code === 0 ? 'Paired — try `sella doctor` next.' : 'Pairing failed — see above.');
+                ui.outro(paired.code === 0 ? 'Paired. Try `sella doctor` next.' : 'Pairing failed. See above.');
                 printer.jsonOut(paired.summary || {});
                 return paired.code;
             }
@@ -415,12 +456,12 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
                     const total = result.datasets.length + result.apis.length;
                     printer.info(`Sandbox results for "${query}" (no account, rate-limited):`);
                     for (const d of result.datasets) {
-                        printer.info(`  dataset  ${d.title || d.id}${d.priceUSDC ? ` — $${d.priceUSDC}/call` : ' — free'}`);
+                        printer.info(`  dataset  ${d.title || d.id}${d.priceUSDC ? `, $${d.priceUSDC}/call` : ', free'}`);
                     }
                     for (const a of result.apis) {
                         printer.info(`  api      ${a.name || ''}${a.chains?.length ? ` [${a.chains.join('/')}]` : ''}`);
                     }
-                    printer.info(total ? '\nPair to buy any of these: `sella init`.' : 'No matches — try a broader query.');
+                    printer.info(total ? '\nPair to buy any of these: `sella init`.' : 'No matches. Try a broader query.');
                 }
                 return 0;
             }
@@ -429,7 +470,7 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
                 printer.jsonOut(info);
                 if (!flags.json) {
                     if (!info.paired) {
-                        printer.error('Not paired yet — run `sella pair` first, then `sella fund`.');
+                        printer.error('Not paired yet. Run `sella pair` first, then `sella fund`.');
                         return 2;
                     }
                     printer.info('Fund your Sella agent wallet with USDC:\n');
@@ -452,14 +493,14 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
                     printer.info('Sella doctor:');
                     for (const check of result.checks) {
                         if (check.ok)
-                            printer.ok(`${check.label} — ${check.detail}`);
+                            printer.ok(`${check.label}: ${check.detail}`);
                         else {
-                            printer.error(`${check.label} — ${check.detail}`);
+                            printer.error(`${check.label}: ${check.detail}`);
                             if (check.fix)
                                 printer.info(`      ↳ ${check.fix}`);
                         }
                     }
-                    printer.info(result.ok ? '\nAll checks passed. Your agent is ready to buy.' : '\nSome checks failed — see the fixes above.');
+                    printer.info(result.ok ? '\nAll checks passed. Your agent is ready to buy.' : '\nSome checks failed. See the fixes above.');
                 }
                 return result.ok ? 0 : 1;
             }
@@ -468,7 +509,7 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
                 printer.jsonOut(status);
                 if (!flags.json) {
                     const key = status.key;
-                    printer.info(key.present ? `API key: ${key.prefix}… (${key.source})` : 'API key: not paired — run `sella pair`');
+                    printer.info(key.present ? `API key: ${key.prefix}… (${key.source})` : 'API key: not paired. Run `sella pair`');
                     const aw = status.agentWallet;
                     if (aw?.username) {
                         printer.info(`AgentWallet: ${aw.username}${aw.fundingStatus ? ` · ${aw.fundingStatus}` : ''}`);
@@ -484,6 +525,47 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
                 }
                 return 0;
             }
+            case 'skill': {
+                const origin = ctx.mcpUrl.replace(/\/api\/mcp\/?$/, '');
+                const sub = flags.positional[1];
+                if (sub === 'update') {
+                    const result = await syncSkillBundle({ env: ctx.env, origin, force: flags.positional.includes('--force') });
+                    printer.jsonOut(result);
+                    if (!flags.json) {
+                        if (result.upToDate) {
+                            printer.info(`Already on ${result.version}. Nothing to download.`);
+                        }
+                        else {
+                            const moved = result.previousVersion ? `${result.previousVersion} -> ${result.version}` : result.version;
+                            printer.info(`Skill bundle ${moved}`);
+                            printer.info(`  ${result.written.length} downloaded, ${result.reused.length} unchanged`);
+                            printer.info(`  ${result.dir}`);
+                        }
+                    }
+                    return 0;
+                }
+                const status = await skillStatus(ctx.env, origin);
+                printer.jsonOut(status);
+                if (!flags.json) {
+                    if (!status.localVersion) {
+                        printer.info(`No local bundle. Live version is ${status.remoteVersion}.`);
+                        printer.info('Run `sella skill update` to cache it.');
+                    }
+                    else if (status.upToDate) {
+                        printer.info(`Skill bundle ${status.localVersion} (current).`);
+                        if (status.dir)
+                            printer.info(`  ${status.dir}`);
+                    }
+                    else {
+                        printer.info(`Skill bundle ${status.localVersion} is out of date. Live version is ${status.remoteVersion}.`);
+                        if (status.breaking) {
+                            printer.info('  This is a breaking change: a tool may have been removed or changed.');
+                        }
+                        printer.info('  Run `sella skill update`.');
+                    }
+                }
+                return status.localVersion && !status.upToDate ? 1 : 0;
+            }
             case 'businesses': {
                 const stored = loadStoredKey(ctx.env);
                 if (!stored) {
@@ -551,7 +633,7 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
                 if (sub === 'push') {
                     const stored = loadStoredKey(ctx.env);
                     if (!stored) {
-                        printer.error('Not paired — run `sella pair` first, then `sella publish push`.');
+                        printer.error('Not paired. Run `sella pair` first, then `sella publish push`.');
                         printer.jsonOut({ ok: false, error: 'not_paired' });
                         return 2;
                     }
@@ -566,12 +648,12 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
                                     printer.error(`  ${k}: ${v}`);
                         }
                         else {
-                            printer.ok(`Published — status: ${result.status}`);
+                            printer.ok(`Published. Status: ${result.status}`);
                             printer.info(`  listing: ${result.listingUrl}`);
                             if (result.status === 'manual_review')
                                 printer.info('  Sella is reviewing it; it goes live once approved.');
                             else if (result.status === 'processing')
-                                printer.info('  Still scoring — re-check later with `sella status` or the dashboard.');
+                                printer.info('  Still scoring. Re-check later with `sella status` or the dashboard.');
                         }
                     }
                     return result.ok ? 0 : 1;
@@ -587,7 +669,7 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
                     ctx.io.stderr(`ok  Sella MCP bridge → ${ctx.mcpUrl} (key from ${stored.source})`);
                 }
                 else {
-                    ctx.io.stderr('warn  No stored key — bridging free/sandbox tools only; run `sella pair` to enable paid tools.');
+                    ctx.io.stderr('warn  No stored key. Bridging free/sandbox tools only; run `sella pair` to enable paid tools.');
                 }
                 return await runMcpBridge({ mcpUrl: ctx.mcpUrl, apiKey: stored?.apiKey });
             }

package/dist/mcp-bridge.js

@@ -40,7 +40,7 @@ export async function forwardMessage(msg, opts) {
         });
         const text = await res.text();
         if (!res.ok) {
-            const hint = res.status === 401 ? ' — run `sella pair` to (re)authenticate this machine' : '';
+            const hint = res.status === 401 ? '. Run `sella pair` to (re)authenticate this machine' : '';
             return { jsonrpc: '2.0', id, error: { code: -32000, message: `Sella endpoint responded ${res.status}${hint}` } };
         }
         if (!text)

package/dist/publish.js

@@ -33,7 +33,7 @@ export function precheckCsv(text) {
         warnings.push(`Duplicate header(s): ${[...new Set(dupes)].join(', ')}.`);
     const dataLines = lines.slice(1);
     if (dataLines.length === 0)
-        warnings.push('No data rows — only a header was found.');
+        warnings.push('No data rows. Only a header was found.');
     let emptyCells = 0;
     let ragged = 0;
     const nonEmptyPerColumn = new Array(columns.length).fill(0);
@@ -138,7 +138,7 @@ export async function pushDataset(opts) {
         });
         const json = await res.json().catch(() => ({}));
         if (res.status === 401)
-            return { ok: false, error: 'Not authenticated — run `sella pair` to (re)authenticate this machine.' };
+            return { ok: false, error: 'Not authenticated. Run `sella pair` to (re)authenticate this machine.' };
         if (res.status === 422)
             return { ok: false, error: 'The listing was rejected by validation.', fieldErrors: json.fieldErrors };
         if (!res.ok)

package/dist/skill.js

@@ -0,0 +1,169 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/**
+ * Local skill-bundle cache.
+ *
+ * An agent that re-fetches 25 KB of instructions every session burns context and gets whatever is
+ * live, which can change mid-task. A pinned local copy is cheaper and reproducible: two runs of the
+ * same prompt read the same instructions, so when something goes wrong you know which version
+ * produced it.
+ *
+ * The danger is the obvious one. A cache that never expires is a confidently wrong copy of a world
+ * that moved, which is exactly how the old hand-written skill.json ended up advertising four
+ * deprecated tools. So the bundle is stored under its version, the server stamps stale callers on
+ * calls they were already making, and `sella skill update` is one command.
+ */
+/** Placeholder the server substitutes per request host. See lib/agent-docs.ts. */
+const ORIGIN_PLACEHOLDER = '{{SELLA_ORIGIN}}';
+export class SkillSyncError extends Error {
+}
+function skillRoot(env) {
+    return path.join(env.home, '.sella', 'skill');
+}
+function pointerPath(env) {
+    return path.join(skillRoot(env), 'current');
+}
+/**
+ * A plain text pointer rather than a symlink. Symlink creation needs elevation or developer mode on
+ * Windows, and this has to work for every operator, not just the ones on a unix box.
+ */
+export function readCurrentVersion(env) {
+    try {
+        const v = fs.readFileSync(pointerPath(env), 'utf8').trim();
+        return v || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function readLocalBundle(env) {
+    const version = readCurrentVersion(env);
+    if (!version)
+        return null;
+    const dir = path.join(skillRoot(env), version);
+    let meta = {};
+    try {
+        meta = JSON.parse(fs.readFileSync(path.join(dir, 'bundle.json'), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+    let files = [];
+    try {
+        files = fs.readdirSync(dir).filter((f) => f !== 'bundle.json');
+    }
+    catch {
+        return null;
+    }
+    return { version, dir, files, fetchedAt: meta.fetchedAt || '' };
+}
+/**
+ * Reverses the server's origin substitution so a downloaded document hashes to the value the
+ * manifest published.
+ *
+ * The manifest hashes the RAW template, before substitution, so that a bundle cached on one Sella
+ * domain is not invalidated by re-checking from another. What arrives over HTTP is the rendered
+ * form. Putting the placeholder back is exact rather than approximate because the server guarantees
+ * no template contains a literal absolute origin (asserted by findLiteralOrigins in the app), so
+ * every occurrence of the origin in a served document came from the placeholder.
+ */
+export function canonicalize(body, origin) {
+    const trimmed = origin.replace(/\/+$/, '');
+    return trimmed ? body.split(trimmed).join(ORIGIN_PLACEHOLDER) : body;
+}
+export function hashCanonical(body, origin) {
+    return `sha256:${crypto.createHash('sha256').update(canonicalize(body, origin), 'utf8').digest('hex')}`;
+}
+export async function fetchManifest(origin, fetchImpl = fetch) {
+    const base = origin.replace(/\/+$/, '');
+    const res = await fetchImpl(`${base}/skill.json`);
+    if (!res.ok)
+        throw new SkillSyncError(`Could not read ${base}/skill.json (HTTP ${res.status}).`);
+    const manifest = (await res.json());
+    if (!manifest?.version || !manifest?.files) {
+        throw new SkillSyncError(`${base}/skill.json is not a skill manifest.`);
+    }
+    return manifest;
+}
+/**
+ * Brings the local bundle to the version the server is serving.
+ *
+ * Unchanged files are copied forward from the previous bundle rather than re-downloaded, which is
+ * why the manifest carries a per-file hash at all. A version bump for a one-line prose fix then
+ * costs one small request instead of the whole bundle.
+ */
+export async function syncSkillBundle(opts) {
+    const { env, origin } = opts;
+    const fetchImpl = opts.fetchImpl || fetch;
+    const manifest = await fetchManifest(origin, fetchImpl);
+    const previousVersion = readCurrentVersion(env);
+    const dir = path.join(skillRoot(env), manifest.version);
+    const alreadyCurrent = previousVersion === manifest.version && fs.existsSync(dir);
+    if (alreadyCurrent && !opts.force) {
+        return {
+            version: manifest.version,
+            previousVersion,
+            dir,
+            written: [],
+            reused: Object.keys(manifest.files),
+            upToDate: true,
+        };
+    }
+    fs.mkdirSync(dir, { recursive: true });
+    const written = [];
+    const reused = [];
+    for (const [name, entry] of Object.entries(manifest.files)) {
+        const target = path.join(dir, name);
+        // Reuse an identical file from the previous bundle when the hash says it did not change.
+        if (!opts.force && previousVersion) {
+            const old = path.join(skillRoot(env), previousVersion, name);
+            try {
+                const body = fs.readFileSync(old, 'utf8');
+                if (hashCanonical(body, origin) === entry.sha256) {
+                    fs.writeFileSync(target, body);
+                    reused.push(name);
+                    continue;
+                }
+            }
+            catch {
+                // Not present or unreadable in the old bundle; fall through and download it.
+            }
+        }
+        const res = await fetchImpl(entry.url);
+        if (!res.ok)
+            throw new SkillSyncError(`Could not download ${name} (HTTP ${res.status}).`);
+        const body = await res.text();
+        // Integrity, not just freshness. A truncated or tampered document is worse than a stale one
+        // because it looks authoritative, so a mismatch fails the sync rather than being written.
+        const actual = hashCanonical(body, origin);
+        if (actual !== entry.sha256) {
+            throw new SkillSyncError(`${name} does not match the hash in the manifest. Expected ${entry.sha256}, got ${actual}. ` +
+                `Nothing was written. Retry, and if it persists report it rather than using the file.`);
+        }
+        fs.writeFileSync(target, body);
+        written.push(name);
+    }
+    fs.writeFileSync(path.join(dir, 'bundle.json'), JSON.stringify({ version: manifest.version, origin: origin.replace(/\/+$/, ''), fetchedAt: new Date().toISOString() }, null, 2) + '\n');
+    fs.mkdirSync(skillRoot(env), { recursive: true });
+    fs.writeFileSync(pointerPath(env), `${manifest.version}\n`);
+    return { version: manifest.version, previousVersion, dir, written, reused, upToDate: false };
+}
+function major(version) {
+    const m = /^(\d+)\.\d+\.\d+$/.exec(String(version || '').trim());
+    return m ? Number(m[1]) : null;
+}
+export async function skillStatus(env, origin, fetchImpl = fetch) {
+    const manifest = await fetchManifest(origin, fetchImpl);
+    const local = readLocalBundle(env);
+    const localMajor = major(local?.version || null);
+    const remoteMajor = major(manifest.version);
+    return {
+        localVersion: local?.version || null,
+        remoteVersion: manifest.version,
+        upToDate: Boolean(local && local.version === manifest.version),
+        breaking: localMajor !== null && remoteMajor !== null && localMajor < remoteMajor,
+        dir: local?.dir || null,
+        readFirst: manifest.readFirst || null,
+    };
+}

package/dist/ui.js

@@ -78,7 +78,7 @@ export class Ui {
         if (this.quiet)
             return;
         if (!this.pretty) {
-            this.out(`SELLA — ${subtitle} (${meta})`);
+            this.out(`SELLA · ${subtitle} (${meta})`);
             return;
         }
         this.out('');
@@ -277,7 +277,7 @@ export class Ui {
             throw new Error(`Cannot prompt for "${label}" in a non-interactive run.`);
         if (!this.pretty) {
             this.out(label);
-            options.forEach((o, idx) => this.out(`  ${idx + 1}) ${o.label}${o.hint ? ` — ${o.hint}` : ''}`));
+            options.forEach((o, idx) => this.out(`  ${idx + 1}) ${o.label}${o.hint ? ` (${o.hint})` : ''}`));
             for (;;) {
                 const answer = (await this.plainQuestion(`Choose 1-${options.length} (${initial + 1}): `)).trim();
                 if (!answer)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sella-cli",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "Connect your AI agent to Sella, the marketplace where agents buy data and APIs, in one command: npx sella-cli. Installs the Sella MCP server into Claude Code, Cursor and more, then pairs, verifies, funds, and publishes.",
   "keywords": [
     "cli",
@@ -22,13 +22,26 @@
   ],
   "license": "MIT",
   "homepage": "https://sellag.vercel.app",
-  "bugs": { "url": "https://github.com/010100100100011101010100/ogsella/issues" },
-  "repository": { "type": "git", "url": "https://github.com/010100100100011101010100/ogsella", "directory": "cli" },
+  "bugs": {
+    "url": "https://github.com/010100100100011101010100/ogsella/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/010100100100011101010100/ogsella",
+    "directory": "cli"
+  },
   "type": "module",
-  "bin": { "sella": "./dist/index.js" },
+  "bin": {
+    "sella": "./dist/index.js"
+  },
   "main": "./dist/index.js",
-  "files": ["dist", "README.md"],
-  "engines": { "node": ">=18" },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "prepublishOnly": "npm run build",