@monoes/monomindcli 1.9.17 → 1.10.0

package/.claude/skills/mastermind/plan-to-tasks.md

@@ -0,0 +1,136 @@
+---
+name: mastermind-plan-to-tasks
+description: Mastermind plan-to-tasks — converts a written plan (prose, outline, or structured doc) into assigned org issues with correct specialties, dependency wiring, and parallelization. Mirrors Paperclip's plan-to-tasks skill. Use when breaking down a project plan into executable issue trees.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Plan to Tasks
+
+This skill is invoked by `mastermind:plan-to-tasks` or directly via `/mastermind:plan-to-tasks`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `org_name`: org to create issues in (required)
+- `plan`: the plan text (required — paste inline or pipe in)
+- `project_id`: assign all issues to this project (optional)
+- `workspace_id`: assign all issues to this workspace (optional)
+- `dry_run`: true | false (default: false — if true, print plan without creating issues)
+- `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 — Validate Inputs
+
+```bash
+[ -z "$org_name" ] && { echo "ERROR: --org required."; exit 1; }
+[ -z "$plan"     ] && { echo "ERROR: --plan required (the plan text to decompose)."; exit 1; }
+
+orgFile=".monomind/orgs/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
+```
+
+---
+
+## Step 2 — Load Agents for Specialty Matching
+
+```bash
+echo "PLAN-TO-TASKS — $org_name"
+echo "────────────────────────────────────────────────────────"
+echo ""
+echo "AGENTS IN ORG:"
+jq -r '.roles[] | "  \(.id)  \(.title // "-")  [\(.adapter.type // "?")]"' "$orgFile"
+echo ""
+```
+
+---
+
+## Step 3 — Decompose Plan into Issues
+
+Read the plan carefully and apply these rules:
+
+**Planning principles (from Paperclip plan-to-tasks):**
+
+1. **Plan deeply.** Capture real detail: goals, constraints, unknowns, success criteria, risks. A shallow plan becomes rework.
+2. **Know your team.** Read the org's agents and their specialties (titles, roles, adapters) before assigning anything.
+3. **Assign for specialty.** Hand each piece of work to the most relevant agent. If no agent fits, flag the gap.
+4. **Take responsibility.** When you (the AI) are best-suited for a piece, assign it to yourself instead of delegating.
+5. **Use the dependency tree.** Express every concrete deliverable as an issue. Wire real blockers via `blockedByIssueIds`. When done, dependents auto-wake.
+6. **Order, then parallelize.** Sequence by real dependencies. Independent branches start in parallel.
+7. **Enough is enough.** Plans unblock execution. Don't re-plan already clear work.
+
+**Decomposition output:**
+
+For each issue extracted from the plan, produce:
+```
+ISSUE: <title>
+  assignee:    <agent-id or UNASSIGNED>
+  priority:    low | medium | high | urgent
+  blockedBy:   <issue-title> (or none)
+  description: <1-2 sentence summary of the deliverable>
+```
+
+**Quality checklist before creating:**
+- [ ] Enough detail that assignees can act without re-asking
+- [ ] Every concrete deliverable is an issue
+- [ ] Each issue has a deliberate, specialty-matched assignee
+- [ ] Each issue's real blockers are declared
+- [ ] Independent branches can start in parallel
+- [ ] Gaps (missing skills, decisions, external inputs) are surfaced, not hidden
+
+---
+
+## Step 4 — Create Issues (unless dry_run=true)
+
+```bash
+issuesFile=".monomind/orgs/${org_name}-issues.json"
+[ ! -f "$issuesFile" ] && echo '{"issues":[]}' > "$issuesFile"
+
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+# Issues are created from the decomposition above
+# Each issue gets:
+#   id: issue-<timestamp>-<N>
+#   title, description, priority, status: open
+#   assigneeId (from matched agent)
+#   projectId, workspaceId (if provided)
+#   blockedByIssueIds (resolved after all issues are created)
+#   createdAt, updatedAt
+
+echo ""
+if [ "${dry_run:-false}" = "true" ]; then
+  echo "DRY RUN — no issues were created."
+  echo "Remove --dry-run to create these issues."
+else
+  echo "CREATED ISSUES:"
+  # (issue creation happens inline above as each issue is decomposed)
+fi
+```
+
+---
+
+## Step 5 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: plan-to-tasks
+org_name: <org_name>
+issues_created: <N>
+dry_run: <true|false>
+```
+
+---
+
+## Step 6 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/.claude/skills/mastermind/plugin-manager.md

