obolos 1.4.1 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obolos",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "description": "Agent-friendly command line interface for the obolos protocol",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

package/skills/obolos/SKILL.md

@@ -58,7 +58,7 @@ skill together; run it when a command or flag this skill names is missing.
 obolos doctor --json   # RPC, chain, deployments, whether a key is configured
 obolos login           # connect this terminal as one of the user's agent wallets
 obolos login --try     # the same on try.obolos.io, when that is where the user's account is
-obolos companies       # companies the acting wallet holds a role in
+obolos companies       # companies the acting wallet holds a role in, or the agent holds powers at
 obolos use '#3'        # select a company by #id or address
 obolos whoami          # the agent wallet and its powers, or the key's roles there
 obolos company show
@@ -113,28 +113,31 @@ stand, so nothing is signed again. `obolos login --key` signs in with the user's
 An agent wallet does only what the user gave it on the Passport page, per wallet and company: Read
 opens the company, that wallet's holdings and the documents it can open; Vote casts votes and gives
 proxies; Manage equity runs share classes, shares, grants, vesting, notes, SAFEs and the data room,
-within the roles the wallet holds; Raise creates and runs rounds; Create a company sets up the one
-company the user named there. Role grants, upgrades and treasury withdrawals take the user's own
-key: `cli.missing_power` with `power: null` says so; pass that on. Run `obolos company incorporate` with that ticker,
-jurisdiction and entity; its deploy works once. `workflow.company.incorporate.plan_moved` means
-another company was created from that wallet since: deploy nothing and ask the user to give Create a
-company again. Its sends are sponsored and count against the user's daily limit.
+within the roles the wallet holds; Raise creates and runs rounds. Role grants, upgrades and treasury
+withdrawals are the user's to do in the app: `cli.missing_power` with `power: null` says so; pass that
+on, and never ask the user for a key. Its sends are sponsored and count against the user's daily limit.
 
 An agent buys no credits. `obolos credits topup [--amount <usd>]` opens the company's billing page in
 the user's browser and waits up to 15 minutes for the credits. Off a terminal, add `--no-wait`: it
 exits 6 with `cli.awaiting_credits` and `details.link`. Give the user the link, wait for them to say
 they loaded the credits, then check with `obolos credits show`.
 
+An agent activates no module either: activation is permanent and spends credits. `obolos company
+module activate <name>` checks the module can be activated, opens it on the company's Modules page in
+the user's browser and waits up to 15 minutes for it to be active. Off a terminal, add `--no-wait`: it
+exits 6 with `cli.awaiting_module` and `details.link`. Give the user the link, wait for them to say
+they activated it, then check with `obolos company modules`, whose `cost` is in credits. A company
+short of credits gets the same link (`creditsShort: true`): the activation there offers Add credits, so
+tell the user they add credits first, and don't send them to `credits topup`.
+
 - **Exit 3, `cli.session_ended`**: the session ended (disconnected, or past its 3 days). On a terminal
   the CLI offers to connect again; otherwise ask the user, then run `obolos login`.
 - **Exit 3, `cli.missing_power`**: `details` names the `power`, the `wallet` and the `company`. Tell
   the user to give it under the agent wallet's Powers on the Passport page; never route around it.
-- **Exit 3, `cli.outside_power`**: the call's values differ from the ones the user approved, such as
-  another ticker. Use the approved values, or ask the user to give the power again with these.
+- **Exit 3, `cli.outside_power`**: the call's values differ from the ones the user approved. Use the
+  approved values, or ask the user to give the power again with these.
 - **Exit 3, `cli.approval_stale`**: the approval was removed or used up, or the wallet changed. The user
   gives the powers again on the Passport page.
-- **Exit 3, `cli.split_operation`**: one operation can't carry these calls together; the deploy goes in an
-  operation of its own, one company at a time.
 - **Exit 5, `cli.nonce_taken`**: another operation from the wallet went first, and this one never went
   out. Run the command again.
 - **Exit 5, `cli.send_failed` with `details.operation`**: the operation went out, but how it ended
@@ -147,6 +150,29 @@ they loaded the credits, then check with `obolos credits show`.
 `obolos agents check <address>` asks whether a verified person stands behind any agent wallet. It
 never says who.
 
