monomind 1.19.0 → 2.0.1

package/.claude/skills/mastermind-skills/implementer-prompt.md

@@ -1,109 +0,0 @@
-# Implementer Subagent Prompt Template
-
-Use this template when dispatching an implementer subagent from `mastermind:taskdev`.
-
-```
-Task tool (general-purpose):
-  description: "Implement Task N: [task name]"
-  prompt: |
-    You are implementing Task N: [task name]
-
-    ## Task Description
-
-    [FULL TEXT of task from plan — paste it here, do not make the subagent read the file]
-
-    ## Context
-
-    [Scene-setting: where this fits, dependencies, architectural context, brain context summary]
-
-    ## Before You Begin
-
-    If you have questions about:
-    - The requirements or acceptance criteria
-    - The approach or implementation strategy
-    - Dependencies or assumptions
-    - Anything unclear in the task description
-
-    **Ask them now.** Raise any concerns before starting work.
-
-    ## Your Job
-
-    Once you're clear on requirements:
-    1. Implement exactly what the task specifies
-    2. Write tests following TDD (use Skill("mastermind-skills:tdd") if available)
-    3. Verify implementation works
-    4. Commit your work
-    5. Self-review (see below)
-    6. Report back
-
-    Work from: [directory]
-
-    **While you work:** If you encounter something unexpected or unclear, **ask questions**.
-    It's always OK to pause and clarify. Don't guess or make assumptions.
-
-    ## Code Organization
-
-    - Follow the file structure defined in the plan
-    - Each file should have one clear responsibility with a well-defined interface
-    - If a file you're creating is growing beyond the plan's intent, stop and report
-      it as DONE_WITH_CONCERNS — don't split files on your own without plan guidance
-    - If an existing file you're modifying is already large or tangled, work carefully
-      and note it as a concern in your report
-    - In existing codebases, follow established patterns. Improve code you're touching
-      the way a good developer would, but don't restructure things outside your task.
-
-    ## When You're in Over Your Head
-
-    It is always OK to stop and say "this is too hard for me." Bad work is worse than
-    no work. You will not be penalized for escalating.
-
-    **STOP and escalate when:**
-    - The task requires architectural decisions with multiple valid approaches
-    - You need to understand code beyond what was provided and can't find clarity
-    - You feel uncertain about whether your approach is correct
-    - The task involves restructuring existing code in ways the plan didn't anticipate
-    - You've been reading file after file trying to understand the system without progress
-
-    **How to escalate:** Report back with status BLOCKED or NEEDS_CONTEXT. Describe
-    specifically what you're stuck on, what you've tried, and what kind of help you need.
-
-    ## Before Reporting Back: Self-Review
-
-    Review your work with fresh eyes. Ask yourself:
-
-    **Completeness:**
-    - Did I fully implement everything in the spec?
-    - Did I miss any requirements?
-    - Are there edge cases I didn't handle?
-
-    **Quality:**
-    - Is this my best work?
-    - Are names clear and accurate?
-    - Is the code clean and maintainable?
-
-    **Discipline:**
-    - Did I avoid overbuilding (YAGNI)?
-    - Did I only build what was requested?
-    - Did I follow existing patterns in the codebase?
-
-    **Testing:**
-    - Do tests actually verify behavior (not just mock behavior)?
-    - Did I follow TDD if required?
-    - Are tests comprehensive?
-
-    If you find issues during self-review, fix them now before reporting.
-
-    ## Report Format
-
-    When done, report:
-    - **Status:** DONE | DONE_WITH_CONCERNS | BLOCKED | NEEDS_CONTEXT
-    - What you implemented (or what you attempted, if blocked)
-    - What you tested and test results
-    - Files changed
-    - Self-review findings (if any)
-    - Any issues or concerns
-
-    Use DONE_WITH_CONCERNS if you completed the work but have doubts about correctness.
-    Use BLOCKED if you cannot complete the task. Use NEEDS_CONTEXT if you need
-    information that wasn't provided. Never silently produce work you're unsure about.
-```

package/.claude/skills/mastermind-skills/import.md

