@monoes/monomindcli 1.9.16 → 1.10.0

package/.claude/skills/mastermind/approve.md

@@ -0,0 +1,181 @@
+---
+name: mastermind-approve
+description: Mastermind approve — review and action pending approval requests from agents in a running org. Agents can request human approval before proceeding with sensitive actions.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Approve
+
+This skill is invoked by `mastermind:approve` or directly via `/mastermind:approve`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block
+- `org_name`: org to check approvals for
+- `action`: list | approve | reject | inspect
+- `approval_id`: id of the specific approval request (for approve/reject/inspect)
+- `reason`: optional reason for rejection
+- `caller`: command | master
+
+---
+
+## Step 0 — Brain Load (standalone only)
+
+If `caller` is not "command", load brain context following _protocol.md Brain Load Procedure with namespace: `ops`.
+
+---
+
+## Step 1 — Load Approvals
+
+Approvals are stored in `.monomind/orgs/<org_name>-approvals.json`:
+
+```bash
+orgFile=".monomind/orgs/${org_name}.json"
+approvalsFile=".monomind/orgs/${org_name}-approvals.json"
+[ ! -f "$approvalsFile" ] && echo '{"approvals":[]}' > "$approvalsFile"
+```
+
+---
+
+## Step 2 — Execute Action
+
+### list (default)
+
+Show pending approval requests from agents:
+
+```bash
+jq -r '
+  .approvals | map(select(.status == "pending")) |
+  if length == 0 then "No pending approvals." else
+    .[] | "[\(.id)] \(.agent_id): \(.title)\n  Action: \(.action)\n  Risk: \(.risk_level // "low")\n  Requested: \(.requested_at)"
+  end
+' "$approvalsFile"
+```
+
+Render as:
+```
+PENDING APPROVALS — org: <org_name>
+──────────────────────────────────────────────────
+[req-001] content-writer: Publish to external blog
+  Action: POST to https://blog.example.com/api/posts
+  Risk:   medium
+  Requested: 2 min ago
+
+[req-002] marketer: Send email campaign
+  Action: Send to 1,200 subscribers
+  Risk:   high  ← requires explicit approval
+  Requested: 5 min ago
+──────────────────────────────────────────────────
+2 pending  |  Type "approve <id>" or "reject <id> <reason>"
+```
+
+### inspect
+
+Show full details of a single approval request:
+
+```bash
+jq --arg id "$approval_id" '.approvals[] | select(.id == $id)' "$approvalsFile"
+```
+
+Print the agent's requested action, context, and any supporting evidence they provided.
+
+### approve
+
+Update approval status and notify the waiting agent via memory:
+
+```bash
+tmp="${approvalsFile}.tmp"
+jq --arg id "$approval_id" \
+   '.approvals = [.approvals[] | if .id == $id then .status = "approved" | .resolved_at = (now|todate) | .resolved_by = "human" else . end]' \
+   "$approvalsFile" > "$tmp" && mv "$tmp" "$approvalsFile"
+
+# Notify the agent via memory so it can proceed
+approval=$(jq --arg id "$approval_id" '.approvals[] | select(.id == $id)' "$approvalsFile")
+agent_id=$(echo "$approval" | jq -r '.agent_id')
+memNs="org:${org_name}"
+npx monomind@latest memory store \
+  --key "${memNs}:approval:${approval_id}" \
+  --namespace "$memNs" \
+  --value '{"status":"approved","approval_id":"'"$approval_id"'","ts":"'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'"}'
+
+echo "Approved request $approval_id — agent $agent_id may proceed."
+```
+
+Emit `org:approval:approved` event to dashboard.
+
+### reject
+
+```bash
+tmp="${approvalsFile}.tmp"
+jq --arg id "$approval_id" --arg reason "${reason:-No reason given}" \
+   '.approvals = [.approvals[] | if .id == $id then .status = "rejected" | .resolved_at = (now|todate) | .resolved_by = "human" | .rejection_reason = $reason else . end]' \
+   "$approvalsFile" > "$tmp" && mv "$tmp" "$approvalsFile"
+
+approval=$(jq --arg id "$approval_id" '.approvals[] | select(.id == $id)' "$approvalsFile")
+agent_id=$(echo "$approval" | jq -r '.agent_id')
+memNs="org:${org_name}"
+npx monomind@latest memory store \
+  --key "${memNs}:approval:${approval_id}" \
+  --namespace "$memNs" \
+  --value '{"status":"rejected","approval_id":"'"$approval_id"'","reason":"'"${reason:-No reason given}"'","ts":"'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'"}'
+
+echo "Rejected request $approval_id. Agent $agent_id has been notified."
+```
+
+Emit `org:approval:rejected` event.
+
+---
+
+## How Agents Request Approval
+
+Agents that need human approval before a sensitive action should:
+
+1. Write to the approvals file:
+```bash
+approvalsFile=".monomind/orgs/${orgName}-approvals.json"
+[ ! -f "$approvalsFile" ] && echo '{"approvals":[]}' > "$approvalsFile"
+approval_id="req-$(date +%s)"
+tmp="${approvalsFile}.tmp"
+jq --arg id "$approval_id" \
+   --arg agent "$role_id" \
+   --arg title "$action_title" \
+   --arg action "$action_description" \
+   --arg risk "medium" \
+   '.approvals += [{"id":$id,"agent_id":$agent,"title":$title,"action":$action,"risk_level":$risk,"status":"pending","requested_at":(now|todate)}]' \
+   "$approvalsFile" > "$tmp" && mv "$tmp" "$approvalsFile"
+```
+
+2. Emit `org:approval:requested` event to dashboard (so the human is notified).
+
+3. Poll memory for the approval decision:
+```bash
+while true; do
+  result=$(npx monomind@latest memory search --query "approval:${approval_id}" --namespace "${memNs}" 2>/dev/null)
+  status=$(echo "$result" | jq -r '.[0].value.status // ""' 2>/dev/null)
+  [ "$status" = "approved" ] && break
+  [ "$status" = "rejected" ] && { echo "Action rejected: $(echo $result | jq -r '.[0].value.reason // ""')"; exit 1; }
+  sleep 30
+done
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org: <org_name>
+approval_id: <approval_id if applicable>
+pending_count: <N>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/.claude/skills/mastermind/architect.md

@@ -65,7 +65,9 @@ If this skill is invoked directly (not by master):
 
 1. If `sessionId` was not provided by the caller: generate it by taking the current UTC datetime formatted as `YYYYMMDDTHHmmss` and prefixing with `mm-` (e.g. `mm-20260506T142345`). Then emit `session:start` (if `caller` is `standalone` — skip if `command` or `master`, as the caller emits it). Before executing the curl below, substitute the generated sessionId for `<sessionId>`:
    ```bash
