monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/.claude/skills/mastermind-finance/SKILL.md

@@ -1,166 +0,0 @@
----
-name: mastermind-finance
-description: Mastermind finance domain — invoicing, budget tracking, financial forecasting. Spawns a Finance Manager coordinating financial tracking and analysis agents.
-type: domain-skill
-default_mode: confirm
----
-
-# Mastermind Finance Domain
-
-This skill is invoked by `mastermind:master` or directly via `/mastermind:finance`.
-
----
-
-## Inputs
-
-- `brain_context`: BRAIN CONTEXT block (injected by master, or loaded standalone via mastermind-protocol/SKILL.md brain load)
-- `prompt`: the finance goal for this run
-- `project_name`: monotask space name
-- `board_id`: monotask board ID (set by master, or created standalone)
-- `mode`: auto | confirm
-
----
-
-## Complexity Assessment
-
-Assess the prompt to determine execution mode:
-
-**Simple (direct execution):** Single calculation or single document:
-- "Calculate total revenue for Q1 from these figures: ..."
-- "Draft an invoice for project X at $5,000"
-→ Use a single Finance Tracker agent. Skip manager delegation.
-
-**Complex (spawn Finance Manager agent):** Any of these:
-- Full financial forecast (revenue + costs + runway)
-- Budget analysis across multiple cost centers
-- Batch invoice processing
-- P&L or cash flow modeling
-→ Spawn Finance Manager agent with full briefing.
-
----
-
-## 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: `finance`)
-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 "finance" --json | jq -r '.id // empty')
-   [ -z "$board_id" ] && { echo "ERROR: Failed to create finance 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: `finance`)
-
----
-
-## Complex Execution — Finance Manager Agent
-
-Spawn a Finance Manager agent via Task tool:
-
-```javascript
-Task({
-  subagent_type: "coordinator",
-  description: `You are the Finance Manager for project <project_name>.
-
-CONTEXT: <date> | Project: <project_name> | Spawned by: mastermind:finance
-
-BRAIN CONTEXT:
-<brain_context>
-
-YOUR BOARD: <board_id>
-YOUR GOAL: <prompt>
-
-STEP 1 — PLAN
-Decompose the finance goal into discrete workstreams. For each workstream, identify:
-- What financial domain it covers (invoicing, tracking, forecasting, analysis)
-- What input data is needed
-- What deliverable is produced (report, model, invoice batch)
-- Dependencies between workstreams
-
-STEP 2 — CREATE TASKS
-For each workstream, 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 workstream goal, ≤80 chars>" --json)
-CARD_ID=$(echo "$result" | jq -r '.id // empty')
-monotask card set-description "$BOARD_ID" "$CARD_ID" "[specific financial workstream goal]"
-monotask card comment add "$BOARD_ID" "$CARD_ID" "CONTEXT: <date> | Project: <project_name> | Created by: Finance Manager
-BRAIN MEMORY: [paste most relevant 3-5 brain context excerpts]
-SCOPE: [time period, accounts, cost centers, currencies in scope]
-CONSTRAINTS: [accounting standards, tax requirements, rounding rules, approval thresholds]
-SUCCESS CRITERIA:
-- [ ] [checkable item — e.g. \"forecast covers 12-month runway\"]
-AGENT: [Finance Tracker | Analytics Reporter]
-SWARM: hierarchical 3 raft
-DEPENDENCIES: [task IDs or \"none\"]
-OUTPUT FORMAT: unified output schema"
-```
-
-STEP 3 — EXECUTE
-Spawn one Task agent per workstream:
-- Financial tracking and invoicing: subagent_type "Finance Tracker"
-- Analysis and reporting: subagent_type "Analytics Reporter"
-
-Also run /mastermind:do --board <board_id> to track execution.
-
-STEP 4 — COLLECT AND RETURN
-Collect all financial outputs. Return to caller:
-
-domain: finance
-status: complete | partial | blocked
-artifacts:
-  - path: [financial reports, invoices, forecast models]
-    type: report
-decisions:
-  - what: [financial decisions or recommendations made]
-    why: [reasoning — cost drivers, runway implications, risk factors]
-    confidence: [0.0-1.0]
-    outcome: pending | shipped
-lessons:
-  - what_worked: [what data sources or models were most accurate]
-  - what_didnt: [what required manual correction or more data]
-next_actions:
-  - [e.g. "run mastermind:ops to automate invoice generation"]
-  - [e.g. "run mastermind:review on the financial model assumptions"]
-board_url: monotask://<project_name>/finance
-run_id: <ISO8601-timestamp>`,
-  run_in_background: true
-})
-```
-
----
-
-## Simple Execution
-
-For simple tasks (single agent, single output):
-
-1. Spawn one Task agent with the finance 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 financial forecast | coordinator + tracker + analyst | hierarchical 3 raft specialized |
-| Budget analysis | Finance Tracker + Analytics Reporter | hierarchical 3 raft specialized |
-| Invoice batch | Finance Tracker | hierarchical 3 raft specialized |
-| P&L report | Analytics Reporter | single agent |
-| Single invoice or calculation | Finance Tracker | single agent |

package/packages/@monomind/cli/.claude/skills/mastermind-finish/SKILL.md

@@ -1,251 +0,0 @@
----
-name: mastermind-finish
-description: Use when implementation is complete, all tests pass, and you need to decide how to integrate the work — guides completion of development work by presenting structured options for merge, PR, or cleanup
----
-
-# Finishing a Development Branch
-
-## Overview
-
-Guide completion of development work by presenting clear options and handling the chosen workflow.
-
-**Core principle:** Verify tests → Detect environment → Present options → Execute choice → Clean up.
-
-**Announce at start:** "I'm using the mastermind:finish skill to complete this work."
-
-## The Process
-
-### Step 1: Verify Tests
-
-**Before presenting options, verify tests pass:**
-
-```bash
-# Run project's test suite
-npm test / cargo test / pytest / go test ./...
-```
-
-**If tests fail:**
-```
-Tests failing (<N> failures). Must fix before completing:
-
-[Show failures]
-
-Cannot proceed with merge/PR until tests pass.
-```
-
-Stop. Don't proceed to Step 2.
-
-**If tests pass:** Continue to Step 2.
-
-### Step 2: Detect Environment
-
-**Determine workspace state before presenting options:**
-
-```bash
-GIT_DIR=$(cd "$(git rev-parse --git-dir)" 2>/dev/null && pwd -P)
-GIT_COMMON=$(cd "$(git rev-parse --git-common-dir)" 2>/dev/null && pwd -P)
-```
-
-This determines which menu to show and how cleanup works:
-
-| State | Menu | Cleanup |
-|-------|------|---------|
-| `GIT_DIR == GIT_COMMON` (normal repo) | Standard 4 options | No worktree to clean up |
-| `GIT_DIR != GIT_COMMON`, named branch | Standard 4 options | Provenance-based (see Step 6) |
-| `GIT_DIR != GIT_COMMON`, detached HEAD | Reduced 3 options (no merge) | No cleanup (externally managed) |
-
-### Step 3: Determine Base Branch
-
-```bash
-# Try common base branches
-git merge-base HEAD main 2>/dev/null || git merge-base HEAD master 2>/dev/null
-```
-
-Or ask: "This branch split from main — is that correct?"
-
-### Step 4: Present Options
-
-**Normal repo and named-branch worktree — present exactly these 4 options:**
-
-```
-Implementation complete. What would you like to do?
-
-1. Merge back to <base-branch> locally
-2. Push and create a Pull Request
-3. Keep the branch as-is (I'll handle it later)
-4. Discard this work
-
-Which option?
-```
-
-**Detached HEAD — present exactly these 3 options:**
-
-```
-Implementation complete. You're on a detached HEAD (externally managed workspace).
-
-1. Push as new branch and create a Pull Request
-2. Keep as-is (I'll handle it later)
-3. Discard this work
-
-Which option?
-```
-
-**Don't add explanation** — keep options concise.
-
-### Step 5: Execute Choice
-
-#### Option 1: Merge Locally
-
-```bash
-# Get main repo root for CWD safety
-MAIN_ROOT=$(git -C "$(git rev-parse --git-common-dir)/.." rev-parse --show-toplevel)
-cd "$MAIN_ROOT"
-
-# Merge first — verify success before removing anything
-git checkout <base-branch>
-git pull
-git merge <feature-branch>
-
-# Verify tests on merged result
-<test command>
-
-# Only after merge succeeds: cleanup worktree (Step 6), then delete branch
-```
-
-Then: Cleanup worktree (Step 6), then delete branch:
-
-```bash
-git branch -d <feature-branch>
-```
-
-#### Option 2: Push and Create PR
-
-```bash
-# Push branch
-git push -u origin <feature-branch>
-
-# Create PR
-gh pr create --title "<title>" --body "$(cat <<'EOF'
-## Summary
-<2-3 bullets of what changed>
-
-## Test Plan
-- [ ] <verification steps>
-EOF
-)"
-```
-
-**Do NOT clean up worktree** — user needs it alive to iterate on PR feedback.
-
-#### Option 3: Keep As-Is
-
-Report: "Keeping branch <name>. Worktree preserved at <path>."
-
-**Don't cleanup worktree.**
-
-#### Option 4: Discard
-
-**Confirm first:**
-```
-This will permanently delete:
-- Branch <name>
-- All commits: <commit-list>
-- Worktree at <path>
-
-Type 'discard' to confirm.
-```
-
-Wait for exact confirmation.
-
-If confirmed:
-```bash
-MAIN_ROOT=$(git -C "$(git rev-parse --git-common-dir)/.." rev-parse --show-toplevel)
-cd "$MAIN_ROOT"
-```
-
-Then: Cleanup worktree (Step 6), then force-delete branch:
-```bash
-git branch -D <feature-branch>
-```
-
-### Step 6: Cleanup Workspace
-
-**Only runs for Options 1 and 4.** Options 2 and 3 always preserve the worktree.
-
-```bash
-GIT_DIR=$(cd "$(git rev-parse --git-dir)" 2>/dev/null && pwd -P)
-GIT_COMMON=$(cd "$(git rev-parse --git-common-dir)" 2>/dev/null && pwd -P)
-WORKTREE_PATH=$(git rev-parse --show-toplevel)
-```
-
-**If `GIT_DIR == GIT_COMMON`:** Normal repo, no worktree to clean up. Done.
-
-**If worktree path is under `.worktrees/`, `worktrees/`, or `~/.config/monomind/worktrees/`:** Mastermind created this worktree — we own cleanup.
-
-```bash
-MAIN_ROOT=$(git -C "$(git rev-parse --git-common-dir)/.." rev-parse --show-toplevel)
-cd "$MAIN_ROOT"
-git worktree remove "$WORKTREE_PATH"
-git worktree prune  # Self-healing: clean up any stale registrations
-```
-
-**Otherwise:** The host environment (harness) owns this workspace. Do NOT remove it. If your platform provides a workspace-exit tool, use it. Otherwise, leave the workspace in place.
-
-## Quick Reference
-
-| Option | Merge | Push | Keep Worktree | Cleanup Branch |
-|--------|-------|------|---------------|----------------|
-| 1. Merge locally | yes | - | - | yes |
-| 2. Create PR | - | yes | yes | - |
-| 3. Keep as-is | - | - | yes | - |
-| 4. Discard | - | - | - | yes (force) |
-
-## Common Mistakes
-
-**Skipping test verification**
-- **Problem:** Merge broken code, create failing PR
-- **Fix:** Always verify tests before offering options
-
-**Open-ended questions**
-- **Problem:** "What should I do next?" is ambiguous
-- **Fix:** Present exactly 4 structured options (or 3 for detached HEAD)
-
-**Cleaning up worktree for Option 2**
-- **Problem:** Remove worktree user needs for PR iteration
-- **Fix:** Only cleanup for Options 1 and 4
-
-**Deleting branch before removing worktree**
-- **Problem:** `git branch -d` fails because worktree still references the branch
-- **Fix:** Merge first, remove worktree, then delete branch
-
-**Running git worktree remove from inside the worktree**
-- **Problem:** Command fails silently when CWD is inside the worktree being removed
-- **Fix:** Always `cd` to main repo root before `git worktree remove`
-
-**Cleaning up harness-owned worktrees**
-- **Problem:** Removing a worktree the harness created causes phantom state
-- **Fix:** Only clean up worktrees under `.worktrees/`, `worktrees/`, or `~/.config/monomind/worktrees/`
-
-**No confirmation for discard**
-- **Problem:** Accidentally delete work
-- **Fix:** Require typed "discard" confirmation
-
-## Red Flags
-
-**Never:**
-- Proceed with failing tests
-- Merge without verifying tests on result
-- Delete work without confirmation
-- Force-push without explicit request
-- Remove a worktree before confirming merge success
-- Clean up worktrees you didn't create (provenance check)
-- Run `git worktree remove` from inside the worktree
-
-**Always:**
-- Verify tests before offering options
-- Detect environment before presenting menu
-- Present exactly 4 options (or 3 for detached HEAD)
-- Get typed confirmation for Option 4
-- Clean up worktree for Options 1 & 4 only
-- `cd` to main repo root before worktree removal
-- Run `git worktree prune` after removal

package/packages/@monomind/cli/.claude/skills/mastermind-goal-detail/SKILL.md

@@ -1,255 +0,0 @@
----
-name: mastermind-goal-detail
-description: Mastermind goal-detail — deep per-goal inspection and management. Show sub-goal tree, linked projects, edit title/status/description/priority, add child goals, and close or reopen a single goal within an org.
-type: domain-skill
-default_mode: auto
----
-
-# Mastermind Goal Detail
-
-This skill is invoked by `mastermind:goal-detail` or directly via `/mastermind:goal-detail`.
-
----
-
-## Inputs
-
-- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
-- `org_name`: org the goal belongs to (required)
-- `goal_id`: goal id/slug (required)
-- `action`: show | tree | projects | edit | add-child | close | reopen
-- `field`: field to edit (title | description | status | priority | parent_id)
-- `value`: new field value (required for edit)
-- `child_title`: title for the new child goal (required for add-child)
-- `child_description`: description for the new child goal (optional)
-- `caller`: command | master
-
----
-
-## Goal Status Flow
-
-```
-open → in_progress → done
-  └──────────────────┘  (can reopen)
-```
-
-## Priority Levels
-
-`critical` | `high` | `medium` | `low`
-
----
-
-## 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 Goal Data
-
-```bash
-orgFile=".monomind/orgs/${org_name}.json"
-[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
-
-goalsFile=".monomind/orgs/${org_name}-goals.json"
-[ ! -f "$goalsFile" ] && { echo "ERROR: No goals file for org '$org_name'. Create goals via /mastermind:goals."; exit 1; }
-
-goalDef=$(jq -r --arg id "$goal_id" '(.goals // [])[] | select(.id == $id or .slug == $id)' "$goalsFile")
-[ -z "$goalDef" ] && { echo "ERROR: Goal '$goal_id' not found in org '$org_name'."; exit 1; }
-
-resolvedId=$(echo "$goalDef" | jq -r '.id')
-projectsFile=".monomind/orgs/${org_name}-projects.json"
-```
-
----
-
-## Step 2 — Execute Action
-
-### show (default)
-
-```bash
-echo "GOAL DETAIL — $goal_id @ $org_name"
-echo "────────────────────────────────────────────────────────"
-
-echo "$goalDef" | jq -r '
-  "  ID:           \(.id)",
-  "  Title:        \(.title // "(no title)")",
-  "  Status:       \(.status // "open")",
-  "  Priority:     \(.priority // "medium")",
-  "  Parent:       \(.parent_id // "(root goal)")",
-  "  Created:      \(.created_at // "-")",
-  "  Updated:      \(.updated_at // "-")"
-'
-
-# Sub-goals count
-subCount=$(jq --arg pid "$resolvedId" '[(.goals // [])[] | select(.parent_id == $pid)] | length' "$goalsFile" 2>/dev/null || echo 0)
-doneCount=$(jq --arg pid "$resolvedId" '[(.goals // [])[] | select(.parent_id == $pid and .status == "done")] | length' "$goalsFile" 2>/dev/null || echo 0)
-echo "  Sub-goals:    $subCount total, $doneCount done"
-
-# Linked projects
-projCount=$(echo "$goalDef" | jq -r '(.linked_projects // []) | length')
-echo "  Projects:     $projCount linked"
-
-# Description
-desc=$(echo "$goalDef" | jq -r '.description // ""')
-if [ -n "$desc" ]; then
-  echo ""
-  echo "DESCRIPTION"
-  echo "────────────────────────────────────────────────────────"
-  echo "$desc"
-fi
-```
-
-### tree
-
-```bash
-echo "SUB-GOAL TREE — $goal_id"
-echo "────────────────────────────────────────────────────────"
-
-function print_tree() {
-  local pid="$1"
-  local indent="$2"
-  local children
-  children=$(jq -r --arg pid "$pid" '(.goals // [])[] | select(.parent_id == $pid) |
-    [.id, (.status // "open"), (.title // "(no title)")] | @tsv' "$goalsFile" 2>/dev/null)
-  while IFS=$'\t' read -r cid cst ctitle; do
-    [ -z "$cid" ] && continue
-    echo "${indent}[${cst}] ${ctitle} (${cid})"
-    print_tree "$cid" "  ${indent}"
-  done <<< "$children"
-}
-
-# Print root goal
-rootTitle=$(echo "$goalDef" | jq -r '.title // "(no title)"')
-rootStatus=$(echo "$goalDef" | jq -r '.status // "open"')
-echo "[${rootStatus}] ${rootTitle} (${resolvedId})"
-print_tree "$resolvedId" "  "
-```
-
-### projects
-
-```bash
-echo "LINKED PROJECTS — $goal_id"
-echo "────────────────────────────────────────────────────────"
-
-linkedIds=$(echo "$goalDef" | jq -r '(.linked_projects // [])[]')
-if [ -z "$linkedIds" ]; then
-  echo "  No linked projects."
-else
-  while IFS= read -r pid; do
-    [ -z "$pid" ] && continue
-    if [ -f "$projectsFile" ]; then
-      projInfo=$(jq -r --arg id "$pid" '(.projects // [])[] | select(.id == $id) |
-        "  [\(.status // "active")] \(.name // $id) — \(.description // "")"' "$projectsFile" 2>/dev/null)
-      [ -n "$projInfo" ] && echo "$projInfo" || echo "  [$pid] (project not found in projects file)"
-    else
-      echo "  $pid"
-    fi
-  done <<< "$linkedIds"
-fi
-
-echo ""
-echo "Issues referencing this goal:"
-issuesFile=".monomind/orgs/${org_name}-issues.json"
-if [ -f "$issuesFile" ]; then
-  count=$(jq --arg gid "$resolvedId" '[(.issues // [])[] | select(.goal_id == $gid)] | length' "$issuesFile" 2>/dev/null || echo 0)
-  echo "  $count issue(s) linked to this goal."
-fi
-```
-
-### edit
-
-```bash
-[ -z "$field" ] && { echo "ERROR: --field required (title|description|status|priority|parent_id)."; exit 1; }
-[ -z "$value" ] && { echo "ERROR: --value required."; exit 1; }
-
-validFields="title description status priority parent_id"
-echo "$validFields" | tr ' ' '\n' | grep -qx "$field" || {
-  echo "ERROR: Unknown field '$field'. Valid: $validFields"; exit 1
-}
-
-if [ "$field" = "status" ]; then
-  case "$value" in open|in_progress|done|cancelled) : ;; *)
-    echo "ERROR: status must be one of: open, in_progress, done, cancelled"; exit 1 ;;
-  esac
-fi
-if [ "$field" = "priority" ]; then
-  case "$value" in critical|high|medium|low) : ;; *)
-    echo "ERROR: priority must be one of: critical, high, medium, low"; exit 1 ;;
-  esac
-fi
-
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-tmp="${goalsFile}.tmp"
-jq --arg id "$resolvedId" --arg field "$field" --arg val "$value" --arg ts "$ts" \
-  '.goals = [(.goals // [])[] | if .id == $id then .[$field] = $val | .updated_at = $ts else . end]' \
-  "$goalsFile" > "$tmp" && mv "$tmp" "$goalsFile"
-
-echo "Goal '$goal_id' updated: $field = $value"
-```
-
-### add-child
-
-```bash
-[ -z "$child_title" ] && { echo "ERROR: --child-title required."; exit 1; }
-
-childId="goal-$(openssl rand -hex 4 2>/dev/null || python3 -c 'import secrets; print(secrets.token_hex(4))')"
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-
-tmp="${goalsFile}.tmp"
-jq --arg id "$childId" \
-   --arg title "$child_title" \
-   --arg desc "${child_description:-}" \
-   --arg pid "$resolvedId" \
-   --arg ts "$ts" \
-  '.goals += [{"id":$id,"title":$title,
-    "description":(if $desc != "" then $desc else null end),
-    "parent_id":$pid,"status":"open","priority":"medium",
-    "linked_projects":[],"created_at":$ts,"updated_at":$ts}]' \
-  "$goalsFile" > "$tmp" && mv "$tmp" "$goalsFile"
-
-echo "Sub-goal created: $childId"
-echo "  Title:  $child_title"
-echo "  Parent: $goal_id"
-```
-
-### close
-
-```bash
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-tmp="${goalsFile}.tmp"
-jq --arg id "$resolvedId" --arg ts "$ts" \
-  '.goals = [(.goals // [])[] | if .id == $id then .status = "done" | .updated_at = $ts | .closed_at = $ts else . end]' \
-  "$goalsFile" > "$tmp" && mv "$tmp" "$goalsFile"
-echo "Goal '$goal_id' → done."
-```
-
-### reopen
-
-```bash
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-tmp="${goalsFile}.tmp"
-jq --arg id "$resolvedId" --arg ts "$ts" \
-  '.goals = [(.goals // [])[] | if .id == $id then .status = "open" | .updated_at = $ts | .closed_at = null else . end]' \
-  "$goalsFile" > "$tmp" && mv "$tmp" "$goalsFile"
-echo "Goal '$goal_id' → reopened."
-```
-
----
-
-## Step 3 — Return Output
-
-```yaml
-domain: ops
-status: complete
-action: <action>
-org: <org_name>
-goal_id: <goal_id>
-goal_status: <status>
-sub_goals: <N>
-```
-
----
-
-## Step 4 — Brain Write (standalone only)
-
-If `caller` is not "command", follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.