@@ -1,281 +0,0 @@
----
-name: mastermind-import
-description: Mastermind import — import an org from a portable ZIP archive exported by mastermind:export. Previews the archive contents, shows agent plans (create/update/skip), lets you choose a collision strategy, and applies the import to the local .monomind/orgs/ directory. Mirrors CompanyImport.tsx.
-type: domain-skill
-default_mode: confirm
----
-
-# Mastermind Import
-
-This skill is invoked by `mastermind:import` or directly via `/mastermind:import`.
-
----
-
-## Inputs
-
-- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
-- `action`: preview | apply | list-archive
-- `archive_path`: absolute or relative path to the ZIP archive file (required)
-- `org_name`: override org name from archive (default: use name in archive)
-- `collision`: skip | merge | overwrite (what to do if org already exists; default: skip)
-- `adapter_override`: optional; adapter type to replace all agents' adapters (e.g. `claude-local`)
-- `caller`: command | master
-
----
-
-## Collision Strategy Reference
-
-| Strategy | Behavior |
-|----------|----------|
-| `skip` | If org already exists, abort. Safe default. |
-| `merge` | Merge: add agents/goals/etc from archive, skip duplicates by id. |
-| `overwrite` | Delete existing org files and replace with archive contents. |
-
----
-
-## 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 — Validate Archive
-
-```bash
-[ -z "$archive_path" ] && { echo "ERROR: --archive-path required (path to the exported .zip file)."; exit 1; }
-[ ! -f "$archive_path" ] && { echo "ERROR: Archive not found: $archive_path"; exit 1; }
-
-# Detect format
-case "$archive_path" in
-  *.zip) fmt="zip" ;;
-  *.tar.gz|*.tgz) fmt="tgz" ;;
-  *.json) fmt="json" ;;
-  *) echo "ERROR: Unsupported archive format. Expected .zip, .tar.gz, or .json"; exit 1 ;;
-esac
-
-echo "Archive: $archive_path  (format: $fmt)"
-```
-
----
-
-## Step 2 — Execute Action
-
-### list-archive
-
-List files in the archive without extracting:
-
-```bash
-if [ "$fmt" = "zip" ]; then
-  unzip -l "$archive_path" 2>/dev/null | grep -v "^Archive\|^--\|files$" | awk '{print $NF}' | grep -v "^$"
-elif [ "$fmt" = "tgz" ]; then
-  tar -tzf "$archive_path"
-elif [ "$fmt" = "json" ]; then
-  echo "(JSON format — single file, no archive listing needed)"
-fi
-```
-
-### preview
-
-Extract and preview the org configuration without writing:
-
-```bash
-tmpDir=$(mktemp -d /tmp/mastermind-import-XXXXXX)
-trap 'rm -rf "$tmpDir"' EXIT
-
-if [ "$fmt" = "zip" ]; then
-  unzip -q "$archive_path" -d "$tmpDir" 2>/dev/null
-elif [ "$fmt" = "tgz" ]; then
-  tar -xzf "$archive_path" -C "$tmpDir" 2>/dev/null
-elif [ "$fmt" = "json" ]; then
-  cp "$archive_path" "$tmpDir/org.json"
-fi
-
-# Find the main org config file (exclude sidecar files and manifest)
-orgConfigFile=$(find "$tmpDir" -name "*.json" | grep -vE -- '-approvals|-state|-activity|-goals|-routines|-projects|-members|-issues|-workspaces|-worktrees|-environments|-plugins|-adapters|-bootstrap|-threads|-budgets|-project-workspaces|-approval-comments|-secrets|/manifest\.json' | head -1)
-[ -z "$orgConfigFile" ] && orgConfigFile=$(find "$tmpDir" -name "org.json" -o -name "export.json" | head -1)
-
-if [ -z "$orgConfigFile" ]; then
-  echo "ERROR: Could not find org config file in archive."
-  exit 1
-fi
-
-importedOrgName="${org_name:-$(jq -r '.name // "unknown"' "$orgConfigFile")}"
-agentCount=$(jq '(.roles // []) | length' "$orgConfigFile")
-createdAt=$(jq -r '.created_at // "-"' "$orgConfigFile")
-gov=$(jq -r '.governance // "-"' "$orgConfigFile")
-
-echo "IMPORT PREVIEW"
-echo "────────────────────────────────────────────────────────"
-echo "  Archive:    $archive_path"
-echo "  Org name:   $importedOrgName"
-echo "  Agents:     $agentCount"
-echo "  Governance: $gov"
-echo "  Created:    $createdAt"
-echo ""
-
-# Check if org already exists
-targetOrgFile=".monomind/orgs/${importedOrgName}.json"
-if [ -f "$targetOrgFile" ]; then
-  existingAgents=$(jq '(.roles // []) | length' "$targetOrgFile")
-  echo "  WARNING: Org '${importedOrgName}' already exists ($existingAgents agents)."
-  echo "  Collision strategy: ${collision:-skip}"
-  echo ""
-fi
-
-# Preview agent plans
-echo "AGENT PLANS"
-echo "────────────────────────────────────────────────────────"
-jq -r --arg target "$targetOrgFile" '(.roles // [])[] |
-  [.id, (.title // "-"), (.adapter.type // "?"), (.adapter.model // "-")] | @tsv' \
-  "$orgConfigFile" | while IFS=$'\t' read -r id title adapter model; do
-  if [ -f "$targetOrgFile" ]; then
-    exists=$(jq -r --arg id "$id" '[(.roles // [])[] | select(.id == $id)] | length' "$targetOrgFile")
-    action=$([ "$exists" -gt 0 ] && echo "UPDATE" || echo "CREATE")
-  else
-    action="CREATE"
-  fi
-  printf "  %-8s %-24s %-20s %-16s %s\n" "$action" "$id" "$title" "$adapter" "$model"
-done
-
-echo ""
-echo "  To apply: --action apply --archive-path $archive_path --collision ${collision:-skip}"
-```
-
-### apply
-
-Apply the import (write org files):
-
-```bash
-tmpDir=$(mktemp -d /tmp/mastermind-import-XXXXXX)
-trap 'rm -rf "$tmpDir"' EXIT
-
-if [ "$fmt" = "zip" ]; then
-  unzip -q "$archive_path" -d "$tmpDir" 2>/dev/null
-elif [ "$fmt" = "tgz" ]; then
-  tar -xzf "$archive_path" -C "$tmpDir" 2>/dev/null
-elif [ "$fmt" = "json" ]; then
-  cp "$archive_path" "$tmpDir/org.json"
-fi
-
-orgConfigFile=$(find "$tmpDir" -name "*.json" | grep -vE -- '-approvals|-state|-activity|-goals|-routines|-projects|-members|-issues|-workspaces|-worktrees|-environments|-plugins|-adapters|-bootstrap|-threads|-budgets|-project-workspaces|-approval-comments|-secrets|/manifest\.json' | head -1)
-[ -z "$orgConfigFile" ] && orgConfigFile=$(find "$tmpDir" -name "org.json" -o -name "export.json" | head -1)
-[ -z "$orgConfigFile" ] && { echo "ERROR: Could not find org config file in archive."; exit 1; }
-
-importedOrgName="${org_name:-$(jq -r '.name // "unnamed"' "$orgConfigFile")}"
-targetOrgFile=".monomind/orgs/${importedOrgName}.json"
-
-mkdir -p ".monomind/orgs"
-
-# Handle collision
-if [ -f "$targetOrgFile" ]; then
-  collisionStrategy="${collision:-skip}"
-  case "$collisionStrategy" in
-    skip)
-      echo "ERROR: Org '${importedOrgName}' already exists. Use --collision merge or --collision overwrite to proceed."
-      exit 1
-      ;;
-    overwrite)
-      echo "  Overwriting existing org '${importedOrgName}'..."
-      rm -f ".monomind/orgs/${importedOrgName}"*.json ".monomind/orgs/${importedOrgName}"*.jsonl
-      ;;
-    merge)
-      echo "  Merging into existing org '${importedOrgName}'..."
-      # Merge will be handled per-file below
-      ;;
-  esac
-fi
-
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-
-# Apply adapter override if specified
-if [ -n "$adapter_override" ]; then
-  tmp="${orgConfigFile}.ovr"
-  jq --arg a "$adapter_override" \
-    '.roles = [(.roles // [])[] | .adapter.type = $a]' \
-    "$orgConfigFile" > "$tmp" && mv "$tmp" "$orgConfigFile"
-  echo "  Applied adapter override: $adapter_override to all agents"
-fi
-
-# Copy main config (or merge if merge strategy)
-if [ -f "$targetOrgFile" ] && [ "${collision:-skip}" = "merge" ]; then
-  tmp="$targetOrgFile.tmp"
-  python3 - "$targetOrgFile" "$orgConfigFile" > "$tmp" << 'PYEOF'
-import json, sys
-existing = json.load(open(sys.argv[1]))
-incoming = json.load(open(sys.argv[2]))
-existing_ids = {r['id'] for r in existing.get('roles', [])}
-new_roles = [r for r in incoming.get('roles', []) if r['id'] not in existing_ids]
-existing['roles'] = existing.get('roles', []) + new_roles
-print(json.dumps(existing, indent=2))
-PYEOF
-  mv "$tmp" "$targetOrgFile"
-  mergedCount=$(python3 -c "import json; d=json.load(open('$targetOrgFile')); print(len(d.get('roles',[])))")
-  echo "  Merged: $mergedCount total agents"
-else
-  cp "$orgConfigFile" "$targetOrgFile"
-fi
-
-# Copy associated files (goals, routines, issues, etc.) from archive
-for suffix in members issues goals projects routines approvals adapters plugins environments workspaces worktrees activity threads budgets project-workspaces approval-comments bootstrap; do
-  src=$(find "$tmpDir" -name "*-${suffix}.json" | head -1)
-  [ -z "$src" ] && src=$(find "$tmpDir" -name "*-${suffix}.jsonl" | head -1)
-  if [ -n "$src" ]; then
-    ext="${src##*.}"
-    dest=".monomind/orgs/${importedOrgName}-${suffix}.${ext}"
-    if [ -f "$dest" ] && [ "${collision:-skip}" = "merge" ]; then
-      # Merge arrays
-      python3 - "$dest" "$src" "$suffix" > "${dest}.tmp" << 'PYEOF'
-import json, sys, os
-dest_path, src_path, suffix = sys.argv[1], sys.argv[2], sys.argv[3]
-try:
-    dest_data = json.load(open(dest_path))
-    src_data = json.load(open(src_path))
-    arr_key = suffix if suffix in dest_data else list(dest_data.keys())[0] if dest_data else suffix
-    existing_ids = {item.get('id') for item in dest_data.get(arr_key, []) if 'id' in item}
-    new_items = [item for item in src_data.get(arr_key, []) if item.get('id') not in existing_ids]
-    dest_data[arr_key] = dest_data.get(arr_key, []) + new_items
-    print(json.dumps(dest_data, indent=2))
-except Exception as e:
-    print(json.dumps(json.load(open(dest_path))), file=__import__('sys').stdout)
-PYEOF
-      [ $? -eq 0 ] && mv "${dest}.tmp" "$dest" || rm -f "${dest}.tmp"
-    else
-      cp "$src" "$dest"
-    fi
-    echo "  Imported: ${importedOrgName}-${suffix}.${ext}"
-  fi
-done
-
-agentCount=$(jq '(.roles // []) | length' "$targetOrgFile")
-
-echo ""
-echo "IMPORT COMPLETE"
-echo "────────────────────────────────────────────────────────"
-echo "  Org:        $importedOrgName"
-echo "  Agents:     $agentCount"
-echo "  Location:   $targetOrgFile"
-echo "  Collision:  ${collision:-skip}"
-echo "  Applied at: $ts"
-echo ""
-echo "  Run org:    /mastermind:runorg --org $importedOrgName"
-echo "  View chart: /mastermind:org-chart --org $importedOrgName"
-```
-
----
-
-## Step 3 — Return Output
-
-```yaml
-domain: ops
-status: complete
-action: <action>
-org_name: <importedOrgName>
-agent_count: <N>
-collision: <strategy>
-```
-
----
-
-## Step 4 — Brain Write (standalone only)
-
-If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/.claude/skills/mastermind-skills/inbox.md