-   curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+   REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+   CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+   curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
      -H "Content-Type: application/json" \
      -d '{"type":"session:start","session":"<sessionId>","domain":"architect","ts":'"$(date +%s)"'000}' || true
    ```
@@ -100,7 +102,9 @@ If this skill is invoked directly (not by master):
 6. Proceed with complexity assessment below
 7. At end: emit `session:complete` (if `caller` is `standalone`). Before executing the curl below, substitute the resolved sessionId for `<sessionId>`:
    ```bash
-   curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+   REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+   CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+   curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
      -H "Content-Type: application/json" \
      -d '{"type":"session:complete","session":"<sessionId>","domain":"architect","ts":'"$(date +%s)"'000}' || true
    ```
@@ -289,7 +293,9 @@ Before spawning, resolve two values:
 Then emit `agent:spawn` for the manager and spawn it. Before executing the curl below, substitute the resolved sessionId for `<sessionId>`:
 
 ```bash
-curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -H "Content-Type: application/json" \
   -d '{"type":"agent:spawn","session":"<sessionId>","domain":"architect","agent":"<manager_agent_type lowercased and hyphenated, e.g. software-architect>","task":"coordinate architecture analysis","ts":'"$(date +%s)"'000}'
 ```
@@ -437,14 +443,18 @@ The `description` must be the complete briefing, including CONTEXT, BRAIN MEMORY
 
 BEFORE spawning each agent, emit agent:spawn to the live dashboard. Before each of the following curl commands executes, `<sessionId>` must already be substituted with the session ID from the CONTEXT header Session field above. When substituting `<stream-description>` and other free-text fields into the JSON payload, strip any double-quotes and backslashes from the value to keep the JSON well-formed:
 \`\`\`bash
-curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -H "Content-Type: application/json" \
   -d '{"type":"agent:spawn","session":"<sessionId>","domain":"architect","agent":"<subagent_type lowercased and hyphenated, e.g. software-architect>","task":"<stream-description>","ts":'"$(date +%s)"'000}'
 \`\`\`
 
 If handing off artifacts to another domain (e.g. build for refactoring implementation, review for post-restructure check), emit intercom. When substituting `<msg>` and other free-text fields, strip any double-quotes and backslashes from the value to keep the JSON well-formed:
 \`\`\`bash
-curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -H "Content-Type: application/json" \
   -d '{"type":"intercom","session":"<sessionId>","from":"architect","to":"<domain>","msg":"<msg>","ts":'"$(date +%s)"'000}'
 \`\`\`
@@ -453,7 +463,9 @@ To track task execution, log progress via \`monotask card comment add "$BOARD_ID
 
 BEFORE returning, emit domain:complete to the live dashboard:
 \`\`\`bash
-curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -H "Content-Type: application/json" \
   -d '{"type":"domain:complete","session":"<sessionId>","domain":"architect","status":"<choose: complete | partial | blocked>","artifacts":[],"decisions":[],"ts":'"$(date +%s)"'000}'
 \`\`\`
@@ -539,7 +551,9 @@ Before executing the curl blocks below and when constructing the Task() descript
 
 1. Emit `agent:spawn` to the dashboard (use the resolved agent slug):
    ```bash
