@monoes/monomindcli 1.9.17 → 1.10.0

package/.claude/skills/mastermind/budgets.md

@@ -0,0 +1,237 @@
+---
+name: mastermind-budgets
+description: Mastermind budgets — view, set, and track token/cost budgets for agents and the entire org. Shows current spend vs. limits, alerts on overages, and lets board members adjust per-agent or org-wide budgets. Reads from -budgets.json org state files.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Budgets
+
+This skill is invoked by `mastermind:budgets` or directly via `/mastermind:budgets`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `org_name`: org to manage budgets for (required)
+- `action`: show | set | reset | alert
+- `agent_id`: scope to a specific agent (optional — omit for org-wide)
+- `limit_tokens`: token limit to set (for set)
+- `limit_usd`: USD cost limit to set (for set)
+- `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 Org and Budget File
+
+```bash
+orgFile=".monomind/orgs/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
+
+budgetsFile=".monomind/orgs/${org_name}-budgets.json"
+stateFile=".monomind/orgs/${org_name}-state.json"
+
+if [ ! -f "$budgetsFile" ]; then
+  echo '{"org_budget":{},"agent_budgets":{},"period":"monthly","currency":"USD"}' > "$budgetsFile"
+fi
+```
+
+---
+
+## Step 2 — Execute Action
+
+### show (default)
+
+```bash
+echo "BUDGETS — $org_name"
+echo "════════════════════════════════════════════════════════"
+
+python3 - "$orgFile" "$budgetsFile" "$stateFile" "${agent_id:-}" <<'PYEOF'
+import json, sys, os
+
+orgData    = json.load(open(sys.argv[1]))
+budgetData = json.load(open(sys.argv[2]))
+statePath  = sys.argv[3]
+agentFilter= sys.argv[4]
+
+# Load heartbeat state for per-agent token usage
+agentTokens = {}
+if os.path.exists(statePath):
+    try:
+        state = json.load(open(statePath))
+        for r in state.get("roles", []):
+            rid = r.get("id","")
+            agentTokens[rid] = {
+                "tokensIn":  r.get("tokens_in", 0),
+                "tokensOut": r.get("tokens_out", 0),
+                "totalCostUsd": r.get("total_cost_usd", 0.0),
+            }
+    except: pass
+
+orgBudget   = budgetData.get("org_budget", {})
+agentBudgets= budgetData.get("agent_budgets", {})
+period      = budgetData.get("period", "monthly")
+
+print(f"  Period: {period}")
+print()
+
+# Org-wide budget
+orgLimitTokens = orgBudget.get("limit_tokens")
+orgLimitUsd    = orgBudget.get("limit_usd")
+orgSpentTokens = sum(v.get("tokensIn",0) + v.get("tokensOut",0) for v in agentTokens.values())
+orgSpentUsd    = sum(v.get("totalCostUsd",0) for v in agentTokens.values())
+
+print("ORG BUDGET")
+print("────────────────────────────────────────────────────────")
+print(f"  Tokens spent:  {orgSpentTokens:>12,}")
+if orgLimitTokens:
+    pct = orgSpentTokens / orgLimitTokens * 100
+    bar = "█" * int(pct / 5) + "░" * (20 - int(pct / 5))
+    print(f"  Token limit:   {orgLimitTokens:>12,}  [{bar}] {pct:.1f}%")
+print(f"  Cost (USD):    ${orgSpentUsd:>11.4f}")
+if orgLimitUsd:
+    pct = orgSpentUsd / orgLimitUsd * 100
+    bar = "█" * int(pct / 5) + "░" * (20 - int(pct / 5))
+    print(f"  Cost limit:    ${orgLimitUsd:>11.2f}    [{bar}] {pct:.1f}%")
+print()
+
+# Per-agent budgets
+roles = orgData.get("roles", [])
+if agentFilter:
+    roles = [r for r in roles if r.get("id") == agentFilter]
+
+print("AGENT BUDGETS")
+print("────────────────────────────────────────────────────────")
+print(f"  {'AGENT':<28} {'TOKENS IN':<12} {'TOKENS OUT':<12} {'COST USD':<12} {'LIMIT USD'}")
+print("  " + "─" * 82)
+
+for role in roles:
+    rid   = role.get("id","?")
+    title = role.get("title", rid)[:26]
+    tok   = agentTokens.get(rid, {})
+    tIn   = tok.get("tokensIn", 0)
+    tOut  = tok.get("tokensOut", 0)
+    cost  = tok.get("totalCostUsd", 0.0)
+    lim   = agentBudgets.get(rid, {}).get("limit_usd")
+    limStr= f"${lim:.2f}" if lim else "—"
+
+    overBudget = lim and cost > lim
+    flag = " ⚠ OVER" if overBudget else ""
+    print(f"  {title:<28} {tIn:<12,} {tOut:<12,} ${cost:<11.4f} {limStr}{flag}")
+
+if not roles:
+    print("  (no agents)")
+PYEOF
+
+echo ""
+echo "  Set limit: /mastermind:budgets --org $org_name --action set --agent-id <id> --limit-usd 5.00"
+echo "  Reset:     /mastermind:budgets --org $org_name --action reset"
+```
+
+### set
+
+```bash
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+python3 - "$budgetsFile" "${agent_id:-}" "${limit_tokens:-}" "${limit_usd:-}" "$ts" <<'PYEOF'
+import json, sys
+
+path, agentId, limitTok, limitUsd, ts = sys.argv[1:]
+
+data = json.load(open(path))
+
+if agentId:
+    entry = data.setdefault("agent_budgets", {}).setdefault(agentId, {})
+    if limitTok: entry["limit_tokens"] = int(limitTok)
+    if limitUsd:  entry["limit_usd"] = float(limitUsd)
+    entry["updatedAt"] = ts
+    print(f"  Budget set for agent '{agentId}':")
+    if limitTok: print(f"    Token limit: {int(limitTok):,}")
+    if limitUsd:  print(f"    USD limit:   ${float(limitUsd):.2f}")
+else:
+    org = data.setdefault("org_budget", {})
+    if limitTok: org["limit_tokens"] = int(limitTok)
+    if limitUsd:  org["limit_usd"] = float(limitUsd)
+    org["updatedAt"] = ts
+    print(f"  Org-wide budget updated:")
+    if limitTok: print(f"    Token limit: {int(limitTok):,}")
+    if limitUsd:  print(f"    USD limit:   ${float(limitUsd):.2f}")
+
+with open(path, "w") as f:
+    json.dump(data, f, indent=2)
+PYEOF
+```
+
+### reset
+
+```bash
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+echo '{"org_budget":{},"agent_budgets":{},"period":"monthly","currency":"USD","resetAt":"'"$ts"'"}' > "$budgetsFile"
+echo "  Budget counters reset for '$org_name'  ($ts)"
+echo "  Note: resets limit configs too. Re-run --action set to restore limits."
+```
+
+### alert
+
+Check for agents over their budget limits:
+
+```bash
+echo "BUDGET ALERTS — $org_name"
+echo "────────────────────────────────────────────────────────"
+
+python3 - "$orgFile" "$budgetsFile" "$stateFile" <<'PYEOF'
+import json, sys, os
+
+orgData    = json.load(open(sys.argv[1]))
+budgetData = json.load(open(sys.argv[2]))
+statePath  = sys.argv[3]
+
+agentTokens = {}
+if os.path.exists(statePath):
+    try:
+        state = json.load(open(statePath))
+        for r in state.get("roles", []):
+            rid = r.get("id","")
+            agentTokens[rid] = r.get("total_cost_usd", 0.0)
+    except: pass
+
+agentBudgets = budgetData.get("agent_budgets", {})
+alerts = []
+for rid, ab in agentBudgets.items():
+    lim = ab.get("limit_usd")
+    spent = agentTokens.get(rid, 0.0)
+    if lim and spent > lim:
+        alerts.append((rid, spent, lim))
+
+if not alerts:
+    print("  ✓ All agents within budget.")
+else:
+    print(f"  ⚠ {len(alerts)} agent(s) over budget:")
+    for rid, spent, lim in alerts:
+        print(f"    {rid}: spent ${spent:.4f} / limit ${lim:.2f}")
+PYEOF
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org_name: <org_name>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/.claude/skills/mastermind/companies.md