@@ -1,214 +0,0 @@
----
-name: mastermind-inbox
-description: Mastermind inbox — unified view of everything that needs human attention across all orgs: pending approvals, running heartbeats, active task assignments, and budget alerts. The single place to check before starting work.
-type: domain-skill
-default_mode: auto
----
-
-# Mastermind Inbox
-
-This skill is invoked by `mastermind:inbox` or directly via `/mastermind:inbox`.
-
----
-
-## Inputs
-
-- `brain_context`: BRAIN CONTEXT block
-- `org_name`: optional — filter to a single org (default: all orgs)
-- `filter`: all | approvals | heartbeats | tasks | alerts (default: all)
-- `action`: read | mark-done | archive
-- `item_id`: id of item to action
-- `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 — Collect All Orgs
-
-```bash
-if [ -n "$org_name" ]; then
-  orgs="$org_name"
-else
-  orgs=$(ls .monomind/orgs/*.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)
-fi
-```
-
----
-
-## Step 2 — Gather Inbox Items
-
-For each org, collect:
-
-```bash
-total_approvals=0
-total_heartbeats=0
-total_alerts=0
-
-for org in $orgs; do
-  orgFile=".monomind/orgs/${org}.json"
-  stateFile=".monomind/orgs/${org}-state.json"
-  approvalsFile=".monomind/orgs/${org}-approvals.json"
-
-  # 1. Pending approvals
-  if [ -f "$approvalsFile" ]; then
-    pending=$(jq '[(.approvals // [])[] | select(.status == "pending")] | length' "$approvalsFile" 2>/dev/null || echo 0)
-    total_approvals=$((total_approvals + pending))
-  fi
-
-  # 2. Running agents (active heartbeats)
-  if [ -f "$stateFile" ]; then
-    running=$(jq '[.agents // {} | to_entries[] | select(.value.status == "running")] | length' "$stateFile" 2>/dev/null || echo 0)
-    total_heartbeats=$((total_heartbeats + running))
-  fi
-
-  # 3. Budget alerts
-  budget=$(jq -r '.run_config.budget_tokens // 0' "$orgFile" 2>/dev/null || echo 0)
-  threshold=$(jq -r '.run_config.alert_threshold // 0.8' "$orgFile" 2>/dev/null || echo 0.8)
-  if [ "$budget" -gt 0 ] && [ -f "$stateFile" ]; then
-    total_in=$(jq '[.agents // {} | to_entries[] | .value.tokens_in // 0] | add // 0' "$stateFile" 2>/dev/null || echo 0)
-    total_out=$(jq '[.agents // {} | to_entries[] | .value.tokens_out // 0] | add // 0' "$stateFile" 2>/dev/null || echo 0)
-    total_tok=$((total_in + total_out))
-    over=$(awk -v t="$total_tok" -v b="$budget" -v thr="$threshold" \
-      'BEGIN { print (b>0 && t/b >= thr) ? "yes" : "no" }')
-    [ "$over" = "yes" ] && total_alerts=$((total_alerts + 1))
-  fi
-done
-```
-
----
-
-## Step 3 — Render Inbox
-
-```bash
-echo "╔══════════════════════════════════════════════════════╗"
-echo "║  MASTERMIND INBOX                                    ║"
-echo "╚══════════════════════════════════════════════════════╝"
-echo ""
-echo "  🔴 APPROVALS NEEDED:   $total_approvals"
-echo "  🟡 AGENTS RUNNING:     $total_heartbeats"
-echo "  🟠 BUDGET ALERTS:      $total_alerts"
-echo ""
-
-for org in $orgs; do
-  orgFile=".monomind/orgs/${org}.json"
-  stateFile=".monomind/orgs/${org}-state.json"
-  approvalsFile=".monomind/orgs/${org}-approvals.json"
-
-  has_items=0
-
-  # Pending approvals
-  if [ -f "$approvalsFile" ]; then
-    pending_approvals=$(jq -r '(.approvals // [])[] | select(.status == "pending") | "  [APPROVAL] [\(.id)] \(.agent_id): \(.title)  risk=\(.risk_level // "low")"' \
-      "$approvalsFile" 2>/dev/null)
-    [ -n "$pending_approvals" ] && { has_items=1; echo "ORG: $org"; echo "$pending_approvals"; }
-  fi
-
-  # Running agents
-  if [ -f "$stateFile" ]; then
-    running_agents=$(jq -r '
-      .agents // {} | to_entries[] | select(.value.status == "running") |
-      "  [RUNNING]  [\(.key)]  since=\(.value.last_heartbeat // "unknown")"
-    ' "$stateFile" 2>/dev/null)
-    [ -n "$running_agents" ] && { has_items=1; [ $has_items -eq 1 ] || echo "ORG: $org"; echo "$running_agents"; }
-  fi
-
-  [ $has_items -eq 1 ] && echo ""
-done
-
-if [ "$total_approvals" -eq 0 ] && [ "$total_heartbeats" -eq 0 ] && [ "$total_alerts" -eq 0 ]; then
-  echo "  ✓ Inbox is clear. No items need attention."
-fi
-```
-
-### filter: approvals only
-
-```bash
-for org in $orgs; do
-  approvalsFile=".monomind/orgs/${org}-approvals.json"
-  [ -f "$approvalsFile" ] || continue
-  echo "=== $org ==="
-  jq -r '(.approvals // [])[] | select(.status == "pending") |
-    "[\(.id)] \(.agent_id): \(.title)\n  Action: \(.action)\n  Risk: \(.risk_level // "low")\n  → /mastermind:approve --org '"$org"' --action approve --approval-id \(.id)"
-  ' "$approvalsFile" 2>/dev/null || echo "  No pending approvals."
-  echo ""
-done
-```
-
-### filter: heartbeats only
-
-Show currently running agent heartbeats across all orgs:
-
-```bash
-for org in $orgs; do
-  stateFile=".monomind/orgs/${org}-state.json"
-  [ -f "$stateFile" ] || continue
-  running=$(jq -r '
-    .agents // {} | to_entries[] | select(.value.status == "running") |
-    "  [\(.key)] since=\(.value.last_heartbeat // "?")"
-  ' "$stateFile" 2>/dev/null)
-  [ -n "$running" ] && { echo "=== $org ==="; echo "$running"; echo ""; }
-done
-```
-
-### filter: alerts only
-
-```bash
-echo "BUDGET ALERTS:"
-for org in $orgs; do
-  orgFile=".monomind/orgs/${org}.json"
-  stateFile=".monomind/orgs/${org}-state.json"
-  budget=$(jq -r '.run_config.budget_tokens // 0' "$orgFile" 2>/dev/null || echo 0)
-  [ "$budget" -le 0 ] && continue
-  [ -f "$stateFile" ] || continue
-  total_in=$(jq '[.agents // {} | to_entries[] | .value.tokens_in // 0] | add // 0' "$stateFile" 2>/dev/null || echo 0)
-  total_out=$(jq '[.agents // {} | to_entries[] | .value.tokens_out // 0] | add // 0' "$stateFile" 2>/dev/null || echo 0)
-  total_tok=$((total_in + total_out))
-  pct=$(awk -v t="$total_tok" -v b="$budget" 'BEGIN{printf "%.1f", t/b*100}')
-  echo "  $org: ${pct}% of $budget token budget used"
-done
-```
-
----
-
-## Quick Action Shortcuts
-
-From the inbox, the user can directly:
-
-```bash
-# Approve a pending request:
-/mastermind:approve --org <org> --action approve --approval-id <id>
-
-# Stop a running agent:
-/mastermind:agents --org <org> --action pause --agent-id <id>
-
-# Check costs:
-/mastermind:costs --org <org> --action report
-
-# Set budget:
-/mastermind:costs --org <org> --action set-budget --budget-tokens 500000
-```
-
----
-
-## Step 4 — Return Output
-
-```yaml
-domain: ops
-status: complete
-filter: <filter>
-orgs_checked: <N>
-pending_approvals: <N>
-running_heartbeats: <N>
-budget_alerts: <N>
-```
-
----
-
-## Step 5 — Brain Write (standalone only)
-
-If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.