monomind 1.16.6 → 1.16.8

package/packages/@monomind/cli/.claude/skills/mastermind/sales.md

@@ -0,0 +1,170 @@
+---
+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. Follow _protocol.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 "sales" --json | jq -r '.id // empty')
+   [ -z "$board_id" ] && { echo "ERROR: Failed to create sales 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 _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(.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 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 /mastermind: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 |

package/packages/@monomind/cli/.claude/skills/mastermind/search.md

@@ -0,0 +1,186 @@
+---
+name: mastermind-search
+description: Mastermind search — fuzzy cross-org search across tasks, goals, agents, approvals, routines, projects, and activity log. Returns ranked results with org context.
+type: domain-skill
+default_mode: auto
+---
+
+# Mastermind Search
+
+This skill is invoked by `mastermind:search` or directly via `/mastermind:search`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `query`: search term (required)
+- `org_name`: filter to a specific org (optional — searches all orgs if omitted)
+- `scope`: all | tasks | goals | agents | approvals | routines | projects | activity (default: all)
+- `limit`: max results per category (default: 10)
+- `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 — Resolve 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
+[ -z "$orgs" ] && { echo "No orgs found. Run /mastermind:createorg first."; exit 0; }
+```
+
+---
+
+## Step 2 — Search All Scopes
+
+```bash
+query_lower=$(echo "$query" | tr '[:upper:]' '[:lower:]')
+limit="${limit:-10}"
+total_hits=0
+
+echo "SEARCH: \"${query}\""
+echo "════════════════════════════════════════════════"
+echo ""
+
+for org in $orgs; do
+  orgFile=".monomind/orgs/${org}.json"
+  [ ! -f "$orgFile" ] && continue
+
+  org_hits=0
+
+  # ── Agents ────────────────────────────────────────
+  if [ "$scope" = "all" ] || [ "$scope" = "agents" ]; then
+    hits=$(jq -r --arg q "$query_lower" \
+      '(.roles // [])[] | select((.id + " " + .title + " " + (.responsibilities // [] | join(" "))) | ascii_downcase | test($q)) |
+       "[AGENT] \(.id): \(.title)  type=\(.agent_type)"' \
+      "$orgFile" 2>/dev/null | head -"$limit")
+    if [ -n "$hits" ]; then
+      echo "── $org / agents ──"
+      echo "$hits"
+      echo ""
+      org_hits=$((org_hits + $(echo "$hits" | wc -l)))
+    fi
+  fi
+
+  # ── Goals ─────────────────────────────────────────
+  goalsFile=".monomind/orgs/${org}-goals.json"
+  if [ -f "$goalsFile" ] && { [ "$scope" = "all" ] || [ "$scope" = "goals" ]; }; then
+    hits=$(jq -r --arg q "$query_lower" \
+      '(.goals // [])[] | select((.title + " " + (.description // "") + " " + (.status // "")) | ascii_downcase | test($q)) |
+       "[GOAL] [\(.id)] \(.title)  status=\(.status // "open")"' \
+      "$goalsFile" 2>/dev/null | head -"$limit")
+    if [ -n "$hits" ]; then
+      echo "── $org / goals ──"
+      echo "$hits"
+      echo ""
+      org_hits=$((org_hits + $(echo "$hits" | wc -l)))
+    fi
+  fi
+
+  # ── Routines ──────────────────────────────────────
+  routinesFile=".monomind/orgs/${org}-routines.json"
+  if [ -f "$routinesFile" ] && { [ "$scope" = "all" ] || [ "$scope" = "routines" ]; }; then
+    hits=$(jq -r --arg q "$query_lower" \
+      '(.routines // [])[] | select((.name + " " + (.description // "") + " " + (.schedule // "")) | ascii_downcase | test($q)) |
+       "[ROUTINE] \(.name)  schedule=\(.schedule // "-")"' \
+      "$routinesFile" 2>/dev/null | head -"$limit")
+    if [ -n "$hits" ]; then
+      echo "── $org / routines ──"
+      echo "$hits"
+      echo ""
+      org_hits=$((org_hits + $(echo "$hits" | wc -l)))
+    fi
+  fi
+
+  # ── Approvals ─────────────────────────────────────
+  approvalsFile=".monomind/orgs/${org}-approvals.json"
+  if [ -f "$approvalsFile" ] && { [ "$scope" = "all" ] || [ "$scope" = "approvals" ]; }; then
+    hits=$(jq -r --arg q "$query_lower" \
+      '(.approvals // [])[] | select((.title + " " + (.action // "") + " " + (.agent_id // "")) | ascii_downcase | test($q)) |
+       "[APPROVAL] [\(.id)] \(.agent_id): \(.title)  status=\(.status)"' \
+      "$approvalsFile" 2>/dev/null | head -"$limit")
+    if [ -n "$hits" ]; then
+      echo "── $org / approvals ──"
+      echo "$hits"
+      echo ""
+      org_hits=$((org_hits + $(echo "$hits" | wc -l)))
+    fi
+  fi
+
+  # ── Projects ──────────────────────────────────────
+  projectsFile=".monomind/orgs/${org}-projects.json"
+  if [ -f "$projectsFile" ] && { [ "$scope" = "all" ] || [ "$scope" = "projects" ]; }; then
+    hits=$(jq -r --arg q "$query_lower" \
+      '(.projects // [])[] | select((.name + " " + (.description // "") + " " + (.lead // "")) | ascii_downcase | test($q)) |
+       "[PROJECT] \(.name)  status=\(.status // "active")  lead=\(.lead // "-")"' \
+      "$projectsFile" 2>/dev/null | head -"$limit")
+    if [ -n "$hits" ]; then
+      echo "── $org / projects ──"
+      echo "$hits"
+      echo ""
+      org_hits=$((org_hits + $(echo "$hits" | wc -l)))
+    fi
+  fi
+
+  # ── Activity log ──────────────────────────────────
+  if [ "$scope" = "all" ] || [ "$scope" = "activity" ]; then
+    eventsFile="data/mastermind-events.jsonl"
+    if [ -f "$eventsFile" ]; then
+      hits=$(grep "\"org\":\"$org\"" "$eventsFile" 2>/dev/null | \
+        jq -r --arg q "$query_lower" \
+          'select((tostring | ascii_downcase | test($q))) |
+           "[EVENT] \(.type)  org=\(.org)  \(if .task then "task=\(.task)" elif .role then "role=\(.role)" else "" end)"' \
+        2>/dev/null | tail -"$limit")
+      if [ -n "$hits" ]; then
+        echo "── $org / activity ──"
+        echo "$hits"
+        echo ""
+        org_hits=$((org_hits + $(echo "$hits" | wc -l)))
+      fi
+    fi
+  fi
+
+  total_hits=$((total_hits + org_hits))
+done
+
+if [ "$total_hits" -eq 0 ]; then
+  echo "  No results found for \"${query}\""
+  echo ""
+  echo "  Tips:"
+  echo "  • Try a shorter or more general query"
+  echo "  • Use --scope to narrow: tasks, goals, agents, approvals, routines, projects, activity"
+  echo "  • Use --org to limit to a specific org"
+fi
+
+echo "════════════════════════════════════════════════"
+echo "Found: ${total_hits} result(s)"
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+query: <query>
+scope: <scope>
+orgs_searched: <N>
+total_hits: <N>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/packages/@monomind/cli/.claude/skills/mastermind/secrets.md

@@ -0,0 +1,199 @@
+---
+name: mastermind-secrets
+description: Mastermind secrets — manage org-scoped API keys and secrets consumed by agents. Store, rotate, list, and audit secrets without exposing values in logs or state files.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Secrets
+
+This skill is invoked by `mastermind:secrets` or directly via `/mastermind:secrets`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block
+- `org_name`: org to manage secrets for
+- `action`: list | set | rotate | revoke | audit
+- `secret_name`: name/key of the secret (e.g. `OPENAI_API_KEY`, `SLACK_WEBHOOK`)
+- `secret_value`: value to store (only ever passed as env var reference, NEVER hardcoded)
+- `provider`: local | env | vault (default: local)
+- `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`.
+
+---
+
+## SECURITY RULES (always enforced)
+
+- NEVER print secret values to stdout
+- NEVER store secret values in state files (store only masked references: `sk-ant-***...***`)
+- NEVER commit secrets to git
+- Secrets passed as `secret_value` MUST come from env vars (`$MY_KEY`), NOT inline strings
+
+---
+
+## Step 1 — Load Secrets Registry
+
+The secrets registry stores **metadata only** (name, provider, masked hint, rotation date):
+
+```bash
+secretsFile=".monomind/orgs/${org_name}-secrets.json"
+[ ! -f "$secretsFile" ] && echo '{"secrets":[]}' > "$secretsFile"
+```
+
+Actual secret values live in:
+- `local`: `.monomind/orgs/.secrets/<org_name>/<name>` (chmod 600, gitignored)
+- `env`: environment variable `ORG_<ORG_NAME_UPPER>_<SECRET_NAME_UPPER>`
+
+---
+
+## Step 2 — Execute Action
+
+### list (default)
+
+Show all registered secrets for this org (metadata only, masked values):
+
+```bash
+jq -r '
+  (.secrets // [])[] |
+  "[\(.name)]  provider=\(.provider)  hint=\(.masked_hint // "***")  set=\(.set_at // "unknown")  rotated=\(.rotated_at // "never")"
+' "$secretsFile" 2>/dev/null || echo "No secrets registered."
+```
+
+Render as:
+```
+SECRETS — org: <org_name>
+──────────────────────────────────────────────
+NAME                  PROVIDER   VALUE HINT       SET               ROTATED
+ANTHROPIC_API_KEY     local      sk-ant-***...    2 days ago        —
+SLACK_WEBHOOK         env        https://hooks    1 week ago        —
+GITHUB_TOKEN          local      ghp_***...       3 days ago        1 day ago
+```
+
+### set
+
+Store a secret value. Always source from env var:
+
+```bash
+# Validate secret_name (alphanumeric + underscore only)
+echo "$secret_name" | grep -qE '^[A-Z][A-Z0-9_]{0,63}$' || { echo "ERROR: secret_name must be uppercase letters, digits, underscores only."; exit 1; }
+
+# Create secure storage dir
+secretDir=".monomind/orgs/.secrets/${org_name}"
+mkdir -p "$secretDir"
+chmod 700 "$secretDir"
+
+# Write value from env var reference — NEVER inline
+if [ -z "${secret_value}" ]; then
+  echo "ERROR: Pass the secret value as an env var: secret_value=\$MY_VAR /mastermind:secrets --action set"
+  exit 1
+fi
+
+secretFile="${secretDir}/${secret_name}"
+printf '%s' "$secret_value" > "$secretFile"
+chmod 600 "$secretFile"
+
+# Store masked hint (first 6 chars + ***)
+hint="${secret_value:0:6}***...${secret_value: -3}"
+
+# Register in secrets metadata
+tmp="${secretsFile}.tmp"
+jq --arg name "$secret_name" \
+   --arg provider "${provider:-local}" \
+   --arg hint "$hint" \
+   --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+   '.secrets = [(.secrets // [])[] | select(.name != $name)] +
+    [{"name":$name,"provider":$provider,"masked_hint":$hint,"set_at":$ts}]' \
+   "$secretsFile" > "$tmp" && mv "$tmp" "$secretsFile"
+
+echo "Secret $secret_name stored (provider: ${provider:-local})"
+```
+
+Ensure `.monomind/orgs/.secrets/` is in `.gitignore`:
+```bash
+grep -q '.monomind/orgs/.secrets' .gitignore 2>/dev/null || echo '.monomind/orgs/.secrets/' >> .gitignore
+```
+
+### rotate
+
+Generate a new value from env var and update:
+
+```bash
+# Same as set but also records rotated_at
+tmp="${secretsFile}.tmp"
+jq --arg name "$secret_name" --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+   '.secrets = [(.secrets // [])[] | if .name == $name then .rotated_at = $ts | .set_at = $ts else . end]' \
+   "$secretsFile" > "$tmp" && mv "$tmp" "$secretsFile"
+# Then re-run the set logic above with new value
+```
+
+### revoke
+
+Remove secret value and registry entry:
+
+```bash
+rm -f ".monomind/orgs/.secrets/${org_name}/${secret_name}"
+tmp="${secretsFile}.tmp"
+jq --arg name "$secret_name" '.secrets = [(.secrets // [])[] | select(.name != $name)]' \
+   "$secretsFile" > "$tmp" && mv "$tmp" "$secretsFile"
+echo "Secret $secret_name revoked."
+```
+
+### audit
+
+Show which agents reference each secret in their adapter_config or responsibilities:
+
+```bash
+orgFile=".monomind/orgs/${org_name}.json"
+echo "=== SECRET USAGE AUDIT — org: $org_name ==="
+jq -r '(.roles // [])[] | "\(.id): \((.responsibilities // []) | join(", "))"' "$orgFile" | \
+  while IFS=: read -r role resp; do
+    refs=$(jq -r '(.secrets // [])[].name' "$secretsFile" | while read -r sname; do
+      echo "$resp" | grep -q "$sname" && echo "    → $sname"
+    done)
+    [ -n "$refs" ] && echo "$role$refs"
+  done
+echo "(Audit checks responsibilities text only — review agent prompts manually for additional references)"
+```
+
+---
+
+## How Agents Access Secrets
+
+Agents spawned by the boss should read secrets via:
+
+```bash
+# Read from local storage (not env):
+secret=$(cat ".monomind/orgs/.secrets/${orgName}/${SECRET_NAME}" 2>/dev/null)
+[ -z "$secret" ] && secret="${!SECRET_NAME}"  # Fallback to env var
+
+# Use in API calls:
+curl -H "Authorization: Bearer $secret" ...
+```
+
+Never store secret values in memory namespace or state files.
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org: <org_name>
+secret_name: <name if applicable>
+secrets_count: <N>
+```
+
+---
+
+## Step 4 — Brain Write (standalone only)
+
+If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.