-   curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+   REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+   CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+   curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
      -H "Content-Type: application/json" \
      -d '{"type":"agent:spawn","session":"<sessionId>","domain":"architect","agent":"<resolved agent slug, e.g. software-architect>","task":"<prompt>","ts":'"$(date +%s)"'000}'
    ```
@@ -553,7 +567,9 @@ Before executing the curl blocks below and when constructing the Task() descript
 3. Include current directory structure context (`find . -maxdepth 3 -type d | grep -Ev "(^|/)(node_modules|dist|\.git)(/|$)"`)
 4. Collect output, then emit `domain:complete`:
    ```bash
-   curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+   REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+   CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+   curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
      -H "Content-Type: application/json" \
      -d '{"type":"domain:complete","session":"<sessionId>","domain":"architect","status":"complete","artifacts":[],"decisions":[],"ts":'"$(date +%s)"'000}'
    ```

package/.claude/skills/mastermind/backup.md

@@ -0,0 +1,197 @@
+---
+name: mastermind-backup
+description: Mastermind backup — create, list, and restore compressed org backups. Archives org config, state, goals, routines, approvals, projects, and activity log into a timestamped tarball.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Backup
+
+This skill is invoked by `mastermind:backup` or directly via `/mastermind:backup`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `org_name`: org to back up or restore (optional for `list`; required for `create`/`restore`)
+- `action`: create | list | restore | delete
+- `backup_file`: path to backup archive (required for `restore`/`delete`; auto-selected for `restore` if omitted → latest)
+- `backup_dir`: directory to store backups (default: `.monomind/backups`)
+- `include_state`: whether to include runtime state file (default: false — state is ephemeral)
+- `caller`: command | master
+
+---
+
+## Step 0 — Brain Load (standalone only)
+
+If `caller` is not "command", load brain context following _protocol.md Brain Load Procedure with namespace: `ops`.
+
+---
+
+## Step 1 — Ensure Backup Directory
+
+```bash
+backupDir="${backup_dir:-.monomind/backups}"
+mkdir -p "$backupDir"
+```
+
+---
+
+## Step 2 — Execute Action
+
+### create
+
+Create a compressed backup of all org data files:
+
+```bash
+[ -z "$org_name" ] && { echo "ERROR: --org required for create."; exit 1; }
+orgFile=".monomind/orgs/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
+
+timestamp=$(date +%Y%m%d-%H%M%S)
+archiveName="${org_name}-${timestamp}.tar.gz"
+archivePath="${backupDir}/${archiveName}"
+
+# Collect files to back up
+filesToBackup=""
+for suffix in "" "-goals" "-routines" "-approvals" "-projects" "-worktrees" "-bootstrap"; do
+  f=".monomind/orgs/${org_name}${suffix}.json"
+  [ -f "$f" ] && filesToBackup="$filesToBackup $f"
+done
+
+# Optionally include runtime state
+if [ "${include_state:-false}" = "true" ]; then
+  stateFile=".monomind/orgs/${org_name}-state.json"
+  [ -f "$stateFile" ] && filesToBackup="$filesToBackup $stateFile"
+fi
+
+# Include recent activity (last 500 lines filtered by org)
+eventsFile="data/mastermind-events.jsonl"
+if [ -f "$eventsFile" ]; then
+  tmpEvents=$(mktemp /tmp/backup-events-XXXXXX.jsonl)
+  grep "\"org\":\"${org_name}\"" "$eventsFile" | tail -500 > "$tmpEvents" || true
+  filesToBackup="$filesToBackup $tmpEvents"
+fi
+
+# Create archive
+tar -czf "$archivePath" $filesToBackup 2>/dev/null
+[ -n "$tmpEvents" ] && rm -f "$tmpEvents"
+
+if [ -f "$archivePath" ]; then
+  sizeKb=$(du -k "$archivePath" | awk '{print $1}')
+  echo "Backup created: $archivePath (${sizeKb}KB)"
+  echo "Files included: $(echo $filesToBackup | wc -w | tr -d ' ')"
+else
+  echo "ERROR: Failed to create backup archive."
+  exit 1
+fi
+```
+
+Emit `org:backup:created` event:
+
+```bash
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn --arg org "$org_name" --arg file "$archiveName" \
+    '{type:"org:backup:created",org:$org,file:$file,ts:(now*1000|floor)}')" || true
+```
+
+### list
+
+Show all available backups:
+
+```bash
+echo "BACKUPS — ${backup_dir:-.monomind/backups}"
+echo "──────────────────────────────────────────────"
+printf "%-45s %-12s %s\n" "FILE" "SIZE" "ORG"
+echo "──────────────────────────────────────────────"
+
+found=0
+for f in "${backupDir}"/*.tar.gz; do
+  [ -f "$f" ] || continue
+  name=$(basename "$f")
+  sizeKb=$(du -k "$f" | awk '{print $1}')
+  orgPart=$(echo "$name" | sed 's/-[0-9]\{8\}-[0-9]\{6\}\.tar\.gz$//')
+  if [ -z "$org_name" ] || [ "$orgPart" = "$org_name" ]; then
+    printf "%-45s %-12s %s\n" "$name" "${sizeKb}KB" "$orgPart"
+    found=$((found + 1))
+  fi
+done
+
+[ "$found" -eq 0 ] && echo "  No backups found."
+echo ""
+echo "Total: $found backup(s)"
+```
+
+### restore
+
+Restore org data from a backup archive:
+
+```bash
+# Auto-select latest backup if not specified
+if [ -z "$backup_file" ]; then
+  if [ -n "$org_name" ]; then
+    backup_file=$(ls "${backupDir}/${org_name}-"*.tar.gz 2>/dev/null | sort | tail -1)
+  fi
+  [ -z "$backup_file" ] && { echo "ERROR: No backup file found. Pass --backup-file <path>."; exit 1; }
+fi
+
+[ ! -f "$backup_file" ] && { echo "ERROR: Backup file not found: $backup_file"; exit 1; }
+
+echo "Restoring from: $backup_file"
+echo "This will overwrite existing org data. Confirm? (skipped in auto mode)"
+
+# Extract to a temp dir first, then copy
+tmpDir=$(mktemp -d /tmp/mastermind-restore-XXXXXX)
+tar -xzf "$backup_file" -C "$tmpDir" 2>/dev/null
+
+# Move restored files to correct locations
+find "$tmpDir" -name "*.json" | while read -r f; do
+  dest=$(echo "$f" | sed "s|$tmpDir||")
+  destDir=$(dirname "$dest")
+  mkdir -p "$destDir" 2>/dev/null || true
+  cp "$f" "$dest" && echo "  Restored: $dest"
+done
+
+# Handle events file
+find "$tmpDir" -name "*.jsonl" | while read -r f; do
+  dest=$(echo "$f" | sed "s|$tmpDir||")
+  mkdir -p "$(dirname "$dest")" 2>/dev/null || true
+  cat "$f" >> "$dest" && echo "  Appended events from backup"
+done
+
+rm -rf "$tmpDir"
+echo "Restore complete."
+```
+
+### delete
+
+Remove a specific backup archive:
+
+```bash
+[ -z "$backup_file" ] && { echo "ERROR: --backup-file required for delete."; exit 1; }
+[ ! -f "$backup_file" ] && { echo "ERROR: File not found: $backup_file"; exit 1; }
+rm "$backup_file"
+echo "Deleted: $backup_file"
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org: <org_name>
+backup_file: <path if created>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/.claude/skills/mastermind/bootstrap.md

@@ -0,0 +1,190 @@
+---
+name: mastermind-bootstrap
+description: Mastermind bootstrap — one-time org initialization that primes the CEO/boss agent with org context, goal hierarchy, and a signed invite token. Run after createorg before first runorg.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Bootstrap
+
+This skill is invoked by `mastermind:bootstrap` or directly via `/mastermind:bootstrap`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `org_name`: org to bootstrap (required)
+- `action`: init | token | status | reset
+- `boss_role_id`: role ID of the CEO/boss agent (default: auto-detect by `reports_to: null`)
+- `caller`: command | master
+
+---
+
+## Step 0 — Brain Load (standalone only)
+
+If `caller` is not "command", load brain context following _protocol.md Brain Load Procedure with namespace: `ops`.
+
+---
+
+## Step 1 — Resolve Org
+
+```bash
+orgFile=".monomind/orgs/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found. Run /mastermind:createorg first."; exit 1; }
+
+bootstrapFile=".monomind/orgs/${org_name}-bootstrap.json"
+```
+
+---
+
+## Step 2 — Execute Action
+
+### status (check bootstrap state)
+
+```bash
+if [ -f "$bootstrapFile" ]; then
+  echo "BOOTSTRAP STATUS — ${org_name}"
+  echo "──────────────────────────────────"
+  jq -r '
+    "  State:       \(.state // "unknown")",
+    "  Boss Role:   \(.boss_role_id // "-")",
+    "  Bootstrapped:\(.bootstrapped_at // "never")",
+    "  Token:       \(if .invite_token then (.invite_token | .[0:8]) + "..." else "none" end)",
+    "  Token used:  \(.token_used // false)"
+  ' "$bootstrapFile"
+else
+  echo "Not bootstrapped. Run /mastermind:bootstrap --org ${org_name} --action init"
+fi
+```
+
+### token (generate a fresh invite token)
+
+Generate a signed one-time token the boss agent uses to authenticate its first session:
+
+```bash
+token=$(openssl rand -hex 24 2>/dev/null || python3 -c "import secrets; print(secrets.token_hex(24))")
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+echo "INVITE TOKEN — ${org_name}"
+echo "──────────────────────────────────"
+echo "  Token: $token"
+echo "  Valid until first use."
+echo ""
+
+# Store token in bootstrap file
+[ ! -f "$bootstrapFile" ] && echo '{}' > "$bootstrapFile"
+tmp="${bootstrapFile}.tmp"
+jq --arg token "$token" --arg ts "$ts" \
+  '.invite_token = $token | .token_generated_at = $ts | .token_used = false' \
+  "$bootstrapFile" > "$tmp" && mv "$tmp" "$bootstrapFile"
+echo "Token stored. Include in boss agent prompt as: INVITE_TOKEN=${token}"
+```
+
+### init (full bootstrap)
+
+Initialize org bootstrap: detect boss, generate token, write primer context:
+
+```bash
+# Auto-detect boss (role with no reports_to or reports_to: null)
+if [ -z "$boss_role_id" ]; then
+  boss_role_id=$(jq -r '.roles[] | select(.reports_to == null or .reports_to == "") | .id' "$orgFile" | head -1)
+fi
+[ -z "$boss_role_id" ] && { echo "ERROR: Could not detect boss role. Pass --boss-role-id <id>."; exit 1; }
+
+bossConfig=$(jq --arg id "$boss_role_id" '.roles[] | select(.id == $id)' "$orgFile")
+bossTitle=$(echo "$bossConfig" | jq -r '.title // "CEO"')
+orgGoal=$(jq -r '.goal // "No goal set"' "$orgFile")
+orgTopology=$(jq -r '.topology // "hierarchical"' "$orgFile")
+roleCount=$(jq '.roles | length' "$orgFile")
+governance=$(jq -r '.governance.policy // "auto"' "$orgFile")
+
+# Generate invite token
+token=$(openssl rand -hex 24 2>/dev/null || python3 -c "import secrets; print(secrets.token_hex(24))")
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+# Write bootstrap record
+cat > "$bootstrapFile" <<EOF
+{
+  "org": "${org_name}",
+  "state": "initialized",
+  "boss_role_id": "${boss_role_id}",
+  "boss_title": "${bossTitle}",
+  "org_goal": "${orgGoal}",
+  "topology": "${orgTopology}",
+  "role_count": ${roleCount},
+  "governance": "${governance}",
+  "invite_token": "${token}",
+  "token_used": false,
+  "token_generated_at": "${ts}",
+  "bootstrapped_at": "${ts}"
+}
+EOF
+
+echo "BOOTSTRAP COMPLETE — ${org_name}"
+echo "──────────────────────────────────────────"
+echo "  Boss:       ${bossTitle} (${boss_role_id})"
+echo "  Goal:       ${orgGoal}"
+echo "  Topology:   ${orgTopology}"
+echo "  Agents:     ${roleCount}"
+echo "  Governance: ${governance}"
+echo "  Token:      ${token}"
+echo ""
+echo "CEO PRIMER (include in boss agent prompt):"
+echo "──────────────────────────────────────────"
+cat <<PRIMER
+ORG: ${org_name}
+ROLE: ${bossTitle}
+GOAL: ${orgGoal}
+GOVERNANCE: ${governance}
+INVITE_TOKEN: ${token}
+
+You are the autonomous CEO of org '${org_name}'. Your mission: ${orgGoal}.
+You lead ${roleCount} agents in a ${orgTopology} topology.
+Governance mode: ${governance}. In 'board' or 'strict' mode, pause before high-risk actions and emit approval requests.
+Use your INVITE_TOKEN for your first heartbeat. Token is single-use.
+PRIMER
+```
+
+Emit `org:bootstrap:complete` event:
+
+```bash
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn --arg org "$org_name" --arg boss "$boss_role_id" \
+    '{type:"org:bootstrap:complete",org:$org,boss:$boss,ts:(now*1000|floor)}')" || true
+```
+
+### reset
+
+Clear bootstrap state (next init will regenerate token):
+
+```bash
+if [ -f "$bootstrapFile" ]; then
+  rm "$bootstrapFile"
+  echo "Bootstrap state cleared for '${org_name}'. Run --action init to re-bootstrap."
+else
+  echo "No bootstrap file found for '${org_name}'."
+fi
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org: <org_name>
+boss_role_id: <boss_role_id>
+state: initialized | token | reset
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.