@@ -0,0 +1,241 @@
+---
+name: mastermind-plugin-manager
+description: Mastermind plugin-manager — install plugins from npm, uninstall with two-step confirmation, enable/disable installed plugins. Extends mastermind:plugins (listing) and mastermind:plugin-settings (per-plugin config) with the install/uninstall lifecycle. Mirrors PluginManager.tsx.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Plugin Manager
+
+This skill is invoked by `mastermind:plugin-manager` or directly via `/mastermind:plugin-manager`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `action`: list | install | uninstall | enable | disable | check-updates
+- `package_name`: npm package name to install (for install; e.g. `@monomind/plugin-github`)
+- `plugin_id`: plugin id slug (required for uninstall/enable/disable)
+- `confirm`: yes (required second step for uninstall — prevents accidental removal)
+- `caller`: command | master
+
+---
+
+## Plugin Record Schema
+
+```json
+{
+  "id": "plugin-slug",
+  "packageName": "@monomind/plugin-name",
+  "status": "installed",
+  "version": "1.2.0",
+  "category": "monitoring",
+  "description": "One-line plugin description",
+  "installedAt": "2026-01-01T00:00:00Z",
+  "config": {},
+  "grants": [],
+  "health": {"status": "ok", "lastCheck": null}
+}
+```
+
+---
+
+## 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 Plugin Registry
+
+```bash
+registryFile=".monomind/plugins/registry.json"
+mkdir -p ".monomind/plugins"
+[ ! -f "$registryFile" ] && echo '{"plugins":[]}' > "$registryFile"
+```
+
+---
+
+## Step 2 — Execute Action
+
+### list (default)
+
+```bash
+echo "INSTALLED PLUGINS"
+echo "────────────────────────────────────────────────────────"
+printf "%-24s %-10s %-10s %-14s %s\n" "ID" "STATUS" "VERSION" "CATEGORY" "PACKAGE"
+echo "────────────────────────────────────────────────────────"
+
+count=$(jq '.plugins | length' "$registryFile")
+if [ "$count" -eq 0 ]; then
+  echo "  No plugins installed."
+  echo "  Install one: --action install --package-name @monomind/plugin-github"
+else
+  jq -r '.plugins[] |
+    [.id, (.status // "installed"), (.version // "-"), (.category // "general"),
+     (.packageName // "-")] | @tsv' \
+    "$registryFile" | while IFS=$'\t' read -r id st ver cat pkg; do
+    printf "%-24s %-10s %-10s %-14s %s\n" "$id" "$st" "$ver" "$cat" "$pkg"
+  done
+
+  errCount=$(jq '[.plugins[] | select(.status == "error")] | length' "$registryFile")
+  [ "$errCount" -gt 0 ] && echo "" && echo "  WARNING: $errCount plugin(s) in error state. Run: --action list to inspect."
+fi
+
+echo ""
+echo "  Install:    --action install --package-name <npm-package>"
+echo "  Uninstall:  --action uninstall --plugin-id <id>"
+echo "  Settings:   /mastermind:plugin-settings --plugin-id <id>"
+```
+
+### install
+
+```bash
+[ -z "$package_name" ] && { echo "ERROR: --package-name required (e.g. @monomind/plugin-github)."; exit 1; }
+
+echo "INSTALLING PLUGIN — $package_name"
+echo "────────────────────────────────────────────────────────"
+echo "  Running: npm install $package_name"
+
+# Check if already installed
+alreadyId=$(jq -r --arg pkg "$package_name" '.plugins[] | select(.packageName == $pkg) | .id' "$registryFile" | head -1)
+[ -n "$alreadyId" ] && {
+  echo "  Plugin already installed as '$alreadyId'. Use --action enable/disable or reinstall via npm."
+  exit 0
+}
+
+if npm install "$package_name" 2>&1 | tail -5; then
+  # Derive plugin metadata from npm package
+  pkgVer=$(node -e "try{console.log(require('${package_name}/package.json').version)}catch(e){console.log('0.0.0')}" 2>/dev/null || echo "0.0.0")
+  pkgDesc=$(node -e "try{console.log(require('${package_name}/package.json').description||'')}catch(e){console.log('')}" 2>/dev/null || echo "")
+  pluginId=$(echo "$package_name" | sed 's|@[^/]*/||' | tr '[:upper:]' '[:lower:]' | tr -cs 'a-z0-9' '-' | sed 's/^-//;s/-$//')
+  ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+  tmp="${registryFile}.tmp"
+  jq --arg id "$pluginId" \
+     --arg pkg "$package_name" \
+     --arg ver "$pkgVer" \
+     --arg desc "$pkgDesc" \
+     --arg ts "$ts" \
+    '.plugins += [{"id":$id,"packageName":$pkg,"status":"installed","version":$ver,
+      "description":$desc,"category":"general","config":{},"grants":[],
+      "health":{"status":"ok","lastCheck":null},"installedAt":$ts}]' \
+    "$registryFile" > "$tmp" && mv "$tmp" "$registryFile"
+
+  echo ""
+  echo "Plugin installed: $pluginId @ $pkgVer"
+  echo "  Configure: /mastermind:plugin-settings --plugin-id $pluginId"
+else
+  echo "  ERROR: npm install failed. Check the package name and network connectivity."
+  exit 1
+fi
+```
+
+### uninstall
+
+```bash
+[ -z "$plugin_id" ] && { echo "ERROR: --plugin-id required."; exit 1; }
+
+exists=$(jq -r --arg id "$plugin_id" '[.plugins[] | select(.id == $id)] | length' "$registryFile")
+[ "$exists" -eq 0 ] && { echo "ERROR: Plugin '$plugin_id' not found."; exit 1; }
+
+# Two-step confirmation
+if [ "${confirm:-}" != "yes" ]; then
+  pkg=$(jq -r --arg id "$plugin_id" '.plugins[] | select(.id == $id) | .packageName // $id' "$registryFile")
+  echo "UNINSTALL CONFIRMATION REQUIRED"
+  echo "────────────────────────────────────────────────────────"
+  echo "  Plugin:  $plugin_id  ($pkg)"
+  echo "  This will remove the plugin and all its configuration."
+  echo ""
+  echo "  To confirm: --action uninstall --plugin-id $plugin_id --confirm yes"
+  exit 0
+fi
+
+pkg=$(jq -r --arg id "$plugin_id" '.plugins[] | select(.id == $id) | .packageName // ""' "$registryFile")
+
+# Remove from registry
+tmp="${registryFile}.tmp"
+jq --arg id "$plugin_id" \
+  '.plugins = [.plugins[] | select(.id != $id)]' \
+  "$registryFile" > "$tmp" && mv "$tmp" "$registryFile"
+
+echo "Plugin '$plugin_id' removed from registry."
+
+# Attempt npm uninstall if packageName known
+if [ -n "$pkg" ]; then
+  echo "  Running: npm uninstall $pkg"
+  npm uninstall "$pkg" 2>&1 | tail -3 || echo "  WARNING: npm uninstall had errors — registry entry removed anyway."
+fi
+```
+
+### enable
+
+```bash
+[ -z "$plugin_id" ] && { echo "ERROR: --plugin-id required."; exit 1; }
+
+exists=$(jq -r --arg id "$plugin_id" '[.plugins[] | select(.id == $id)] | length' "$registryFile")
+[ "$exists" -eq 0 ] && { echo "ERROR: Plugin '$plugin_id' not found."; exit 1; }
+
+tmp="${registryFile}.tmp"
+jq --arg id "$plugin_id" \
+  '.plugins = [.plugins[] | if .id == $id then .status = "installed" | .disabledAt = null else . end]' \
+  "$registryFile" > "$tmp" && mv "$tmp" "$registryFile"
+
+echo "Plugin '$plugin_id' ENABLED."
+```
+
+### disable
+
+```bash
+[ -z "$plugin_id" ] && { echo "ERROR: --plugin-id required."; exit 1; }
+
+exists=$(jq -r --arg id "$plugin_id" '[.plugins[] | select(.id == $id)] | length' "$registryFile")
+[ "$exists" -eq 0 ] && { echo "ERROR: Plugin '$plugin_id' not found."; exit 1; }
+
+ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+tmp="${registryFile}.tmp"
+jq --arg id "$plugin_id" --arg ts "$ts" \
+  '.plugins = [.plugins[] | if .id == $id then .status = "disabled" | .disabledAt = $ts else . end]' \
+  "$registryFile" > "$tmp" && mv "$tmp" "$registryFile"
+
+echo "Plugin '$plugin_id' DISABLED — will not load on next startup."
+```
+
+### check-updates
+
+```bash
+echo "CHECKING PLUGIN UPDATES"
+echo "────────────────────────────────────────────────────────"
+
+count=$(jq '.plugins | length' "$registryFile")
+[ "$count" -eq 0 ] && { echo "  No plugins installed."; exit 0; }
+
+jq -r '.plugins[] | select(.packageName != null) |
+  [.id, .packageName, (.version // "unknown")] | @tsv' \
+  "$registryFile" | while IFS=$'\t' read -r id pkg ver; do
+  latest=$(curl -sf "https://registry.npmjs.org/${pkg}/latest" 2>/dev/null | jq -r '.version // "?"' 2>/dev/null || echo "?")
+  if [ "$latest" != "?" ] && [ "$latest" != "$ver" ]; then
+    echo "  [$id]  $ver  →  $latest  — run: npm install $pkg"
+  else
+    echo "  [$id]  $ver  (up to date)"
+  fi
+done
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+plugin_id: <plugin_id>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/.claude/skills/mastermind/plugin-settings.md

@@ -0,0 +1,273 @@
+---
+name: mastermind-plugin-settings
+description: Mastermind plugin-settings — inspect and configure a single installed plugin. View configuration fields, manage file system access grants (read/write paths), check runtime health/status, and update plugin settings. Mirrors Paperclip's PluginSettings page with configuration and status tabs.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Plugin Settings
+
+This skill is invoked by `mastermind:plugin-settings` or directly via `/mastermind:plugin-settings`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `plugin_id`: plugin id to manage (required)
+- `org_name`: org scope (optional — uses global registry if omitted)
+- `action`: show | config | status | grants | set-config | add-grant | remove-grant
+- `config_key`: config key to set (for set-config)
+- `config_value`: config value (for set-config)
+- `grant_path`: filesystem path to grant access to (for add-grant/remove-grant)
+- `grant_access`: read | write | readwrite (for add-grant, default: read)
+- `caller`: command | master
+
+---
+
+## Plugin Configuration Model
+
+```json
+{
+  "id": "plugin-slug",
+  "packageName": "@monomind/plugin-name",
+  "status": "installed",
+  "version": "1.2.0",
+  "category": "monitoring",
+  "config": {
+    "apiKey": "***",
+    "webhookUrl": "https://...",
+    "customField": "value"
+  },
+  "grants": [
+    { "path": "/tmp/plugin-data", "access": "readwrite" },
+    { "path": "/project/logs", "access": "read" }
+  ],
+  "health": {
+    "status": "ok",
+    "lastCheck": "2026-01-01T00:00:00Z",
+    "message": null
+  }
+}
+```
+
+---
+
+## 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 Plugin Registry
+
+```bash
+registryFile=".monomind/plugins/registry.json"
+[ ! -f "$registryFile" ] && { echo "ERROR: No plugin registry found. Install plugins via /mastermind:plugins."; exit 1; }
+
+pluginDef=$(jq -r --arg id "$plugin_id" '.plugins[] | select(.id == $id)' "$registryFile")
+[ -z "$pluginDef" ] && { echo "ERROR: Plugin '$plugin_id' not found. List plugins via /mastermind:plugins --action list."; exit 1; }
+
+# Load org-level overrides if org_name specified
+orgPluginsFile=""
+if [ -n "$org_name" ]; then
+  orgPluginsFile=".monomind/orgs/${org_name}-plugins.json"
+  orgOverride=$([ -f "$orgPluginsFile" ] && jq -r --arg id "$plugin_id" '.plugins[] | select(.id == $id)' "$orgPluginsFile" || echo "")
+fi
+```
+
+---
+
+## Step 2 — Execute Action
+
+### show (default)
+
+```bash
+echo "PLUGIN — $plugin_id"
+echo "────────────────────────────────────────────────────────"
+
+echo "$pluginDef" | jq -r '
+  "  ID:         \(.id)",
+  "  Package:    \(.packageName // "-")",
+  "  Version:    \(.version // "-")",
+  "  Status:     \(.status // "unknown")",
+  "  Category:   \(.category // "general")",
+  "  Local path: \(if .isLocalPath then "yes" else "no" end)",
+  "  Installed:  \(.installedAt // "-")"
+'
+
+if [ -n "$orgOverride" ] && [ "$orgOverride" != "null" ]; then
+  echo ""
+  echo "  ORG OVERRIDE ($org_name):"
+  echo "$orgOverride" | jq -r '"  Status: \(.status // "inherited")"'
+fi
+
+# Config summary
+configCount=$(echo "$pluginDef" | jq -r '(.config // {}) | length')
+echo ""
+echo "  Config fields:  $configCount"
+echo "  Grants:         $(echo "$pluginDef" | jq -r '(.grants // []) | length')"
+
+# Health
+healthStatus=$(echo "$pluginDef" | jq -r '.health.status // "unknown"')
+healthMsg=$(echo "$pluginDef" | jq -r '.health.message // ""')
+echo "  Health:         $healthStatus${healthMsg:+ — $healthMsg}"
+
+# Last error
+lastErr=$(echo "$pluginDef" | jq -r '.lastError // ""')
+[ -n "$lastErr" ] && echo "" && echo "  LAST ERROR: $lastErr"
+```
+
+### config
+
+```bash
+echo "CONFIG — $plugin_id"
+echo "────────────────────────────────────────────────────────"
+
+config=$(echo "$pluginDef" | jq -r '.config // {}')
+count=$(echo "$config" | jq 'length')
+
+if [ "$count" -eq 0 ]; then
+  echo "  No configuration fields."
+  echo "  Set a field: --action set-config --config-key <key> --config-value <value>"
+else
+  echo "$config" | jq -r 'to_entries[] |
+    if (.value | type) == "string" and (.key | test("key|token|secret|password|api"; "i")) then
+      "  \(.key) = ***"
+    else
+      "  \(.key) = \(.value)"
+    end'
+fi
+```
+
+### status
+
+```bash
+echo "PLUGIN STATUS — $plugin_id"
+echo "────────────────────────────────────────────────────────"
+
+echo "$pluginDef" | jq -r '
+  "  Status:      \(.status // "unknown")",
+  "  Version:     \(.version // "-")",
+  "  Installed:   \(.installedAt // "-")"
+'
+
+health=$(echo "$pluginDef" | jq -r '.health // {}')
+healthStatus=$(echo "$health" | jq -r '.status // "unknown"')
+lastCheck=$(echo "$health" | jq -r '.lastCheck // "-"')
+healthMsg=$(echo "$health" | jq -r '.message // ""')
+
+echo ""
+echo "HEALTH CHECK"
+echo "  Status:    $healthStatus"
+echo "  Last:      $lastCheck"
+[ -n "$healthMsg" ] && echo "  Message:   $healthMsg"
+
+# Error
+lastErr=$(echo "$pluginDef" | jq -r '.lastError // ""')
+if [ -n "$lastErr" ]; then
+  echo ""
+  echo "LAST ERROR"
+  echo "  $lastErr"
+fi
+
+# Suggest reload
+[ "$healthStatus" = "error" ] && echo "" && echo "  Run: /mastermind:plugins --action reload --plugin-id $plugin_id"
+```
+
+### grants
+
+```bash
+echo "FILE SYSTEM GRANTS — $plugin_id"
+echo "────────────────────────────────────────────────────────"
+printf "%-6s %s\n" "ACCESS" "PATH"
+echo "────────────────────────────────────────────────────────"
+
+grants=$(echo "$pluginDef" | jq -r '(.grants // [])[]' 2>/dev/null)
+if [ -z "$grants" ]; then
+  echo "  No file system grants."
+  echo "  Add a grant: --action add-grant --grant-path /path/to/dir --grant-access read"
+else
+  echo "$pluginDef" | jq -r '(.grants // [])[] |
+    "  \(.access // "read")\t\(.path)"' | while IFS=$'\t' read -r acc path; do
+    printf "  %-10s %s\n" "$acc" "$path"
+  done
+fi
+```
+
+### set-config
+
+```bash
+[ -z "$config_key" ] && { echo "ERROR: --config-key required."; exit 1; }
+[ -z "$config_value" ] && { echo "ERROR: --config-value required."; exit 1; }
+
+tmp="${registryFile}.tmp"
+jq --arg id "$plugin_id" --arg k "$config_key" --arg v "$config_value" \
+  '.plugins = [.plugins[] | if .id == $id then
+     if .config == null then .config = {} else . end |
+     .config[$k] = $v
+   else . end]' \
+  "$registryFile" > "$tmp" && mv "$tmp" "$registryFile"
+
+# Mask value in output if sensitive key
+if echo "$config_key" | grep -qiE "key|token|secret|password|api"; then
+  echo "Config set: $config_key = ***"
+else
+  echo "Config set: $config_key = $config_value"
+fi
+echo "NOTE: Restart agents or reload the plugin for changes to take effect."
+```
+
+### add-grant
+
+```bash
+[ -z "$grant_path" ] && { echo "ERROR: --grant-path required."; exit 1; }
+access="${grant_access:-read}"
+case "$access" in read|write|readwrite) : ;; *)
+  echo "ERROR: --grant-access must be read, write, or readwrite"; exit 1 ;;
+esac
+
+tmp="${registryFile}.tmp"
+jq --arg id "$plugin_id" --arg path "$grant_path" --arg access "$access" \
+  '.plugins = [.plugins[] | if .id == $id then
+     .grants = ((.grants // []) | map(select(.path != $path))) +
+               [{"path":$path,"access":$access}]
+   else . end]' \
+  "$registryFile" > "$tmp" && mv "$tmp" "$registryFile"
+
+echo "Grant added: $access → $grant_path"
+```
+
+### remove-grant
+
+```bash
+[ -z "$grant_path" ] && { echo "ERROR: --grant-path required."; exit 1; }
+
+tmp="${registryFile}.tmp"
+jq --arg id "$plugin_id" --arg path "$grant_path" \
+  '.plugins = [.plugins[] | if .id == $id then
+     .grants = [(.grants // [])[] | select(.path != $path)]
+   else . end]' \
+  "$registryFile" > "$tmp" && mv "$tmp" "$registryFile"
+
+echo "Grant removed: $grant_path"
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+plugin_id: <plugin_id>
+plugin_status: <status>
+health_status: <health>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.