monomind 1.19.0 → 2.0.1

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

@@ -1,170 +0,0 @@
----
-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/.claude/skills/mastermind-skills/search.md

@@ -1,186 +0,0 @@
----
-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/.claude/skills/mastermind-skills/secrets.md

@@ -1,199 +0,0 @@
----
-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`.