@monoes/monomindcli 2.9.7 → 2.9.8

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

@@ -1,256 +0,0 @@
----
-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 mastermind-protocol/SKILL.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 -vE -- '-approvals|-state|-activity|-goals|-routines|-projects|-members|-issues|-workspaces|-worktrees|-environments|-plugins|-adapters|-bootstrap|-threads|-budgets|-project-workspaces|-approval-comments' | 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 state members issues goals projects routines approvals adapters plugins environments workspaces worktrees activity threads budgets project-workspaces approval-comments bootstrap secrets; 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 state members issues goals projects routines approvals adapters plugins environments workspaces worktrees activity threads budgets project-workspaces approval-comments bootstrap secrets; 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 mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.

package/.claude/skills/mastermind-content/SKILL.md

@@ -1,197 +0,0 @@
----
-name: mastermind-content
-description: Mastermind content domain — blog posts, threads, docs, newsletters. Spawns a Content Manager who runs a ring pipeline (research→draft→edit→publish) for polished output.
-type: domain-skill
-default_mode: confirm
----
-
-# Mastermind Content Domain
-
-This skill is invoked by `mastermind:master` or directly via `/mastermind:content`.
-
----
-
-## Inputs
-
-- `brain_context`: BRAIN CONTEXT block (injected by master, or loaded standalone via mastermind-protocol/SKILL.md brain load)
-- `prompt`: the content goal for this run
-- `project_name`: monotask space name
-- `board_id`: monotask board ID (set by master, or created standalone)
-- `mode`: auto | confirm
-
----
-
-## Reference Library
-
-Before generating or editing any prose, identify which reference files apply and inject them into the agent briefing.
-
-| Reference | When to include |
-|---|---|
-| `.claude/skills/stop-slop/SKILL.md` | Stage 3 (Edit) and Stage 4 (Review) — not Draft |
-| `.claude/skills/stop-slop/references/phrases.md` | Full edit pass — check for banned phrases |
-| `.claude/skills/stop-slop/references/structures.md` | Full edit pass — check structural patterns |
-| `.claude/skills/stop-slop/references/examples.md` | When the agent needs before/after context |
-
-In each Edit/Review stage briefing (Stage 3), add:
-```
-REFERENCE FILES: Read these before editing:
-- .claude/skills/stop-slop/SKILL.md
-- .claude/skills/stop-slop/references/phrases.md
-- .claude/skills/stop-slop/references/structures.md
-```
-
----
-
-## Complexity Assessment
-
-Assess the prompt to determine execution mode:
-
-**Simple (direct execution):** Single short piece, one agent:
-- "Write a one-paragraph product description"
-- "Draft a 280-character tweet about the release"
-→ Use a single Content Creator agent. Skip manager delegation.
-
-**Complex (spawn Content Manager agent):** Any of these:
-- Blog post or article (research + draft + edit)
-- Newsletter issue requiring multiple sections
-- Documentation rewrite or new doc set
-- Thread series across multiple posts
-- Content requiring subject matter research before writing
-→ Spawn Content Manager agent with ring pipeline.
-
----
-
-## Standalone Execution (when called without master)
-
-If this skill is invoked directly (not by master):
-
-1. Load brain context following mastermind-protocol/SKILL.md Brain Load Procedure (namespace: `content`)
-2. Run intake from mastermind-intake/SKILL.md if prompt is vague
-3. Follow mastermind-protocol/SKILL.md Monotask Space+Board Setup Procedure:
-   ```bash
-   project_name="${project_name:-$(basename "$PWD")}"
-   space_id=$(monotask space list 2>/dev/null | awk -F' \| ' -v n="$project_name" '$2==n{print $1}' | head -1)
-   [ -z "$space_id" ] && space_id=$(monotask space create "$project_name" 2>&1 | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
-   [ -z "$space_id" ] && { echo "ERROR: Could not find or create space '$project_name'"; exit 1; }
-   board_id=$(monotask board create "content" --json | jq -r '.id // empty')
-   [ -z "$board_id" ] && { echo "ERROR: Failed to create content board"; exit 1; }
-   monotask space boards add "$space_id" "$board_id" >/dev/null 2>&1 || true
-   todo_col=$(monotask column create "$board_id" "Todo"  --json | jq -r '.id')
-   doing_col=$(monotask column create "$board_id" "Doing" --json | jq -r '.id')
-   done_col=$(monotask column create "$board_id" "Done"  --json | jq -r '.id')
-   ```
-4. Proceed with complexity assessment below
-5. At end: follow mastermind-protocol/SKILL.md Brain Write Procedure (namespace: `content`)
-
----
-
-## Complex Execution — Content Manager Agent
-
-Spawn a Content Manager agent via Task tool:
-
-```javascript
-Task({
-  subagent_type: "coordinator",
-  description: `You are the Content Manager for project <project_name>.
-
-CONTEXT: <date> | Project: <project_name> | Spawned by: mastermind:content
-
-BRAIN CONTEXT:
-<brain_context>
-
-YOUR BOARD: <board_id>
-YOUR GOAL: <prompt>
-
-STEP 1 — PLAN
-Decompose content production into sequential pipeline stages. The ring topology means output from each stage feeds the next:
-Stage 1: Research — gather facts, sources, angles
-Stage 2: Draft — produce first draft from research
-Stage 3: Edit — refine, fact-check, tone-align
-Stage 4: Format — structure for target platform
-
-Identify for each stage:
-- What input it receives from the prior stage
-- What deliverable it produces
-- Which specialist handles it
-
-STEP 2 — CREATE TASKS
-For each pipeline stage, create a monotask card on the project board.
-First look up column IDs and assign shell variables:
-```bash
-columns=$(monotask column list "$BOARD_ID" --json)
-COL_TODO_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Todo" or .title == "Backlog") | .id' | head -1)
-COL_DONE_ID=$(echo "$columns" | jq -r '.[] | select(.title == "Done") | .id' | head -1)
-```
-Then create the card:
-```bash
-result=$(monotask card create "$BOARD_ID" "$COL_TODO_ID" "<short summary of pipeline stage goal, ≤80 chars>" --json)
-CARD_ID=$(echo "$result" | jq -r '.id // empty')
-monotask card set-description "$BOARD_ID" "$CARD_ID" "[this stage's specific production goal]"
-monotask card comment add "$BOARD_ID" "$CARD_ID" "CONTEXT: <date> | Project: <project_name> | Created by: Content Manager
-BRAIN MEMORY: [paste most relevant 3-5 brain context excerpts]
-SCOPE: [content type, target audience, platform, word count, tone]
-CONSTRAINTS: [brand voice, SEO requirements, factual accuracy standards, style guide]
-REFERENCE FILES: [for Stage 3 edit only: .claude/skills/stop-slop/SKILL.md, .claude/skills/stop-slop/references/phrases.md, .claude/skills/stop-slop/references/structures.md]
-SUCCESS CRITERIA:
-- [ ] [checkable item]
-AGENT: [researcher | Content Creator | Technical Writer | Code Reviewer (as editor)]
-SWARM: ring 4 raft pipeline
-DEPENDENCIES: [prior stage task ID — pipeline is sequential]
-OUTPUT FORMAT: unified output schema"
-```
-
-STEP 3 — EXECUTE
-Spawn Task agents in pipeline order (ring topology — each must complete before next starts):
-Stage 1 research: subagent_type "researcher"
-Stage 2 draft: subagent_type "Content Creator"
-Stage 3 edit: subagent_type "Technical Writer"
-Stage 4 format/publish: subagent_type "Content Creator"
-
-Also run /mastermind:do --board <board_id> to track execution.
-
-STEP 4 — COLLECT AND RETURN
-Collect the final formatted content. Return to caller:
-
-domain: content
-status: complete | partial | blocked
-artifacts:
-  - path: [path to final content file]
-    type: copy
-decisions:
-  - what: [angle, tone, or structure decisions made]
-    why: [reasoning]
-    confidence: [0.0-1.0]
-    outcome: shipped | pending
-lessons:
-  - what_worked: [what produced the strongest draft]
-  - what_didnt: [what required multiple iterations]
-next_actions:
-  - [e.g. "run mastermind:marketing to distribute the content"]
-  - [e.g. "run mastermind:review for final quality check"]
-board_url: monotask://<project_name>/content
-run_id: <ISO8601-timestamp>`,
-  run_in_background: true
-})
-```
-
----
-
-## Simple Execution
-
-For simple tasks (single agent, short-form content):
-
-1. Spawn one Task agent with the content request as a self-contained briefing
-2. Collect output
-3. Return unified output schema with `status: complete`
-
----
-
-## Domain Swarm Defaults
-
-| Task Type | Agent | Swarm |
-|---|---|---|
-| Full article / blog post | researcher → writer → editor | ring 4 raft pipeline |
-| Newsletter | coordinator + writers | ring 4 raft pipeline |
-| Documentation rewrite | Technical Writer + researcher | ring 4 raft pipeline |
-| Social thread | Content Creator | hierarchical 3 raft specialized |
-| Short-form copy | Content Creator | single agent |

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

@@ -1,151 +0,0 @@
----
-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 mastermind-protocol/SKILL.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 "x-monomind-token: $(cat "${REPO_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}/.monomind/dashboard-token" 2>/dev/null || true)" \
-      -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 mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.