+### Making a company with the user
+
+An agent doesn't create companies; the user does, in one obolos window the agent opens. When the user
+wants a company:
+
+1. Ask for its name with the legal ending (Acme Inc.), a ticker, the jurisdiction (an ISO code such as
+   US, GB, CH) and the entity type (c-corp, llc, ...). An unknown one fails with `invalid_jurisdiction`
+   or `invalid_entity`, whose details list the choices. A share class name and authorized shares are
+   optional: the default is common stock, 10,000,000 authorized. Don't ask about founders or shares yet.
+2. Run `obolos company incorporate --name ... --ticker ... --jurisdiction ... --entity ...`
+   (`--class`, `--authorized` when given), nothing else. Tell the user the window shows the company,
+   asks whether they want Plus, and creates it once they confirm; its agent then gets every power
+   there and this terminal connects to it.
+3. When it returns, this terminal works as the company's agent, at the company. Offer what comes next,
+   one at a time: loading credits (`obolos credits topup`), issuing the user's shares to their wallet at
+   the company (`obolos whoami` names it) with `obolos shares issue`, vesting, documents for the data
+   room the window created (`obolos docs upload`). The legal details of an existing entity (state, file
+   number, address) go in the company's Settings in the app. Every send still waits for the user's yes.
+
+Off a terminal, add `--no-wait` in step 2: it exits 6 with `cli.awaiting_approval`, `details.link` and
+`details.userCode`. Give the user both, wait for them to say the company is created, then run
+`obolos login --resume`.
+
 ## Runs and sending
 
 A prepared command writes a hash-verified run file (`.obolos/runs/<workflow>-<id>.json`) and prints

package/skills/obolos/references/operations.md

@@ -61,7 +61,7 @@ Choose the remedy from the structured SDK error:
 - compliance error: identify the rule and the legitimate state, credential or approval needed.
 - insufficient credits: quote the deficit and prepare a top-up separately. A top-up or preload under
   the ledger's minimum is refused (`below_minimum`, `preload_below_minimum`). As an agent, the user
-  loads them: `obolos credits topup` opens their browser, and a preload is refused (`agent_preload`).
+  loads them: `obolos credits topup` opens their browser.
 - `cli.no_agent_here` (exit 6): no agent this terminal is connected as works at the company. Ask the
   user to run the `obolos login --company <company>` it names; the page gives their agent there
   Invest and Read, and the command then goes on as that agent. Never connect it without their word.

package/skills/obolos/references/tooling.md

@@ -61,7 +61,7 @@ is the key's address, or after `obolos login` the user's wallet the agent wallet
 needs only that wallet, and sealing confidential inputs binds them to it. With a key, decrypting,
 publishing verdicts and sending need the key. As an agent wallet, decrypting needs Read on that wallet
 at the company, sending needs the power that makes each call, and a command that signs as the wallet
-itself, such as publishing a verdict, needs the user's key: `obolos login --key`.
+itself, such as publishing a verdict, is the user's to do in the app. Never ask the user for a key.
 
 A terminal can hold several agent wallets; each `obolos login` adds one and puts it in use. At a
 company the CLI acts as the agent in use when it holds powers there, otherwise as a connected agent

package/skills/obolos/references/workflows.md

@@ -170,7 +170,7 @@ A denied verdict is a valid outcome, not a reason to vary the quantity until one
 ## Fundraising round
 
 ```bash
-obolos fundraise create --type safe --name Seed --target 1,000,000 --hard-cap 2,000,000 --cap 10,000,000 --discount 20% --agreement <round agreement ref>
+obolos fundraise create --type safe --name Seed --target 1,000,000 --hard-cap 2,000,000 --cap 10,000,000 --discount 20% --agreement ./term-sheet.pdf
 obolos fundraise reserve <round> --investor <wallet> --amount 250,000         # a spot, its amount sealed, signed for the company by a document signer
 obolos fundraise reservation sign <round> --reservation <id>                  # investor, with their key: signs the spot (--accept-terms only once they agree to terms that differ from the round's)
 obolos fundraise subscribe <round> --amount 50,000                            # investor, with their key
@@ -181,12 +181,17 @@ obolos fundraise close <round> && obolos fundraise finalize <round>
 obolos fundraise publish <round>
 ```
 
-Confirm the company profile supports the round and instrument and that the engine is deployed.
+Confirm the round is one `obolos company show` lists under `jurisdiction.instruments`. One with
+`active: false` needs each module in its `activate` list activated first (`obolos company module
+activate <module>`); every round runs on `fundraise`.
 Prepare round creation, document references, whitelist changes and reservations in their natural
 stages; counterparty-signed reservations and encrypted investor inputs are not manager batches.
 
 - **Create** makes the round's data room, publishes the round's agreement unsigned in its Term Sheets,
-  then opens the round (its document reference is the room), so the run is staged.
+  then opens the round (its document reference is the room), so the run is staged. Give the agreement
+  as a document on this machine (.pdf, .md, .txt or .docx). The run pins its hash and stores it
+  unsealed once the user sends the run's first step, the data room, which says so. Don't upload it to a
+  data room first; the round refuses an `obolos://` reference.
 - **Sealed figures.** Money never moves through the contract, and every amount is sealed. A priced
   round's price per share is sealed too, with a public commitment the round's agreement names. The
   company reads it; adding an address to the whitelist shows it the price for good; `subscribe` first