@monoes/monomindcli 1.8.0 → 1.9.0

package/.claude/skills/mastermind/runorg.md

@@ -0,0 +1,308 @@
+---
+name: mastermind-runorg
+description: Mastermind runorg — load a saved org definition and start it as a persistent autonomous agent organization. The boss agent coordinates all roles, agents pick up tasks from a shared board, and the org runs until stopped.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Run Org
+
+This skill is invoked by `mastermind:runorg` or directly via `/mastermind:runorg`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `org_name`: name of the org to run (matches a file at `.monomind/orgs/<org_name>.json`)
+- `session_id`: session ID generated by the command
+- `task`: optional override task/goal for this run (if omitted, uses org's stored goal)
+- `caller`: command | master (controls whether brain load/write runs here)
+
+---
+
+## 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 Org Config
+
+Read `.monomind/orgs/<org_name>.json`. If the file does not exist:
+```bash
+orgs=$(ls .monomind/orgs/*.json 2>/dev/null | xargs -I{} basename {} .json)
+if [ -z "$orgs" ]; then
+  echo "No saved orgs found. Run /mastermind:createorg to define one."
+else
+  echo "Available orgs: $orgs"
+fi
+```
+Return `status: blocked` with message: "Org '<org_name>' not found. Run /mastermind:createorg to define it."
+
+Validate the config has at minimum: `name`, `goal`, `roles` (non-empty array), `communication`.
+
+---
+
+## Step 2 — Derive Variables
+
+Before spawning any agents, derive all variables from the loaded config. These are used in Steps 3 and 4.
+
+```
+orgConfig  = parsed JSON from .monomind/orgs/<org_name>.json
+orgName    = orgConfig.name
+goal       = task (if provided) or orgConfig.goal
+sessionId  = provided session_id input
+stopFile   = `.monomind/orgs/.stops/${orgName}.stop`
+memNs      = `org:${orgName}`
+topology   = orgConfig.topology
+checkpointMin = orgConfig.run_config?.checkpoint_interval_min ?? 30
+```
+
+Find the boss role — use filter to detect ambiguity before dereferencing:
+
+```
+rootRoles = orgConfig.roles.filter(r => r.reports_to === null || r.reports_to === undefined)
+```
+
+Abort with `status: blocked` if `rootRoles.length === 0` — message: "Org '<orgName>' has no root role; exactly one role must have reports_to: null."
+
+Abort with `status: blocked` if `rootRoles.length > 1` — message: "Org '<orgName>' has multiple root roles; exactly one must have reports_to: null."
+
+```
+bossRole           = rootRoles[0]
+bossRole_id        = bossRole.id
+bossRole_title     = bossRole.title
+bossRole_agent_type = bossRole.agent_type
+directReports      = orgConfig.roles.filter(r => r.reports_to === bossRole.id)
+runId              = new Date().toISOString()
+```
+
+Also validate that every role has non-empty `id`, `title`, `agent_type`, and `responsibilities` (array). Abort with `status: blocked` listing any malformed role — do this before Step 3 initializes infrastructure.
+
+After the conceptual derivations above, extract them as real shell variables so downstream bash blocks can reference `$orgName`, `$sessionId`, etc.:
+
+```bash
+orgFile=".monomind/orgs/${org_name}.json"
+orgName=$(jq -r '.name' "$orgFile")
+goal="${task:-$(jq -r '.goal' "$orgFile")}"
+sessionId="$session_id"
+stopFile=".monomind/orgs/.stops/${orgName}.stop"
+memNs="org:${orgName}"
+topology=$(jq -r '.topology' "$orgFile")
+checkpointMin=$(jq -r '.run_config.checkpoint_interval_min // 30' "$orgFile")
+bossRole_id=$(jq -r '[.roles[] | select(.reports_to == null)][0].id' "$orgFile")
+bossRole_title=$(jq -r '[.roles[] | select(.reports_to == null)][0].title' "$orgFile")
+bossRole_agent_type=$(jq -r '[.roles[] | select(.reports_to == null)][0].agent_type' "$orgFile")
+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")
+runId=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+```
+
+---
+
+## Step 3 — Initialize Org Infrastructure
+
+**Validate board IDs from org config:**
+
+The board and column IDs were written into the org config by `createorg`. If missing, the org was not created correctly.
+
+```bash
+[ -z "$board_id" ] && { echo "ERROR: org config missing board_id — re-run /mastermind:createorg --name ${orgName} to rebuild the org."; exit 1; }
+[ -z "$todo_col" ]  && { echo "ERROR: org config missing todo_col_id — re-run /mastermind:createorg --name ${orgName}."; exit 1; }
+```
+
+**Create stop-file directory** (boss agent writes here; must exist before it runs):
+```bash
+mkdir -p .monomind/orgs/.stops
+```
+
+**Emit `org:start` to dashboard:**
+```bash
+curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$sessionId" \
+    --arg org "$orgName" \
+    --arg goal "$goal" \
+    '{type:"org:start",session:$session,org:$org,goal:$goal,ts:(now*1000|floor)}')" || true
+```
+
+---
+
+## Step 4 — Spawn Boss Agent
+
+Using the variables derived in Step 2, spawn the boss agent via Task tool:
+
+```javascript
+Task({
+  subagent_type: bossRole.agent_type,
+  description: `You are the ${bossRole.title} of org "${orgName}". You run persistently until stopped.`,
+  run_in_background: true,
+  prompt: `You are the ${bossRole.title} of the autonomous organization "${orgName}".
+
+ORG GOAL: ${goal}
+
+YOUR ROLE: ${bossRole.title}
+YOUR RESPONSIBILITIES: ${bossRole.responsibilities.join('; ')}
+
+YOUR TEAM (direct reports):
+${directReports.map(r => `• ${r.title} (subagent_type="${r.agent_type}") — ${r.responsibilities.join(', ')}`).join('\n')}
+
+FULL COMMUNICATION TOPOLOGY:
+${orgConfig.communication.map(e => `${e.from} → ${e.to} (${e.type})`).join('\n')}
+
+SHARED INFRASTRUCTURE:
+- Task board (monotask): board_id=${board_id}
+  Columns: Todo=${todo_col}  Doing=${doing_col}  Done=${done_col}
+- Memory namespace: ${memNs} (use: npx monomind@latest memory store/search --namespace ${memNs})
+- Dashboard events: POST http://localhost:4242/api/mastermind/event via curl (see below)
+- Session ID for all events: ${sessionId}
+
+TASK BOARD COMMANDS (use these for all task management):
+  # List all unclaimed Todo cards for a specific role (server-side filters — fast):
+  monotask card list ${board_id} --col ${todo_col} --label "role:<role_id>" --json
+
+  # List all unclaimed Todo cards (any role):
+  monotask card list ${board_id} --col ${todo_col} --json | jq '[.[] | select(.labels | index("claimed") | not)]'
+
+  # List all in-progress cards:
+  monotask card list ${board_id} --col ${doing_col} --json
+
+  # List all cards for a role across all columns:
+  monotask card list ${board_id} --label "role:<role_id>" --json
+
+  # Create a new task in Todo (tagged for a specific role):
+  CARD_ID=$(monotask card create ${board_id} ${todo_col} "Task title" --json | jq -r .id)
+  monotask card label add ${board_id} $CARD_ID "role:<role_id>"
+
+  # Break task into subtasks:
+  monotask card subtask add ${board_id} $CARD_ID ${board_id} ${todo_col} "Subtask title" --json
+
+  # Mark a task as blocked by a prerequisite (won't claim until prereq is Done):
+  monotask card prerequisite add ${board_id} $BLOCKED_ID ${board_id} $PREREQ_ID
+
+  # Claim a task (move to Doing + mark claimed):
+  monotask card move ${board_id} $CARD_ID ${doing_col}
+  monotask card label add ${board_id} $CARD_ID "claimed"
+
+  # Complete a task:
+  monotask card move ${board_id} $CARD_ID ${done_col}
+
+STOP DETECTION (check this FIRST in every loop iteration):
+  ls ${stopFile} 2>/dev/null && echo STOP_REQUESTED
+If the file exists: emit org:complete event, clean up with "rm -f ${stopFile}", then exit.
+
+OPERATING LOOP:
+1. Check for stop signal (see above). Exit if found.
+2. List unclaimed Todo cards: monotask card list ${board_id} --col ${todo_col} --json | jq '[.[] | select(.labels | index("claimed") | not)]'
+3. For each Todo card without a "claimed" label, assign to the appropriate role based on its "role:<id>" label. Skip cards whose prerequisites (monotask card prerequisite list) are not yet in the Done column.
+4. Spawn the assigned role agent via Task tool (run_in_background: true) with:
+   - Full role briefing (title, responsibilities, who they report to, memory namespace)
+   - The specific card title and card_id to work on
+   - Move the card to Doing before spawning: monotask card move ${board_id} $CARD_ID ${doing_col}
+   - Add label "claimed" to the card
+   - Report output via: npx monomind@latest memory store --key "${memNs}:report:<card_id>" --namespace "${memNs}"
+   - When complete, move card to Done: monotask card move ${board_id} $CARD_ID ${done_col}
+   - Emit org:agent:online event to dashboard before starting (use curl, see below)
+5. Collect completed results from memory (search "${memNs}:report:")
+6. Synthesize reports, make decisions, create new cards in Todo column based on progress toward goal
+7. Emit org:checkpoint event with progress summary
+8. Wait ${checkpointMin} minutes, then loop back to step 1
+
+AGENT TYPES FOR YOUR TEAM:
+${orgConfig.roles.filter(r => r.id !== bossRole.id).map(r =>
+  `• ${r.title}: subagent_type="${r.agent_type}"`
+).join('\n')}
+
+DASHBOARD EVENTS — emit via curl (NOT WebFetch — WebFetch does not support POST):
+  curl -s -X POST http://localhost:4242/api/mastermind/event \
+    -H "Content-Type: application/json" \
+    -d "$(jq -cn --arg type TYPE --arg session SESSION --arg org ORG '{type:$type,session:$session,org:$org,ts:(now*1000|floor)}')"
+Payloads:
+- org:agent:online → add fields: role, title, agent_type
+- org:comms → add fields: from, to, msg
+- org:checkpoint → add fields: progress, pending_tasks
+- org:complete → no additional fields
+
+START NOW: check for stop signal, assess the board, create initial tasks if none exist, then begin the operating loop.`
+})
+```
+
+---
+
+## Step 5 — Emit Boss Online Event
+
+Emit `org:agent:online` for the boss role (team member events are emitted by the boss itself):
+
+```bash
+curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$sessionId" \
+    --arg org "$orgName" \
+    --arg role "$bossRole_id" \
+    --arg title "$bossRole_title" \
+    --arg agent_type "$bossRole_agent_type" \
+    '{type:"org:agent:online",session:$session,org:$org,role:$role,title:$title,agent_type:$agent_type,ts:(now*1000|floor)}')" || true
+```
+
+(Use the scalar string variables `$bossRole_id`, `$bossRole_title`, `$bossRole_agent_type` derived by extracting fields from `bossRole` before constructing the curl call.)
+
+---
+
+## Step 6 — Report to User
+
+Print the org startup summary:
+
+```
+╔══════════════════════════════════════════════════════════╗
+║  ORG STARTED: <orgName>                                  ║
+║  GOAL: <goal>                                            ║
+║  MODE: persistent daemon                                 ║
+╚══════════════════════════════════════════════════════════╝
+
+ACTIVE ROLES
+────────────
+• [<bossRole.id>] <bossRole.title> → running as <bossRole.agent_type> agent
+• [<each direct report>] <title> → will be spawned by boss on demand
+  ... (all roles from config)
+
+BOARD: <orgName>/org-tasks
+MEMORY: org:<orgName>
+DASHBOARD: http://localhost:4242
+
+To stop: click STOP in the dashboard Orgs panel
+         or run: curl -X POST http://localhost:4242/api/orgs/<orgName>/stop
+```
+
+---
+
+## Step 7 — Return Output Schema
+
+```yaml
+domain: ops
+status: complete
+artifacts: []
+decisions:
+  - what: "Org <orgName> started with <N> roles, boss agent running"
+    why: "Loaded from .monomind/orgs/<orgName>.json"
+    confidence: 0.9
+    outcome: pending
+lessons:
+  - what_worked: "Boss agent spawned and org loop started"
+  - what_didnt: ""
+next_actions:
+  - "Monitor at http://localhost:4242 — Mastermind Orgs panel"
+  - "To stop: click STOP in dashboard or POST to /api/orgs/<orgName>/stop"
+board_url: "monotask://<orgName>/org-tasks"
+run_id: "<runId>"
+```
+
+---
+
+## Step 8 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/.claude/skills/mastermind/sales.md

@@ -0,0 +1,158 @@
+---
+name: mastermind-sales
+description: Mastermind sales domain — outreach sequences, proposals, pipeline management. Spawns a Sales Manager coordinating outbound strategy and proposal writing agents.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Sales Domain
+
+This skill is invoked by `mastermind:master` or directly via `/mastermind:sales`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by master, or loaded standalone via _protocol.md brain load)
+- `prompt`: the sales 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 output, single agent:
+- "Draft a cold email to the CTO of Acme Corp"
+- "Write a one-paragraph executive summary for this proposal"
+→ Use a single Outbound Strategist or Proposal Strategist agent. Skip manager delegation.
+
+**Complex (spawn Sales Manager agent):** Any of these:
+- Full outreach sequence (ICP + targeting + multi-touch sequence)
+- RFP or proposal requiring research + executive summary + pricing
+- Pipeline review and deal strategy across multiple opportunities
+- Account expansion plan
+→ Spawn Sales 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 _protocol.md Brain Load Procedure (namespace: `sales`)
+2. Run intake from _intake.md if prompt is vague
+3. Create or find monotask space `<project_name>`, create board `sales`
+4. Proceed with complexity assessment below
+5. At end: follow _protocol.md Brain Write Procedure (namespace: `sales`)
+
+---
+
+## Complex Execution — Sales Manager Agent
+
+Spawn a Sales Manager agent via Task tool:
+
+```javascript
+Task({
+  subagent_type: "coordinator",
+  description: `You are the Sales Manager for project <project_name>.
+
+CONTEXT: <date> | Project: <project_name> | Spawned by: mastermind:sales
+
+BRAIN CONTEXT:
+<brain_context>
+
+YOUR BOARD: <board_id>
+YOUR GOAL: <prompt>
+
+STEP 1 — PLAN
+Decompose the sales goal into coordinated workstreams. For each workstream, identify:
+- Target segment or specific account
+- Which sales motion applies (outbound, proposal, pipeline review, expansion)
+- Deliverable needed (email sequence, proposal doc, deal strategy, account plan)
+- Dependencies between workstreams (e.g. research before outreach)
+
+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(.name == "Todo" or .name == "Backlog") | .id' | head -1)
+COL_DONE_ID=$(echo "$columns" | jq -r '.[] | select(.name == "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 sales workstream goal]"
+monotask card comment add "$BOARD_ID" "$CARD_ID" "CONTEXT: <date> | Project: <project_name> | Created by: Sales Manager
+BRAIN MEMORY: [paste most relevant 3-5 brain context excerpts]
+SCOPE: [target accounts, segments, deal stage, decision makers]
+CONSTRAINTS: [brand voice, compliance, do-not-contact lists, pricing floors]
+SUCCESS CRITERIA:
+- [ ] [checkable item]
+AGENT: [Outbound Strategist | Proposal Strategist | Deal Strategist | Account Strategist | researcher]
+SWARM: hierarchical 4 raft
+DEPENDENCIES: [task IDs or \"none\"]
+OUTPUT FORMAT: unified output schema"
+```
+
+STEP 3 — EXECUTE
+Spawn one Task agent per workstream:
+- Outbound and prospecting: subagent_type "Outbound Strategist"
+- Proposal writing: subagent_type "Proposal Strategist"
+- Deal qualification: subagent_type "Deal Strategist"
+- Account expansion: subagent_type "Account Strategist"
+- Competitive research: subagent_type "researcher"
+
+Also run /monomind:do --board <board_id> to track execution.
+
+STEP 4 — COLLECT AND RETURN
+Collect all agent outputs. Return to caller:
+
+domain: sales
+status: complete | partial | blocked
+artifacts:
+  - path: [email sequences, proposal documents, account plans]
+    type: copy
+decisions:
+  - what: [ICP definition, messaging strategy, deal approach]
+    why: [reasoning]
+    confidence: [0.0-1.0]
+    outcome: pending | shipped
+lessons:
+  - what_worked: [which approaches resonated or were most efficient]
+  - what_didnt: [what needed more personalization or research]
+next_actions:
+  - [e.g. "run mastermind:research to validate ICP assumptions"]
+  - [e.g. "run mastermind:content to produce case studies for proposals"]
+board_url: monotask://<project_name>/sales
+run_id: <ISO8601-timestamp>`,
+  run_in_background: true
+})
+```
+
+---
+
+## Simple Execution
+
+For simple tasks (single agent, single output):
+
+1. Spawn one Task agent with the sales 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 outreach campaign | coordinator + outbound + researcher | hierarchical 4 raft specialized |
+| Proposal / RFP response | coordinator + proposal writer | hierarchical 4 raft specialized |
+| Deal strategy | Deal Strategist | hierarchical 3 raft specialized |
+| Account expansion plan | Account Strategist | hierarchical 3 raft specialized |
+| Single email or cold message | Outbound Strategist | single agent |