@@ -0,0 +1,256 @@
+---
+name: mastermind-companies
+description: Mastermind companies — multi-org management. List all orgs with agent/issue stats, switch the active org, rename an org, delete an org (with confirmation), and view per-org summary. Mirrors Companies.tsx.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Companies
+
+This skill is invoked by `mastermind:companies` or directly via `/mastermind:companies`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `action`: list | select | rename | delete | stats | create
+- `org_name`: org name to target (required for select/rename/delete/stats)
+- `new_name`: new org name (required for rename)
+- `confirm`: yes (required second step for delete)
+- `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 — Locate All Orgs
+
+```bash
+orgsDir=".monomind/orgs"
+[ ! -d "$orgsDir" ] && { echo "No orgs directory found. Run /mastermind:createorg to create your first org."; exit 0; }
+
+# Collect all org names from .json files (not -members, -issues, etc.)
+orgNames=$(ls "$orgsDir"/*.json 2>/dev/null | grep -v '\-' | xargs -I{} basename {} .json | sort)
+
+# Track active org
+activeFile=".monomind/active-org"
+activeOrg=$([ -f "$activeFile" ] && cat "$activeFile" || echo "")
+```
+
+---
+
+## Step 2 — Execute Action
+
+### list (default)
+
+```bash
+echo "ORGS"
+echo "────────────────────────────────────────────────────────"
+printf "%-22s %-8s %-8s %-8s %s\n" "NAME" "AGENTS" "ISSUES" "MEMBERS" "STATUS"
+echo "────────────────────────────────────────────────────────"
+
+[ -z "$orgNames" ] && { echo "  No orgs found. Create one: /mastermind:createorg"; exit 0; }
+
+echo "$orgNames" | while read -r name; do
+  orgFile="$orgsDir/${name}.json"
+  [ ! -f "$orgFile" ] && continue
+
+  agents=$(jq -r '(.roles // []) | length' "$orgFile" 2>/dev/null || echo 0)
+  issues=$([ -f "$orgsDir/${name}-issues.json" ] && jq '[.issues[] | select(.status == "open" or .status == "in_progress")] | length' "$orgsDir/${name}-issues.json" 2>/dev/null || echo 0)
+  members=$([ -f "$orgsDir/${name}-members.json" ] && jq '.members | length' "$orgsDir/${name}-members.json" 2>/dev/null || echo 0)
+  status=$([ "$name" = "$activeOrg" ] && echo "● ACTIVE" || echo "")
+
+  printf "%-22s %-8s %-8s %-8s %s\n" "$name" "$agents" "$issues" "$members" "$status"
+done
+
+echo ""
+total=$(echo "$orgNames" | wc -w | tr -d ' ')
+echo "  Total orgs: $total"
+[ -n "$activeOrg" ] && echo "  Active org: $activeOrg"
+echo ""
+echo "  Select:  --action select --org-name <name>"
+echo "  Rename:  --action rename --org-name <name> --new-name <new>"
+echo "  Delete:  --action delete --org-name <name>"
+```
+
+### select
+
+```bash
+[ -z "$org_name" ] && { echo "ERROR: --org-name required."; exit 1; }
+
+orgFile="$orgsDir/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '$org_name' not found."; exit 1; }
+
+echo "$org_name" > "$activeFile"
+echo "Active org set to: $org_name"
+echo "  All mastermind commands will default to this org."
+echo "  To use a different org, pass --org-name explicitly."
+```
+
+### rename
+
+```bash
+[ -z "$org_name" ] && { echo "ERROR: --org-name required."; exit 1; }
+[ -z "$new_name" ] && { echo "ERROR: --new-name required."; exit 1; }
+
+# Validate new name
+echo "$new_name" | grep -qE '^[a-z0-9][a-z0-9_-]*$' || {
+  echo "ERROR: --new-name must be lowercase alphanumeric with hyphens/underscores (e.g. my-org)."
+  exit 1
+}
+
+orgFile="$orgsDir/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '$org_name' not found."; exit 1; }
+
+[ -f "$orgsDir/${new_name}.json" ] && { echo "ERROR: Org '$new_name' already exists."; exit 1; }
+
+# Rename main config file
+mv "$orgFile" "$orgsDir/${new_name}.json"
+
+# Rename all associated files
+for suffix in members issues goals projects routines approvals adapters plugins environments workspaces activity threads budgets; do
+  f="$orgsDir/${org_name}-${suffix}.json"
+  [ -f "$f" ] && mv "$f" "$orgsDir/${new_name}-${suffix}.json"
+  f2="$orgsDir/${org_name}-${suffix}.jsonl"
+  [ -f "$f2" ] && mv "$f2" "$orgsDir/${new_name}-${suffix}.jsonl"
+done
+
+# Update name field inside config
+tmp="$orgsDir/${new_name}.json.tmp"
+jq --arg n "$new_name" '.name = $n' "$orgsDir/${new_name}.json" > "$tmp" && mv "$tmp" "$orgsDir/${new_name}.json"
+
+# Update active org pointer if needed
+[ "$(cat "$activeFile" 2>/dev/null)" = "$org_name" ] && echo "$new_name" > "$activeFile"
+
+echo "Org renamed: $org_name → $new_name"
+```
+
+### delete
+
+```bash
+[ -z "$org_name" ] && { echo "ERROR: --org-name required."; exit 1; }
+
+orgFile="$orgsDir/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '$org_name' not found."; exit 1; }
+
+if [ "${confirm:-}" != "yes" ]; then
+  agentCount=$(jq '(.roles // []) | length' "$orgFile" 2>/dev/null || echo "?")
+  echo "DELETE CONFIRMATION REQUIRED"
+  echo "────────────────────────────────────────────────────────"
+  echo "  Org:    $org_name"
+  echo "  Agents: $agentCount"
+  echo ""
+  echo "  This will permanently delete the org and ALL associated data."
+  echo "  To confirm: --action delete --org-name $org_name --confirm yes"
+  exit 0
+fi
+
+# Delete all org files
+rm -f "$orgsDir/${org_name}.json"
+for suffix in members issues goals projects routines approvals adapters plugins environments workspaces activity threads budgets project-workspaces approval-comments; do
+  rm -f "$orgsDir/${org_name}-${suffix}.json"
+  rm -f "$orgsDir/${org_name}-${suffix}.jsonl"
+done
+
+# Clear active org if it was this org
+[ "$(cat "$activeFile" 2>/dev/null)" = "$org_name" ] && rm -f "$activeFile"
+
+echo "Org '$org_name' deleted permanently."
+echo "  All associated data removed."
+```
+
+### stats
+
+```bash
+[ -z "$org_name" ] && { echo "ERROR: --org-name required."; exit 1; }
+
+orgFile="$orgsDir/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '$org_name' not found."; exit 1; }
+
+echo "ORG STATS — $org_name"
+echo "────────────────────────────────────────────────────────"
+
+# Agent stats
+agents=$(jq '(.roles // []) | length' "$orgFile")
+gov=$(jq -r '.governance // "(not set)"' "$orgFile")
+echo "  Agents:        $agents"
+echo "  Governance:    $gov"
+
+# Issues
+if [ -f "$orgsDir/${org_name}-issues.json" ]; then
+  total=$(jq '.issues | length' "$orgsDir/${org_name}-issues.json")
+  open=$(jq '[.issues[] | select(.status == "open" or .status == "in_progress")] | length' "$orgsDir/${org_name}-issues.json")
+  done=$(jq '[.issues[] | select(.status == "done")] | length' "$orgsDir/${org_name}-issues.json")
+  echo "  Issues:        $total total  ($open open, $done done)"
+fi
+
+# Goals
+[ -f "$orgsDir/${org_name}-goals.json" ] && echo "  Goals:         $(jq '.goals | length' "$orgsDir/${org_name}-goals.json")"
+
+# Projects
+[ -f "$orgsDir/${org_name}-projects.json" ] && echo "  Projects:      $(jq '.projects | length' "$orgsDir/${org_name}-projects.json")"
+
+# Members
+[ -f "$orgsDir/${org_name}-members.json" ] && echo "  Members:       $(jq '.members | length' "$orgsDir/${org_name}-members.json")"
+
+# Routines
+[ -f "$orgsDir/${org_name}-routines.json" ] && echo "  Routines:      $(jq '.routines | length' "$orgsDir/${org_name}-routines.json")"
+
+# Pending approvals
+if [ -f "$orgsDir/${org_name}-approvals.json" ]; then
+  pending=$(jq '[.approvals[] | select(.status == "pending")] | length' "$orgsDir/${org_name}-approvals.json")
+  echo "  Pending approvals: $pending"
+fi
+```
+
+### create
+
+```bash
+[ -z "$org_name" ] && { echo "ERROR: --org-name required."; exit 1; }
+
+echo "$org_name" | grep -qE '^[a-z0-9][a-z0-9_-]*$' || {
+  echo "ERROR: --org-name must be lowercase alphanumeric with hyphens/underscores."
+  exit 1
+}
+
+orgFile="$orgsDir/${org_name}.json"
+[ -f "$orgFile" ] && { echo "ERROR: Org '$org_name' already exists."; exit 1; }
+
+mkdir -p "$orgsDir"
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+cat > "$orgFile" <<EOF
+{
+  "name": "$org_name",
+  "governance": "auto",
+  "roles": [],
+  "created_at": "$ts"
+}
+EOF
+
+echo "Org '$org_name' created."
+echo "  Add agents: /mastermind:new-agent --org $org_name --title 'My Agent'"
+echo "  Run:        /mastermind:runorg --org $org_name"
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org_name: <org_name>
+active_org: <active_org>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/.claude/skills/mastermind/costs.md

@@ -0,0 +1,151 @@
+---
+name: mastermind-costs
+description: Mastermind costs — track token spend and budget burn rate per agent in a running org. Shows current window spend, budget policy, and alerts when approaching limits.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Costs
+
+This skill is invoked by `mastermind:costs` or directly via `/mastermind:costs`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block
+- `org_name`: org to inspect costs for
+- `action`: report | set-budget | alert
+- `budget_tokens`: max token budget for the org run (for set-budget)
+- `alert_threshold`: fraction of budget that triggers alert (default 0.8)
+- `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 Cost Data
+
+Cost data is pulled from monomind's token summary and the org state file:
+
+```bash
+orgFile=".monomind/orgs/${org_name}.json"
+stateFile=".monomind/orgs/${org_name}-state.json"
+tokenSummary=".monomind/metrics/token-summary.json"
+
+memNs="org:${org_name}"
+```
+
+---
+
+## Step 2 — Execute Action
+
+### report (default)
+
+Aggregate token usage per agent from state file and token summary:
+
+```bash
+# Get total token usage from the global summary for context
+if [ -f "$tokenSummary" ]; then
+  echo "=== GLOBAL TOKEN SUMMARY ==="
+  jq -r '"Today: $\(.today.cost | tostring)  calls: \(.today.calls)"' "$tokenSummary" 2>/dev/null || true
+fi
+
+echo ""
+echo "=== ORG SPEND — ${org_name} ==="
+
+# Per-agent spend from state file
+if [ -f "$stateFile" ]; then
+  jq -r '.agents // {} | to_entries[] | "  \(.key):  tokens_in=\(.value.tokens_in // 0)  tokens_out=\(.value.tokens_out // 0)  status=\(.value.status // "unknown")"' "$stateFile" 2>/dev/null
+else
+  echo "  (no state file — org has not run yet)"
+fi
+
+# Budget check
+budget=$(jq -r '.run_config.budget_tokens // "unlimited"' "$orgFile" 2>/dev/null)
+echo ""
+echo "Budget: $budget tokens"
+```
+
+Render as:
+```
+COSTS — org: <org_name>
+──────────────────────────────────────────────
+AGENT             STATUS    TOKENS IN    TOKENS OUT    EST. COST
+boss              running   48,230       12,100        ~$0.42
+content-writer    idle      21,400       8,900         ~$0.18
+reviewer          waiting   5,100        2,300         ~$0.05
+──────────────────────────────────────────────
+TOTAL                        74,730       23,300        ~$0.65
+BUDGET: 500,000 tokens  |  USED: 14.8%  |  REMAINING: 85.2%
+
+BURN RATE: ~4,900 tokens/hour  |  EST. RUNWAY: ~87 hours
+```
+
+Calculate costs using approximate rates: input ~$3/1M tokens, output ~$15/1M tokens (Sonnet-class).
+
+### set-budget
+
+Write budget to org config:
+
+```bash
+tmp="${orgFile}.tmp"
+jq --argjson budget "$budget_tokens" \
+   --argjson threshold "${alert_threshold:-0.8}" \
+   '.run_config.budget_tokens = $budget | .run_config.alert_threshold = $threshold' \
+   "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
+echo "Budget set: $budget_tokens tokens (alert at $(echo "$alert_threshold * 100" | bc)%)"
+```
+
+### alert
+
+Check current usage against budget and emit alert if over threshold:
+
+```bash
+budget=$(jq -r '.run_config.budget_tokens // 0' "$orgFile")
+threshold=$(jq -r '.run_config.alert_threshold // 0.8' "$orgFile")
+
+if [ "$budget" -gt 0 ] && [ -f "$stateFile" ]; then
+  total_in=$(jq '[.agents // {} | to_entries[] | .value.tokens_in // 0] | add // 0' "$stateFile")
+  total_out=$(jq '[.agents // {} | to_entries[] | .value.tokens_out // 0] | add // 0' "$stateFile")
+  total=$((total_in + total_out))
+  
+  # Use awk for float comparison
+  over=$(awk -v total="$total" -v budget="$budget" -v threshold="$threshold" \
+    'BEGIN { print (total/budget >= threshold) ? "yes" : "no" }')
+  
+  if [ "$over" = "yes" ]; then
+    echo "ALERT: Org $org_name has used $(awk -v t=$total -v b=$budget 'BEGIN{printf "%.1f", t/b*100}')% of budget"
+    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" --argjson total $total --argjson budget $budget \
+        '{type:"org:budget:alert",org:$org,tokens_used:$total,budget:$budget,ts:(now*1000|floor)}')" || true
+  fi
+fi
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org: <org_name>
+total_tokens: <N>
+budget_tokens: <N>
+usage_pct: <N>%
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.