Skip to main content
Back to CLI Docs

Release history

Every shipped version of @solidnumber/cli — the first CLI built for AI agents. Newest at the top.

Authored by Adam Campbell · BSL-1.1 (converts to Apache 2.0 on 2030-04-14) · GitHub · npm

All releases

Quick scan. Each row is one published version. The deep-dives for the architecturally significant releases follow below.

VersionDateSummary
v2.20.02026-09A failed command no longer looks like a successful one. ⛔ BEHAVIOUR CHANGE, and the reason this is a minor rather than a patch. The CLI's failure paths exited 0 — and for an agent, the only caller this surface really has, exit 0 with no payload is indistinguishable from "succeeded, found nothing". Seven of eleven `get` commands reported success on a 404 and moved on. Three separate causes, all closed: the `fail(spinner, msg, err)` helper had been copy-pasted into 23 command modules and 22 of those copies printed and then fell through, so ~500 call sites now share one helper that always exits 1 and emits the JSON error envelope that already existed and was already default-on; HTTP 200 responses carrying an error-shaped body (`forms get` answering a miss with {status:"error"}, `invoices get` with {ok:true,result:{error:"invoice_not_found"}}) are now rejected by the response interceptor, deliberately narrowly, checked against live responses so `health` and `invoices list` do not trip it; and unknown positional arguments are REJECTED rather than silently discarded. That last one is the change to read twice: a script passing a stray argument that used to vanish will now fail — which is also why `solid completion bash` finally emits bash and `solid completion fish` emits fish, instead of both quietly emitting zsh as they have since v1.9. 168 top-level commands, 905 verbs.
v2.19.02026-09solid update — one command to get current, whichever way you installed. The notifier already told you a new version existed and then left you to remember the incantation; now `solid update` works out how this copy got here and runs the right thing — npm install -g, brew upgrade, or scoop update — with --check to see what would happen and --json for an agent. ⛔ The bug it really exists for is the SECOND COPY. A machine can carry two `solid` binaries at once — an npm global under nvm AND a Homebrew formula — and whichever comes first in PATH wins, so upgrading one leaves the other lying in wait: open a shell before nvm initialises, or switch Node versions, and you are silently running a CLI from weeks ago that disagrees with the backend about which verbs exist. Found exactly that in the wild, two installs seven releases apart, with nothing said. The update notifier cannot see it — it only ever looks at the copy that is running — so `solid update` scans PATH and names the others. Detection puts Homebrew ahead of npm deliberately: a brew formula's payload also lives in a node_modules directory, and getting that backwards prints `npm install -g` to a Homebrew user, quietly installing a THIRD copy instead of upgrading the one they have. Being offline is not an error — it prints the command instead of failing. 168 top-level commands, 905 verbs.
v2.18.02026-09A business becomes a file you can apply. solid apply reads a manifest, shows you a plan, reconciles the tenant toward it, and remembers what it did — a lockfile, three-way drift (declared vs lock vs live, so a dashboard edit and a manifest edit are never confused), rollback from the pre-images it captured, and export to adopt a company that already exists without hand-authoring its manifest. Sixteen resource kinds now: products, contacts, deals, webhooks, pages, sites, domains, surveys, knowledge base, services, brand, agents, phone lines, and — new here — capabilities, commerce flows and the payment processor, so a manifest can finally say what the business is ALLOWED to do and who takes the money, not only what it looks like. ⛔ Apply configures; it does not conjure. It will not buy a phone number, will not create an agent (those come from the registry), will not activate a flow (that starts it running), and will not edit a connected processor in place — rotating live payment credentials from a manifest is an outage waiting for a typo, so drift is reported and nothing is rewritten. Every refusal prints its reason instead of failing quietly, and the reason is specific: the processor tells you to reconnect, not to delete and recreate, because for a live payment connection that advice takes payments down. 164 top-level commands, 874 verbs.
v2.17.02026-09Deals report their own progress, quizzes actually branch, and the advertised numbers are generated rather than typed. solid deals reads the deal and reports where it stands — offer and order milestones — so an agent can answer "what is left on this?" without stitching three calls together. Quiz scoring walks the real branching path instead of a flattened list, so a quiz that forks on an answer is scored the way the respondent actually experienced it. The legacy REST seam now closes wherever a verb exists: one vocabulary, one code path, and no second way to do the same thing that drifts from the first. sync-counts generates every advertised count instead of trusting a human to walk twelve surfaces — it stamps the CLI's own paired phrasing and REFUSES what it must not touch (a minimum version like @2.10+, a dated changelog line, WebMCP's separate measurement), printing each refusal so a clean run can never hide one; prepublishOnly runs it in check mode, so a stale surface stops a publish instead of shipping a wrong number. Verb and command discovery is unchanged and still LIVE — the CLI reads /api/v1/agent/verbs at call time, so a platform-side change reaches you without a release. 164 top-level commands, 870 verbs.
v2.16.02026-08Forms, operable — solid forms is rebuilt on the verb layer and grows the whole product: moments (when a form goes out), reviews (where a happy customer is sent), build (a starter drafted in this business's own industry words, saving nothing without --save), walk (answer a form the way an agent does — next question, capture, submit), vocabulary, and the lifecycle: publish, pause, resume, link. Every live form now has a standing public address, and embed builds a paste-ready iframe around it instead of the old pre-lifecycle link. solid verbs invoke gains --confirm: write verbs were previously refused by the backend with a message naming a flag that did not exist, so nothing that writes was invokable from the CLI at all. No command sends company_id or an industry code — the tenant and its words are resolved server-side from the authenticated principal.
v2.15.12026-08Fix — solid transaction start and solid transaction append now send confirm. Both verbs are declared side_effects=write; they previously reached the backend handler only because the explicit /api/v1/agent routes bypassed the confirm gate, and that bypass is now closed. Opening a transaction handle is the user's own action, so the CLI confirms on their behalf rather than requiring a flag. Clients below 2.15.1 receive a 400 on those two commands once the backend change is live. No other command is affected.
v2.152026-07The Starter Kit — solid init <name> --company <id> scaffolds a tenant-stamped starter project bound to one Solid# company. The generated project carries a CLAUDE.md with the operating rules (ground-don't-guess, persist-to-company_id, preview→confirm, start_here/end_session), a .solid/config.json tenant stamp (company_id + connector URL), a token-safe .gitignore, a scoped-token .env.example, and it git init's the client's own repo — so a coding agent builds on the right tenant from line one, with tokens never committed. A companion connector verb, scaffold_project, hands the same starter pack over the wire for agents working through the hosted MCP connector rather than the CLI. Command and verb surface unchanged: 163 top-level commands, 748 verbs.
v2.142026-07Telephony command center — the phone system becomes a first-class CLI surface. solid voice lines shows every line you can see (owner, routing mode, backing AI agent); lines routing <line_id> <mode> sets who fields a call (ring | ask | ai | off); lines context returns your default line + today's call counts in one call; solid voice spend breaks usage and charges down per line/user/agent; solid voice pricing prints number rentals, plans, and transcription rates. solid call simulate dry-runs a caller through a line's answer ladder + bound phone tree — key presses and intents via --inputs, nothing rings, --json exits 1 on flow errors so a routing change can be proven from CI before it ever answers a real customer (the same switchboard.simulate verb the Phone Tree builder's test button uses). solid insights report is the master communications report in the terminal — sentiment, call evaluation, and needs-attention rollups across every channel. The MCP connector surface (claude.ai, ChatGPT, and stdio via @solidnumber/mcp for Claude Desktop / Cursor / Windsurf) is hardened for broad client compatibility, so an agent loads the full verb surface reliably on connect. 163 top-level commands, 748 verbs.
v2.132026-06The operator brief + discoverability. solid today is the one-command daily brief — net revenue, open pipeline, urgent/pending work, and ranked recommended next actions assembled from your live business in a single call (--json for agents). solid how-to answers in plain language how to connect Solid# to Claude or ChatGPT (the MCP connector flow + URL), where to start as an operator, and what the CLI can do — discoverability for non-technical owners and agents alike, no command-dump required. Pairs with the matching connector self-knowledge: the claude.ai / ChatGPT connector now ships a how_to tool so the assistant can explain itself in-session. solid whoami / solid auth status now show which company you are bound to by name, your role, and your tier — so you (and your agents, via --json) can see your scope and permission level at a glance, not just a company id.
v2.122026-06Site-Publish Substrate — build a business from one manifest. solid apply now reconciles page, site, domain, and survey kinds alongside products, contacts, deals, and webhooks: declare the whole business surface in one YAML, apply, then solid publish --all takes it live on your domain (immutable kinds report drift instead of silently mutating). solid embed chat|form|paylink emits ready-to-paste snippets — HTML or --react — that wire any website, including AI-generated ones, to the live backend: the AI chat widget, lead forms that create CRM contacts with lead scoring on every submission, and hosted payment-link checkout. solid context --claude now installs the solid-commerce Claude Code skill into the tenant-bound directory so coding agents wire generated sites to real forms, chat, and payments by default.
v2.112026-05/06Substrate layer + sales agent + outbound voice. solid apply <manifest> declarative desired-state reconcile (create / update / prune, --dry-run, content-derived idempotency) — GitOps for a tenant; solid signal stream server-pushed SSE events; @solidnumber/cli/client programmatic package export; Idempotency-Key on every mutation; broad Node 18+ runtime. Sales Agent CLI: 18 AI-powered solid sales verbs (pipeline/forecast reads, KB-grounded scoring + outreach suggestions, consent-gated qualify/advance/close, voice-handoff nurture) wired to 5 agents, plus editor-anywhere onboarding (preflight detects installed-but-can't-run editors; VS Code + Claude Code first-class; solid ai gains Gemini + Grok targets). Outbound voice + universal verb dispatch. solid voice call <phone> and solid voice text <phone> dispatch ADA to place real outbound calls and send SMS — same tenant rate limits as inbound. solid voice translate enable|disable|status <phone> toggles per-phone live speech-to-speech translation (13 output languages; opt-in, Pro+ tier). solid agent dispatch <verb> is the universal entry point — call any of the agent-attraction verbs across every business function through one command. New shortcut commands solid deal, solid calendar, solid lead-promote promote the highest-traffic CRM/scheduling flows to first-class. solid voice health is a per-tenant voice-readiness audit.
v2.102026-05Multi-site operator commands. solid sites list shows every tenant the calling identity can access; solid sites switch <slug> rebinds .solid/manifest.json in-place — agents handling multiple tenants no longer need to track slugs by hand. The agent-attraction surface continues to ship declare-once across five transports.
v2.92026-05Universal verb invoker — AI-first by default. The agent-attraction surface is now declare-once on the backend (services/agent_verb_manifest.py) and auto-bridged to five transports (HTTP, MCP stdio, WebMCP, UCP, CLI). solid verbs list auto-discovers every verb from GET /api/v1/agent/verbs (public, no auth). solid verbs describe returns JSON Schema for agent validators. solid verbs invoke auto-routes GET vs POST. A new verb declared in the backend manifest lights up the CLI on the next session — no CLI release required. 13 parity assertions guarantee drift across the four transport registries cannot ship.
v2.82026-05Agent-attraction primitives in the CLI. solid transaction (start/append/commit/abort/get) wires the backend's atomic-batch substrate — single rollback point for an agent that needs to run N mutations as one unit. solid manifest prints the tenant JSON-LD manifest (@context + entity IRIs + capability graph) so agents can plan against a single canonical retrieval. solid audit log (paginated, cursor-based, JSON/JSONL/table) hits the new /api/v1/agent/audit endpoint. The terminal is now the operator-side of the agent-attraction surface; the same verbs are MCP-discoverable from Claude Code / Cursor and HTTP-callable from any agent runtime.
v2.72026-05Agent transports go cross-runtime. First-class solid webmcp + solid ucp verbs. The same JSON-LD verb registry is now drivable from stdio MCP (your AI editor), in-browser WebMCP (navigator.modelContext, 31 verbs across 5 surfaces), and UCP (signed buyer-agent wire format). One vocabulary, three transports.
v2.62026-05Predict-and-Act GA — TabPFN-v2 (Nature 2025) zero-shot tabular foundation model wired through solid predict. Day-1 predictions on tiny histories, no per-tenant training, no cold-start. Devon auto-discovers new predict targets nightly. Q-Chain auditor surface (solid qchain export/verify/audit-key) — external auditors validate the agent-action chain offline against /.well-known/qchain.json. Email capture on solid demo create with Sarah-drafted Layer 2 outreach. Magic-link install. brew + scoop distribution.
v2.52026-05solid tenant gate-debug — compute-budget activity gate returns its full decision with a machine-readable reason code (dormant_no_activity_ever, owner_allowlist_billing_exempt, …) so agents pattern-match instead of inferring.
v2.42026-05solid predict surface — deal-close, no-show, payment-late, targets. Tabular Foundation Model engine (TabPFN-v2) — zero-shot under tenant data.
v2.02026-04-30Agent-ready by default. Structured JSON error envelopes ship out of the box; SOLID_LEGACY_ERRORS=1 restores 1.x prose for legacy human-written scripts.
v1.262026-04-22Tenant graph diff + N-Quads/Turtle dump. Pipe into Jena, Neo4j, Blazegraph, GraphDB, Neptune.
v1.242026-04-18Offline mutation queue. Auto-detects connectivity loss. solid push --flush replays. Idempotency keys travel with each queued mutation.
v1.222026-04-14JSON-LD tenant graph + SPARQL 1.1 (offline BGP + online --server). Self-describing JSON-LD per @type.
v1.212026-04-10solid graph — typed walk of every Company/Service/Product/Agent/KB/Chain/Webhook.
v1.102026-03-28Opt-in JSON envelopes via SOLID_JSON_V2=1. AI-Driven CLI with 4-layer safety (mode caps, destructive gate, sandbox, backend enforcer).
v1.02026-03-15First public release. solid auth login, pull, push, kb, pages, ai.

v2.0 — Agent-Ready by Default

Breaking

Structured JSON error envelopes — opt-in since 1.10 via SOLID_JSON_V2=1 — are now on by default. Every --json error response ships code, status, hint, docs_url, request_id, and tier/feature/upgrade context. AI agents (Claude Code, Cursor, Codex) work out of the box; humans see the same prose they always did.

2.0 default — structured envelope
$ solid kb get 99 --json
{
  "error": {
    "code": "NOT_FOUND",
    "status": 404,
    "message": "KB entry 99 not found",
    "hint": "Run \"solid kb list\" to see valid IDs",
    "docs_url": "https://solidnumber.com/docs/cli#kb",
    "request_id": "req_8f2a3c"
  }
}
Opt-out — restore 1.x prose
$ SOLID_LEGACY_ERRORS=1 solid kb get 99 --json
Error: KB entry 99 not found
  Hint: Run "solid kb list" to see valid IDs
# 1.x scripts that pattern-match prose still work.

Migration in 30 seconds

  • • You wrote scripts that parse JSON errors: already on the new shape if you set SOLID_JSON_V2=1 — nothing changes.
  • • You wrote scripts that grep prose error text: set SOLID_LEGACY_ERRORS=1 in your shell or CI to restore the 1.x shape, then migrate when you have time.
  • • You drive the CLI from an AI agent: do nothing. The new shape is what you wanted all along.

Tenant Graph + Offline Mutations (v1.21 → v1.26)

Stable

Your tenant's entire surface — companies, services, products, agents, KB, chains, webhooks — ships as a typed JSON-LD graph. Walk it, query it with SPARQL, diff snapshots, dump it into any RDF store, and write to it from a plane.

solid graph --querySPARQL

Offline BGP runs in-process against the bundled .claude/solid-context.jsonld. Add --server for full SPARQL 1.1 (OPTIONAL, FILTER, property paths, UNION, GROUP BY).

Terminal
solid graph --query \
  "SELECT ?s WHERE { ?s a schema:Service }"

solid graph --query "..." --server      # full SPARQL 1.1
solid push --queueoffline-first

Lose wifi mid-mutation, the CLI auto-queues. Regain wifi, the next call auto-replays the queue. No flag, no ceremony. Or arm it explicitly with --queue for plane mode.

Terminal
solid push --queue       # arm offline mode
solid push --flush       # replay queued mutations
# or just lose connectivity — it auto-queues + auto-replays
solid graph --diffCI gate

Structural diff between a baseline snapshot and the current graph. Exit code is the signal — gate CI on tenant stability.

Terminal
solid graph --diff baseline.jsonld --offline \
  || echo "tenant drifted"
solid graph --dumpN-Quads / Turtle

Pipe the tenant graph into Apache Jena Fuseki, Neo4j, Blazegraph, GraphDB, or Neptune. N-Quads is the canonical lossless format every RDF store accepts.

Terminal
solid graph --dump nquads --offline \
  | tdbloader2 --loc /var/jena/db -

AI-Driven CLI

Stable

The CLI isn't just for humans anymore. Claude Code, Cursor, and Codex can drive every command on your behalf — with four safety layers so a hallucinating AI can't issue refunds or delete customer data.

solid aistupid easy

Auto-detects Claude Code / Cursor / Codex, refreshes company context, launches your AI with everything it needs to reason about your business.

Terminal
solid auth login
solid ai                         # launches detected AI for your current company
solid ai --as cursor             # force Cursor
solid ai --no-context            # skip the context refresh
solid ai --sandbox               # safe-preview mode — every mutation intercepted

# Switching company (rare — agencies + multi-tenant operators):
solid auth me                    # shows your active company_id
solid auth companies             # lists every company your account belongs to
solid ai --company <id>          # override for this session
solid installonce, ever

Wires a Claude Code SessionStart hook so claude auto-refreshes .claude/CLAUDE.md every session. Idempotent. Undo with --uninstall.

Terminal
solid install
solid auth login
claude                           # context already fresh

Four layers of safety

LayerWhat it doesWhere
Mode capRefuses out-of-scope verbs before they parseCLI (client-side)
Destructive gaterefund / delete / cancel / revoke require --yesCLI (client-side)
SandboxEvery mutation intercepted; AI sees what would happenCLI dry-run
Backend enforcerServer-side mirror so scripted HTTP can’t bypassBackend middleware
Mode caps--mode

Scope what the AI can touch. Client and server both enforce, so a compromised HTTP client can't bypass.

customer — CRM, orders, voice, analytics
developer — pages, push, sandbox, vibe
agency — switch, company, users, train
full — no cap (default for humans)
Terminal
solid ai --mode customer
solid ai --mode developer --sandbox
Sandbox--sandbox

Every mutation the AI attempts is intercepted and mocked. The AI's reasoning still works because it sees a “would have worked” shape; nothing lands in real state.

Terminal
solid ai --sandbox
# → "Sandbox: ON — every mutation intercepted."
# Agent runs freely. Re-run without --sandbox to apply.
solid agent activityaudit trail

Every AI-driven request carries X-Solid-Agent, X-Solid-Agent-Mode, and X-Solid-Human-Initiator headers. The backend logs them so you always know what an AI did, in which mode, on behalf of whom.

Terminal
solid agent activity                # 24h summary card
solid agent activity --range 7d     # weekly
solid agent activity --events       # raw feed
solid agent activity --json         # programmatic
Back to CLI reference
Release history — @solidnumber/cli changelog | Solid#