@monoes/monomindcli 2.9.7 → 2.9.9

package/.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/.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/.claude/skills/mastermind-heartbeatv1/SKILL.md

@@ -1,167 +0,0 @@
----
-name: mastermind-heartbeatv1
-description: "LEGACY-ORG-V1 (2026-07): v2: send the role a chat message from the dashboard, or inspect with `monomind org logs <name>` — no skill needed. Mastermind heartbeatv1 — trigger a manual heartbeat for a specific agent in a running v1 (prompt-orchestrated) org. The agent wakes, checks its task queue, executes pending work, and reports back. Reach it only via `/mastermind:heartbeatv1`."
-type: domain-skill
-default_mode: auto
----
-
-# Mastermind Heartbeat (v1, legacy)
-
-> **LEGACY-ORG-V1 — manual task-board wake-up for prompt-orchestrated v1 orgs. Reach it only via `/mastermind:heartbeatv1`.**
-> v2 roles run as live SDK sessions with no poll/wake cycle to trigger — send the role a chat message from the dashboard, or inspect activity with `monomind org logs <name>`. This skill remains only for orgs not yet migrated off the v1 `board_id`/`topology` config shape.
-
-This skill is invoked by `mastermind:heartbeatv1` or directly via `/mastermind:heartbeatv1`.
-
----
-
-## Inputs
-
-- `brain_context`: BRAIN CONTEXT block
-- `org_name`: org the agent belongs to
-- `agent_id`: role id of the agent to wake (e.g. `content-writer`)
-- `context`: optional additional context/instructions to pass to the agent during this heartbeat
-- `source`: timer | on_demand | assignment | automation (default: on_demand)
-- `timeout_min`: minutes to wait for completion (default: 10)
-- `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 Org Config
-
-```bash
-orgFile=".monomind/orgs/${org_name}.json"
-stateFile=".monomind/orgs/${org_name}-state.json"
-
-[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found. Run /mastermind:createorg first."; exit 1; }
-
-board_id=$(jq -r '.board_id // empty' "$orgFile")
-todo_col=$(jq -r '.todo_col_id // empty' "$orgFile")
-doing_col=$(jq -r '.doing_col_id // empty' "$orgFile")
-done_col=$(jq -r '.done_col_id // empty' "$orgFile")
-memNs="org:${org_name}"
-```
-
----
-
-## Step 2 — Validate Agent
-
-```bash
-agentConfig=$(jq --arg id "$agent_id" '(.roles // [])[] | select(.id == $id)' "$orgFile")
-[ -z "$agentConfig" ] && { echo "ERROR: Agent '$agent_id' not found in org '$org_name'."; exit 1; }
-
-agentTitle=$(echo "$agentConfig" | jq -r '.title')
-agentType=$(echo "$agentConfig" | jq -r '.agent_type')
-agentResp=$(echo "$agentConfig" | jq -r '.responsibilities | join("; ")')
-reportsTo=$(echo "$agentConfig" | jq -r '.reports_to // "none"')
-```
-
----
-
-## Step 3 — Update State and Emit heartbeat:start
-
-```bash
-[ ! -f "$stateFile" ] && echo '{"agents":{}}' > "$stateFile"
-tmp="${stateFile}.tmp"
-jq --arg id "$agent_id" --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" --arg source "${source:-on_demand}" \
-   '.agents[$id].last_heartbeat = $ts | .agents[$id].status = "running" | .agents[$id].heartbeat_source = $source' \
-   "$stateFile" > "$tmp" && mv "$tmp" "$stateFile"
-
-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" \
-    --arg role "$agent_id" \
-    --arg title "$agentTitle" \
-    --arg source "${source:-on_demand}" \
-    '{type:"org:heartbeat:start",org:$org,role:$role,title:$title,source:$source,ts:(now*1000|floor)}')" || true
-```
-
----
-
-## Step 4 — Spawn Agent for One Heartbeat Cycle
-
-```javascript
-Task({
-  subagent_type: agentType,
-  description: `Heartbeat for ${agentTitle} in org "${org_name}"`,
-  run_in_background: false,
-  prompt: `You are ${agentTitle} in the autonomous organization "${org_name}".
-
-This is a HEARTBEAT CYCLE — a single work session triggered ${source || "on_demand"}.
-
-YOUR ROLE: ${agentTitle}
-YOUR RESPONSIBILITIES: ${agentResp}
-REPORTS TO: ${reportsTo}
-MEMORY NAMESPACE: ${memNs}
-
-${context ? `CONTEXT / INSTRUCTIONS FOR THIS HEARTBEAT:\n${context}\n\n` : ""}
-
-TASK BOARD:
-- board_id: ${board_id}
-- Todo column: ${todo_col}
-- Doing column: ${doing_col}
-- Done column: ${done_col}
-
-HEARTBEAT PROCEDURE:
-1. Check your task queue — unclaimed cards with "role:${agent_id}" label in Todo:
-   monotask card list ${board_id} --col ${todo_col} --json | jq '[.[] | select((.labels // []) | index("role:${agent_id}")) | select((.labels // []) | index("claimed") | not)]'
-
-2. For each unclaimed task:
-   a. Move to Doing: monotask card move ${board_id} $CARD_ID ${doing_col}
-   b. Add "claimed" label: monotask card label add ${board_id} $CARD_ID "claimed"
-   c. Execute the work described in the task title
-   d. Store output: npx monomind@latest memory store --key "${memNs}:output:${agent_id}:$CARD_ID" --namespace "${memNs}" --value "<your output>"
-   e. Move to Done: monotask card move ${board_id} $CARD_ID ${done_col}
-
-3. If no tasks, check memory for any pending instructions:
-   npx monomind@latest memory search --query "instruction ${agent_id}" --namespace "${memNs}"
-
-4. Report completion — emit heartbeat:complete event:
-   CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.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}" --arg role "${agent_id}" --arg title "${agentTitle}" \
-       '{type:"org:heartbeat:complete",org:$org,role:$role,title:$title,ts:(now*1000|floor)}')" || true
-
-Complete your tasks then exit. This is a single heartbeat cycle, not a persistent loop.`
-})
-```
-
----
-
-## Step 5 — Update State After Completion
-
-```bash
-tmp="${stateFile}.tmp"
-jq --arg id "$agent_id" --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-   '.agents[$id].status = "idle" | .agents[$id].last_heartbeat_complete = $ts' \
-   "$stateFile" > "$tmp" && mv "$tmp" "$stateFile"
-```
-
----
-
-## Step 6 — Return Output
-
-```yaml
-domain: ops
-status: complete
-org: <org_name>
-agent_id: <agent_id>
-agent_title: <agentTitle>
-heartbeat_source: <source>
-```
-
-Print: "Heartbeat complete for <agentTitle>. Check outputs with: npx monomind@latest memory search --namespace org:<org_name>"
-
----
-
-## Step 7 — Brain Write (standalone only)
-
-If `caller` is not "command", follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.