obolos 1.5.0 → 1.6.1

package/package.json

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

package/skills/obolos/SKILL.md

@@ -113,15 +113,26 @@ 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. Role grants, upgrades and treasury
-withdrawals take the user's own key: `cli.missing_power` with `power: null` says so; pass that on. Its
-sends are sponsored and count against the user's daily limit.
+within the roles the wallet holds; Raise creates and runs rounds, and sets up the investor policy a
+round opens on: `obolos compliance policy create --preset <id> --class <class>` (`obolos compliance
+presets` lists them) and `obolos compliance rule attach`. It adds rules, never removes or loosens
+them; that is the user's, in the app. 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
@@ -144,8 +155,10 @@ 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:
+An agent doesn't create companies; the user does, in one obolos window the agent opens. Never run
+`obolos login` first, even when the user asks to connect: `login` only connects an agent wallet that
+already exists, while incorporating connects this terminal to the new company's agent. For testnet
+(try.obolos.io), add `--try` to `obolos company incorporate`. 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`

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,18 @@ 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`. A round opens on an investor policy with rules; a
+company with none needs one first (`obolos compliance policy create --preset <id> --class <class>`).
 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