monomind 1.16.6 → 1.16.7

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

@@ -0,0 +1,333 @@
+---
+name: mastermind-export
+description: Mastermind export — full org portability. Export an org to a compressed archive (tar.gz or zip) with file tree selection, and import from an archive with collision strategy and adapter override. Mirrors Paperclip's CompanyExport/CompanyImport pages.
+type: domain-skill
+default_mode: confirm
+---
+
+# Mastermind Export
+
+This skill is invoked by `mastermind:export` or directly via `/mastermind:export`.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
+- `org_name`: org to export/import (required)
+- `action`: export | import | preview | list-archives
+- `output_path`: destination path for exported archive (optional, default: `.monomind/exports/<org>-<ts>.tar.gz`)
+- `input_path`: path to archive file to import (required for import)
+- `collision_strategy`: merge | overwrite | skip (default: merge — for import)
+- `adapter_override`: adapter type to substitute during import (optional: claude-local | gemini-local | codex-local)
+- `include`: comma-separated sections to include (config,goals,routines,projects,members,adapters,secrets-refs,activity — default: all except secrets-refs)
+- `dry_run`: true | false — for import, preview changes without writing (default false)
+- `caller`: command | master
+
+---
+
+## Sections Available for Export
+
+| Section | Files Included | Default |
+|---------|---------------|---------|
+| `config` | `<org>.json` | ✓ |
+| `goals` | `<org>-goals.json` | ✓ |
+| `routines` | `<org>-routines.json` | ✓ |
+| `projects` | `<org>-projects.json` | ✓ |
+| `issues` | `<org>-issues.json` | ✓ |
+| `members` | `<org>-members.json` | ✓ |
+| `adapters` | `<org>-adapters.json` | ✓ |
+| `environments` | `<org>-environments.json` | ✓ |
+| `workspaces` | `<org>-workspaces.json` | ✓ |
+| `threads` | `<org>-threads.json` | ✓ |
+| `budgets` | `<org>-budgets.json` | ✓ |
+| `activity` | `<org>-activity.jsonl` (last 500 events) | ✓ |
+| `secrets-refs` | secret reference names only (NO values) | opt-in |
+
+**SECURITY:** Secret *values* are NEVER exported. Only masked reference names may be included if `secrets-refs` is explicitly listed in `include`.
+
+## Collision Strategies (import)
+
+| Strategy | Behavior |
+|----------|----------|
+| `merge` | New records added; existing records with same ID kept as-is |
+| `overwrite` | New records replace existing ones with same ID |
+| `skip` | Skip entire section if any file already exists in org |
+
+---
+
+## 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 — Validate Org
+
+```bash
+orgFile=".monomind/orgs/${org_name}.json"
+[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
+
+exportsDir=".monomind/exports"
+mkdir -p "$exportsDir"
+ts=$(date -u +%Y%m%dT%H%M%SZ)
+defaultOutput="${exportsDir}/${org_name}-${ts}.tar.gz"
+outputPath="${output_path:-$defaultOutput}"
+```
+
+---
+
+## Step 2 — Execute Action
+
+### preview
+
+Show what would be included in an export without writing anything:
+
+```bash
+echo "EXPORT PREVIEW — org: $org_name"
+echo "────────────────────────────────────────────────────────"
+
+allSections="config goals routines projects issues members adapters environments workspaces threads budgets activity"
+includeSections="${include:-$allSections}"
+
+for section in $allSections; do
+  echo "$includeSections" | grep -qw "$section" || continue
+  case "$section" in
+    config)      srcFile=".monomind/orgs/${org_name}.json" ;;
+    goals)       srcFile=".monomind/orgs/${org_name}-goals.json" ;;
+    routines)    srcFile=".monomind/orgs/${org_name}-routines.json" ;;
+    projects)    srcFile=".monomind/orgs/${org_name}-projects.json" ;;
+    issues)      srcFile=".monomind/orgs/${org_name}-issues.json" ;;
+    members)     srcFile=".monomind/orgs/${org_name}-members.json" ;;
+    adapters)    srcFile=".monomind/orgs/${org_name}-adapters.json" ;;
+    environments) srcFile=".monomind/orgs/${org_name}-environments.json" ;;
+    workspaces)  srcFile=".monomind/orgs/${org_name}-workspaces.json" ;;
+    threads)     srcFile=".monomind/orgs/${org_name}-threads.json" ;;
+    budgets)     srcFile=".monomind/orgs/${org_name}-budgets.json" ;;
+    activity)    srcFile=".monomind/orgs/${org_name}-activity.jsonl" ;;
+    secrets-refs) srcFile=".monomind/orgs/.secrets/${org_name}/" ;;
+  esac
+  if [ -f "$srcFile" ] || [ -d "$srcFile" ]; then
+    size=$(du -sh "$srcFile" 2>/dev/null | cut -f1 || echo "?")
+    echo "  ✓ $section  ($srcFile)  [$size]"
+  else
+    echo "  - $section  ($srcFile)  [not found — will be skipped]"
+  fi
+done
+
+echo ""
+echo "Output would be: $outputPath"
+echo "Run with --action export to proceed."
+```
+
+### export
+
+```bash
+echo "Exporting org '$org_name'…"
+
+allSections="config goals routines projects issues members adapters environments workspaces threads budgets activity"
+includeSections="${include:-$allSections}"
+
+# Build list of files to include
+tmpDir=$(mktemp -d)
+orgExportDir="${tmpDir}/${org_name}"
+mkdir -p "$orgExportDir"
+
+fileCount=0
+for section in $allSections; do
+  echo "$includeSections" | grep -qw "$section" || continue
+  case "$section" in
+    config)       srcFile=".monomind/orgs/${org_name}.json" ; dstName="${org_name}.json" ;;
+    goals)        srcFile=".monomind/orgs/${org_name}-goals.json" ; dstName="${org_name}-goals.json" ;;
+    routines)     srcFile=".monomind/orgs/${org_name}-routines.json" ; dstName="${org_name}-routines.json" ;;
+    projects)     srcFile=".monomind/orgs/${org_name}-projects.json" ; dstName="${org_name}-projects.json" ;;
+    issues)       srcFile=".monomind/orgs/${org_name}-issues.json" ; dstName="${org_name}-issues.json" ;;
+    members)      srcFile=".monomind/orgs/${org_name}-members.json" ; dstName="${org_name}-members.json" ;;
+    adapters)     srcFile=".monomind/orgs/${org_name}-adapters.json" ; dstName="${org_name}-adapters.json" ;;
+    environments) srcFile=".monomind/orgs/${org_name}-environments.json" ; dstName="${org_name}-environments.json" ;;
+    workspaces)   srcFile=".monomind/orgs/${org_name}-workspaces.json" ; dstName="${org_name}-workspaces.json" ;;
+    threads)      srcFile=".monomind/orgs/${org_name}-threads.json" ; dstName="${org_name}-threads.json" ;;
+    budgets)      srcFile=".monomind/orgs/${org_name}-budgets.json" ; dstName="${org_name}-budgets.json" ;;
+    activity)     srcFile=".monomind/orgs/${org_name}-activity.jsonl" ; dstName="${org_name}-activity.jsonl" ;;
+    secrets-refs)
+      # Export ONLY secret reference names — NO values
+      secretsDir=".monomind/orgs/.secrets/${org_name}"
+      if [ -d "$secretsDir" ]; then
+        refsList=$(ls "$secretsDir" 2>/dev/null | jq -Rsc 'split("\n") | map(select(. != ""))')
+        echo "{\"secret_refs\":$refsList,\"note\":\"values_not_exported\"}" > "${orgExportDir}/${org_name}-secret-refs.json"
+        echo "  ✓ secrets-refs (reference names only)"
+        fileCount=$((fileCount + 1))
+      fi
+      continue ;;
+  esac
+  if [ -f "$srcFile" ]; then
+    # For environments: strip key material before including
+    if [ "$section" = "environments" ]; then
+      jq '.environments = [(.environments // [])[] | del(.key_material,.private_key,.ssh_key,.password)]' \
+        "$srcFile" > "${orgExportDir}/${dstName}"
+    elif [ "$section" = "activity" ]; then
+      # Only last 500 events
+      tail -500 "$srcFile" > "${orgExportDir}/${dstName}"
+    else
+      cp "$srcFile" "${orgExportDir}/${dstName}"
+    fi
+    echo "  ✓ $section"
+    fileCount=$((fileCount + 1))
+  else
+    echo "  - $section (skipped — file not found)"
+  fi
+done
+
+# Write manifest
+jq -cn \
+  --arg org "$org_name" \
+  --arg ts "$ts" \
+  --arg sections "$includeSections" \
+  --argjson files "$fileCount" \
+  '{"org":$org,"exported_at":$ts,"sections":($sections|split(" ")),"file_count":$files,"version":"1.0"}' \
+  > "${orgExportDir}/manifest.json"
+
+# Create archive
+tar -czf "$outputPath" -C "$tmpDir" "$org_name" 2>/dev/null
+rm -rf "$tmpDir"
+
+echo ""
+echo "Export complete: $outputPath"
+echo "  Files: $fileCount  |  Sections: $includeSections"
+echo "  Size: $(du -sh "$outputPath" 2>/dev/null | cut -f1)"
+```
+
+### import
+
+```bash
+[ -z "$input_path" ] && { echo "ERROR: --input-path required."; exit 1; }
+[ ! -f "$input_path" ] && { echo "ERROR: Archive not found: $input_path"; exit 1; }
+
+collision="${collision_strategy:-merge}"
+case "$collision" in merge|overwrite|skip) : ;; *)
+  echo "ERROR: --collision-strategy must be merge, overwrite, or skip"; exit 1 ;;
+esac
+
+dryRun="${dry_run:-false}"
+[ "$dryRun" = "true" ] && echo "DRY RUN — no changes will be written."
+
+echo "IMPORT — org: $org_name"
+echo "Collision strategy: $collision"
+[ -n "$adapter_override" ] && echo "Adapter override: $adapter_override"
+echo "────────────────────────────────────────────────────────"
+
+# Extract archive to temp dir
+tmpDir=$(mktemp -d)
+tar -xzf "$input_path" -C "$tmpDir" 2>/dev/null || { echo "ERROR: Failed to extract archive."; rm -rf "$tmpDir"; exit 1; }
+
+# Find org dir in archive
+archiveOrgDir=$(find "$tmpDir" -name "manifest.json" -maxdepth 3 | head -1 | xargs dirname 2>/dev/null)
+[ -z "$archiveOrgDir" ] && { echo "ERROR: No manifest.json found in archive. Invalid export?"; rm -rf "$tmpDir"; exit 1; }
+
+archiveOrg=$(jq -r '.org // ""' "${archiveOrgDir}/manifest.json")
+echo "Archive org: $archiveOrg → importing as: $org_name"
+echo ""
+
+imported=0
+skipped=0
+for srcFile in "${archiveOrgDir}"/*.json "${archiveOrgDir}"/*.jsonl; do
+  [ -f "$srcFile" ] || continue
+  # Rewrite filename for target org name
+  dstName=$(basename "$srcFile" | sed "s/^${archiveOrg}/${org_name}/")
+  dstPath=".monomind/orgs/${dstName}"
+
+  # Skip manifest
+  [[ "$dstName" == "manifest.json" ]] && continue
+
+  # Skip secret refs — never auto-import
+  [[ "$dstName" == *secret-refs* ]] && echo "  SKIP: secret refs (never auto-imported)" && continue
+
+  # Apply adapter override
+  if [ -n "$adapter_override" ] && [[ "$dstName" == *-adapters.json ]]; then
+    echo "  OVERRIDE: applying adapter_override=$adapter_override to adapters file"
+  fi
+
+  if [ -f "$dstPath" ]; then
+    case "$collision" in
+      skip)
+        echo "  SKIP: $dstName (exists, strategy=skip)"
+        skipped=$((skipped + 1))
+        continue ;;
+      merge)
+        echo "  MERGE: $dstName"
+        if [ "$dryRun" = "false" ]; then
+          # JSON files: merge arrays; jsonl files: append deduplicated
+          if [[ "$dstPath" == *.jsonl ]]; then
+            cat "$srcFile" >> "$dstPath"
+          else
+            # Merge: combine top-level arrays from both files
+            python3 -c "
+import json, sys
+with open('$dstPath') as f: existing = json.load(f)
+with open('$srcFile') as f: incoming = json.load(f)
+for k, v in incoming.items():
+    if isinstance(v, list) and isinstance(existing.get(k), list):
+        existIds = {i.get('id') for i in existing[k] if isinstance(i,dict)}
+        existing[k] += [i for i in v if isinstance(i,dict) and i.get('id') not in existIds]
+    elif k not in existing:
+        existing[k] = v
+with open('$dstPath', 'w') as f: json.dump(existing, f, indent=2)
+" 2>/dev/null || cp "$srcFile" "$dstPath"
+          fi
+        fi ;;
+      overwrite)
+        echo "  OVERWRITE: $dstName"
+        [ "$dryRun" = "false" ] && cp "$srcFile" "$dstPath" ;;
+    esac
+  else
+    echo "  CREATE: $dstName (new)"
+    [ "$dryRun" = "false" ] && cp "$srcFile" "$dstPath"
+  fi
+  imported=$((imported + 1))
+done
+
+rm -rf "$tmpDir"
+echo ""
+[ "$dryRun" = "true" ] && echo "DRY RUN complete — $imported file(s) would be imported, $skipped skipped." \
+  || echo "Import complete — $imported file(s) imported, $skipped skipped."
+```
+
+### list-archives
+
+```bash
+echo "EXPORT ARCHIVES — org: $org_name"
+echo "────────────────────────────────────────────────────────"
+
+found=0
+for f in ".monomind/exports/${org_name}-"*.tar.gz ".monomind/exports/${org_name}-"*.zip; do
+  [ -f "$f" ] || continue
+  size=$(du -sh "$f" 2>/dev/null | cut -f1 || echo "?")
+  ts=$(stat -f "%Sm" -t "%Y-%m-%d %H:%M" "$f" 2>/dev/null || stat -c "%y" "$f" 2>/dev/null | cut -c1-16 || echo "?")
+  printf "  %-50s %8s  %s\n" "$(basename "$f")" "$size" "$ts"
+  found=$((found + 1))
+done
+
+[ "$found" -eq 0 ] && echo "  No archives found. Run --action export to create one."
+echo ""
+echo "Total: $found archive(s) in .monomind/exports/"
+```
+
+---
+
+## Step 3 — Return Output
+
+```yaml
+domain: ops
+status: complete
+action: <action>
+org: <org_name>
+output_path: <path if export>
+files_processed: <N>
+collision_strategy: <strategy if import>
+```
+
+---
+
+## 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/finance.md

@@ -0,0 +1,166 @@
+---
+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 _protocol.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 _protocol.md Brain Load Procedure (namespace: `finance`)
+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 "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 _protocol.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 |