@monoes/monomindcli 1.8.0 → 1.9.0

package/.claude/commands/mastermind/master.md

@@ -0,0 +1,379 @@
+---
+name: mastermind-master
+description: Mastermind top-level orchestrator — receives any business prompt, loads the brain, decomposes into domains, spawns domain manager agents via Task tool, synthesizes results, and writes back to the brain. The single entry point for full business automation.
+---
+
+**If $ARGUMENTS is empty:** Output the capability menu below and wait.
+
+---
+
+**MASTERMIND** — autonomous business execution across specialist domains.
+
+Describe your goal. Mastermind identifies the relevant domains, spawns specialist agents in parallel, and synthesizes results. Or invoke a domain directly.
+
+---
+
+**Build & ship**
+`/mastermind:build` — code, features, bug fixes, test suites
+`/mastermind:architect` — system structure, DDD, deduplication, migration (`--scope review|design|deduplicate|migrate|all`)
+`/mastermind:idea` — products, features, pivots, opportunity framing
+`/mastermind:content` — blog, threads, documentation, newsletters
+
+**Understand & decide**
+`/mastermind:research` — market intelligence, competitors, user insights
+`/mastermind:review` — code quality, content critique, strategy audit
+`/mastermind:brain` — inspect and manage business memory
+
+**Go to market & operate**
+`/mastermind:marketing` — campaigns, copy, SEO, social strategy
+`/mastermind:sales` — outreach, proposals, pipeline management
+`/mastermind:release` — versioning, changelogs, deployment
+`/mastermind:ops` — workflow automation, process reporting
+`/mastermind:finance` — invoicing, forecasting, cost tracking
+
+**Persistent agent orgs** — named teams that coordinate across sessions
+`/mastermind:createorg` — define an org: roles, hierarchy, goal
+`/mastermind:runorg` — start a saved org; boss agent assigns work to all roles
+
+---
+Flags: `--auto` · `--confirm` · `--project <name>` · `--iterate <N>`
+
+---
+
+**If $ARGUMENTS is non-empty:** Execute the full flow below.
+
+---
+
+## Execution Flow
+
+### Step 1 — Parse flags
+
+Extract from `$ARGUMENTS`:
+- `--auto` → mode = auto
+- `--confirm` → mode = confirm
+- `--project <name>` → project_name = <name>
+- `--iterate <N>` → iterate = N (integer ≥ 1; default 0 = no iteration)
+- Remaining text = prompt
+
+### Step 2 — Brain Load
+
+Follow the Brain Load Procedure from `_protocol.md`:
+
+1. Call `mcp__monomind__agentdb_hierarchical-recall` namespace `mastermind:principles` (limit 20)
+2. For each domain that appears relevant to the prompt, call `mcp__monomind__agentdb_context-synthesize` namespace `mastermind:<domain>:weekly`
+3. Call `mcp__monomind__monograph_query` with 3-5 keywords from the prompt
+
+Assemble the BRAIN CONTEXT block from results.
+
+### Step 3 — Intake
+
+Invoke the intake logic from `_intake.md`:
+
+- Check if prompt is rich (≥20 words + domain signals + goal phrase)
+- If vague: ask intake questions one at a time (Q1–Q5, stop when enough context)
+- If user says "decide yourself": make explicit LLM decision, state it, log it with confidence 0.7
+- Resolve: mode (auto/confirm), project_name, domains_needed
+
+**After intake resolves:** Generate a session ID (`mm-<YYYYMMDDTHHmmss>`) and emit `session:start` to the live dashboard (see Real-Time Dashboard Event Logging in `_protocol.md`). If the server is unreachable, continue without blocking.
+
+```javascript
+WebFetch({
+  url: "http://localhost:4242/api/mastermind/event",
+  method: "POST",
+  headers: { "Content-Type": "application/json" },
+  body: JSON.stringify({
+    type: "session:start",
+    session: sessionId,        // store this ID for all subsequent events
+    prompt: resolvedPrompt,
+    mode: mode,
+    ts: Date.now()
+  })
+})
+```
+
+### Step 4 — Decompose
+
+For each domain in `domains_needed`, assess complexity:
+- **Simple** (skill-only): single task, single agent, < 30 minutes estimated — invoke skill directly
+- **Complex** (manager agent): multi-step, multi-file, multi-day, or multi-agent — spawn a Task agent
+
+Complexity threshold for manager agent: any of these is true:
+- Requires 3+ files to be created/modified
+- Requires 2+ specialized agent types
+- Has external dependencies (APIs, services)
+- Is estimated to take more than one conversation turn
+
+### Step 5 — Plan Output
+
+Build a plan summary:
+
+```
+MASTERMIND PLAN — <project_name>
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Prompt: <prompt>
+Mode: <auto|confirm>
+
+Domains activated:
+  ✦ build → Development Manager agent → board: <project>/development
+  ✦ marketing → Marketing Manager agent → board: <project>/marketing
+
+Monotask space: <project_name>
+Brain loaded: <N> principles, <M> domain summaries
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+If mode = confirm: show plan and wait for user to say "go" or modify. If mode = auto: proceed immediately.
+
+### Step 6 — Monotask Setup
+
+For each active domain:
+1. Find or create monotask space named `<project_name>`
+2. Create a board named `<domain>` within that space
+3. Note the board ID for the domain manager's task briefing
+
+### Step 7 — Spawn Domain Managers
+
+**Before spawning:** For EACH domain in `domains_needed`, emit a `domain:dispatch` event to the live dashboard:
+
+```javascript
+// Emit for each domain — use WebFetch for each (or batch them)
+WebFetch({
+  url: "http://localhost:4242/api/mastermind/event",
+  method: "POST",
+  headers: { "Content-Type": "application/json" },
+  body: JSON.stringify({
+    type: "domain:dispatch",
+    session: sessionId,
+    domain: "<domain-id>",    // e.g. "build", "marketing"
+    cmd: "<one-line goal for this domain>",
+    ts: Date.now()
+  })
+})
+```
+
+Spawn ALL domain manager agents in ONE message using the Task tool (parallel execution).
+
+Each Task call must include a complete briefing following the Monotask Task Briefing Standard from `_protocol.md`. Include:
+- The full BRAIN CONTEXT block
+- The board ID
+- The specific goal for this domain
+- The project name and run context
+- Instruction to create monotask cards directly using `monotask card create $BOARD_ID $COL_TODO_ID "<title>" --json` for all sub-tasks
+- Instruction to use `/monomind:do` to execute
+- Instruction to spawn specialized agents using the domain-appropriate swarm topology
+- Instruction to return the unified output schema when done
+
+Example Task call for Development Manager:
+```javascript
+Task({
+  subagent_type: "coordinator",
+  description: `You are the Development Manager for project <project_name>.
+
+CONTEXT: Mastermind run <date> | Project: <project_name> | Master spawned you.
+
+BRAIN CONTEXT:
+<paste brain context here>
+
+YOUR BOARD: <board_id> (monotask://<project_name>/development)
+
+GOAL: <domain-specific goal extracted from prompt>
+
+SESSION ID: <sessionId>   ← use this in all dashboard events
+
+YOUR RESPONSIBILITIES:
+1. Resolve column IDs first:
+   ```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 break this goal into discrete tasks by creating monotask cards: `monotask card create "$BOARD_ID" "$COL_TODO_ID" "<title>" --json`
+   Each task description MUST follow the Monotask Task Briefing Standard (full context, goal, scope, constraints, success criteria, agent, swarm, dependencies)
+2. Spawn specialized agents for each task using the Task tool:
+   - Backend work: subagent_type "backend-dev"
+   - Frontend work: subagent_type "frontend-dev"
+   - Testing: subagent_type "tester"
+   - Code review: subagent_type "reviewer"
+   Default swarm: hierarchical 6 agents raft
+3. BEFORE spawning each agent, emit agent:spawn to the live dashboard:
+   WebFetch({ url: "http://localhost:4242/api/mastermind/event", method: "POST",
+     headers: {"Content-Type":"application/json"},
+     body: JSON.stringify({ type:"agent:spawn", session:"<sessionId>",
+       domain:"build", agent:"<agent-slug>", task:"<task-description>", ts:Date.now() }) })
+4. If you hand off artifacts to another domain manager, emit intercom:
+   WebFetch({ url: "http://localhost:4242/api/mastermind/event", method: "POST",
+     headers: {"Content-Type":"application/json"},
+     body: JSON.stringify({ type:"intercom", session:"<sessionId>",
+       from:"build", to:"<other-domain>", msg:"<one-line summary>", ts:Date.now() }) })
+5. Execute tasks via /monomind:do --board <board_id>
+6. Collect all agent outputs
+7. BEFORE returning, emit domain:complete to the live dashboard:
+   WebFetch({ url: "http://localhost:4242/api/mastermind/event", method: "POST",
+     headers: {"Content-Type":"application/json"},
+     body: JSON.stringify({ type:"domain:complete", session:"<sessionId>",
+       domain:"build", status:"complete|partial|blocked",
+       artifacts:["/path/file1"], decisions:[{what:"...",confidence:0.9}], ts:Date.now() }) })
+8. Return unified output schema to master:
+   domain: build
+   status: complete|partial|blocked
+   artifacts: [...]
+   decisions: [...]
+   lessons: [...]
+   next_actions: [...]
+   board_url: monotask://<project_name>/development
+   run_id: <ISO8601-timestamp>`,
+  run_in_background: true
+})
+```
+
+### Step 8 — Wait for Reports
+
+Collect the unified output schema from each domain manager. If a manager reports `status: blocked`, note the blocker but continue collecting from others — do not abort.
+
+### Step 9 — Synthesize
+
+1. Collect all domain output schemas
+2. Identify any cross-domain artifacts needed (e.g. a release that requires both build and review)
+3. Write cross-domain artifacts to disk if needed
+4. **Emit `session:complete` to the live dashboard:**
+
+```javascript
+WebFetch({
+  url: "http://localhost:4242/api/mastermind/event",
+  method: "POST",
+  headers: { "Content-Type": "application/json" },
+  body: JSON.stringify({
+    type: "session:complete",
+    session: sessionId,
+    status: overallStatus,    // "complete" | "partial" | "blocked"
+    domains: completedDomains,
+    ts: Date.now()
+  })
+})
+```
+
+5. Compose the action summary for the user:
+
+```
+MASTERMIND RUN COMPLETE — <project_name>
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Status: complete | partial | blocked
+
+Domains completed: build ✓ | marketing ✓
+Domains blocked: (none)
+
+Artifacts produced:
+  /path/to/file1 (code)
+  /path/to/file2 (copy)
+
+Key decisions made:
+  • [what] — [why] (confidence: X)
+
+Next actions suggested:
+  • /mastermind:review --project <project_name>
+  • /mastermind:release --project <project_name>
+
+Monotask boards:
+  → monotask://<project_name>/development
+  → monotask://<project_name>/marketing
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### Step 10 — Brain Write
+
+Follow the Brain Write Procedure from `_protocol.md` for each domain that ran:
+1. Score all decisions from this run
+2. Append to Tier 1 raw log (AgentDB)
+3. Check and trigger weekly compaction if threshold met
+4. Check and trigger graph consolidation if cluster detected
+
+### Step 11 — Output to User
+
+Show the action summary (Step 9). If any compaction ran during Step 10, append:
+> "Brain updated: compacted <N> entries into <M> summaries."
+
+---
+
+### Step 12 — Iteration Loop (only if `--iterate <N>` was set and N ≥ 1)
+
+After Step 11, run N autonomous improvement cycles. Each cycle is a full self-directed run — no user input required.
+
+**For each cycle i = 1 … N:**
+
+#### 12a — Assess Current State
+
+Load fresh brain context (repeat Brain Load Procedure from `_protocol.md`). Then evaluate the project's current state by examining:
+- What was just completed (artifacts from the most recent run's output schema)
+- What the brain's `next_actions` entries suggest
+- What the `next_actions` from all domain outputs say
+- What the git diff shows (if applicable) — any test failures, TODOs, or incomplete work
+- What gaps exist relative to the original prompt's success criteria
+
+#### 12b — Decide Next Activity
+
+Choose the single highest-value activity for this cycle. Rank candidates by this priority:
+
+| Priority | Activity | Choose when |
+|---|---|---|
+| 1 | **Test** | New code exists with no test coverage, or tests failed |
+| 2 | **Debug / Fix** | Tests are failing or artifacts have known errors |
+| 3 | **Review** | Significant new code exists with no review pass |
+| 4 | **Improve / Refactor** | Code works but has quality issues surfaced by review or brain |
+| 5 | **Add feature** | Core is stable; next_actions suggest new capability aligned with project goal |
+| 6 | **Research** | Significant unknowns remain before next feature can be decided |
+| 7 | **Content / Docs** | Feature is complete and undocumented |
+| 8 | **Release** | Project is stable, tested, reviewed — ready to ship |
+
+State the decision explicitly:
+> "Cycle <i>/<N>: I'm choosing to **<activity>** because <one-sentence reason>. Confidence: <0.0–1.0>"
+
+Log this as a decision in the cycle's output schema with `confidence` set accordingly.
+
+#### 12c — Execute
+
+Execute the chosen activity by invoking the appropriate domain skill directly (Steps 4–10 of the main flow, condensed):
+
+- Test → `Skill("mastermind:build")` with a testing-focused prompt
+- Debug/Fix → `Skill("mastermind:build")` with the specific issue as prompt
+- Review → `Skill("mastermind:review")` with scope = artifacts from last run
+- Improve/Refactor → `Skill("mastermind:build")` with refactor prompt
+- Add feature → `Skill("mastermind:build")` with the next feature from next_actions
+- Research → `Skill("mastermind:research")` with the open question as prompt
+- Content/Docs → `Skill("mastermind:content")` with scope = new artifacts
+- Release → `Skill("mastermind:release")` with project scope
+
+Always pass: the current brain_context, project_name, the relevant board_id, and mode = auto (iteration cycles never pause for confirmation).
+
+#### 12d — Brain Write
+
+Follow Brain Write Procedure from `_protocol.md` for this cycle's domain. Score and append.
+
+#### 12e — Cycle Summary
+
+Output a compact progress line:
+
+```
+ITERATION <i>/<N> — <activity> — <status: complete|partial|blocked>
+  → <one-line summary of what was done>
+  → Next cycle will: <predicted next activity based on current state>
+```
+
+If the cycle returns `status: blocked`, skip remaining cycles and report:
+> "Iteration halted at cycle <i>: blocked on <reason>. Remaining <N-i> cycles skipped."
+
+---
+
+After all N cycles complete, output a final iteration summary:
+
+```
+ITERATION COMPLETE — <N> cycles — <project_name>
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Cycle 1: test       → 12 tests added, all passing
+Cycle 2: review     → 3 issues found, 2 fixed inline
+Cycle 3: improve    → auth module refactored, 15% complexity reduction
+...
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Brain updated: <total decisions scored and logged>
+Project state: <one-sentence assessment of where things stand>
+Suggested next: <what a human should do or approve next>
+```

package/.claude/commands/mastermind/ops.md

@@ -0,0 +1,22 @@
+---
+name: mastermind-ops
+description: Mastermind ops domain — workflow automation, reporting, process optimization. Default mode: auto.
+---
+
+Parse `$ARGUMENTS` for:
+- `--auto` flag → mode = auto
+- `--confirm` flag → mode = confirm
+- `--project <name>` → project_name = <name>
+- Remaining text = prompt
+
+If prompt is empty: ask "What operations task would you like to automate or optimize?"
+
+Load brain context for the `ops` domain (follow _protocol.md Brain Load Procedure).
+
+Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `ops`).
+
+Default mode for this command: **auto** (unless `--confirm` flag present or intake Q4 says confirm).
+
+Invoke `Skill("mastermind:ops")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+
+After skill returns: follow _protocol.md Brain Write Procedure for domain `ops`.

package/.claude/commands/mastermind/release.md

@@ -0,0 +1,22 @@
+---
+name: mastermind-release
+description: Mastermind release domain — versioning, changelog, deployment. Default mode: auto.
+---
+
+Parse `$ARGUMENTS` for:
+- `--auto` flag → mode = auto
+- `--confirm` flag → mode = confirm
+- `--project <name>` → project_name = <name>
+- Remaining text = prompt
+
+If prompt is empty: ask "What would you like to release or deploy?"
+
+Load brain context for the `release` domain (follow _protocol.md Brain Load Procedure).
+
+Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `release`).
+
+Default mode for this command: **auto** (unless `--confirm` flag present or intake Q4 says confirm).
+
+Invoke `Skill("mastermind:release")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+
+After skill returns: follow _protocol.md Brain Write Procedure for domain `release`.

package/.claude/commands/mastermind/research.md

@@ -0,0 +1,22 @@
+---
+name: mastermind-research
+description: Mastermind research domain — market research, competitor analysis, user research, trend scanning. Default mode: auto.
+---
+
+Parse `$ARGUMENTS` for:
+- `--auto` flag → mode = auto
+- `--confirm` flag → mode = confirm
+- `--project <name>` → project_name = <name>
+- Remaining text = prompt
+
+If prompt is empty: ask "What would you like researched?"
+
+Load brain context for the `research` domain (follow _protocol.md Brain Load Procedure).
+
+Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `research`).
+
+Default mode for this command: **auto** (unless `--confirm` flag present or intake Q4 says confirm).
+
+Invoke `Skill("mastermind:research")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+
+After skill returns: follow _protocol.md Brain Write Procedure for domain `research`.

package/.claude/commands/mastermind/review.md

@@ -0,0 +1,22 @@
+---
+name: mastermind-review
+description: Mastermind review domain — code review, security audit, content and strategy review. Default mode: auto.
+---
+
+Parse `$ARGUMENTS` for:
+- `--auto` flag → mode = auto
+- `--confirm` flag → mode = confirm
+- `--project <name>` → project_name = <name>
+- Remaining text = prompt
+
+If prompt is empty: ask "What would you like reviewed?"
+
+Load brain context for the `review` domain (follow _protocol.md Brain Load Procedure).
+
+Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `review`).
+
+Default mode for this command: **auto** (unless `--confirm` flag present or intake Q4 says confirm).
+
+Invoke `Skill("mastermind:review")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+
+After skill returns: follow _protocol.md Brain Write Procedure for domain `review`.

package/.claude/commands/mastermind/runorg.md

@@ -0,0 +1,106 @@
+---
+name: mastermind-runorg
+description: Start a saved org as a persistent autonomous agent organization. The boss agent coordinates all roles; agents pick up tasks from a shared board and run until stopped.
+---
+
+**If $ARGUMENTS is empty:** List saved orgs and display the following.
+
+---
+
+**MASTERMIND: RUN ORG**
+
+Running an org starts a persistent agent organization: a boss agent loads the org definition, assigns work to specialists, monitors progress, and keeps agents on task until you stop them. Agents pick up cards from a shared board — one role per agent, all running in parallel.
+
+This is continuous operation, not a one-shot run. The org loops: plan → execute → review → plan. Stop it explicitly with `/mastermind:ops --stop-org <name>`.
+
+**Your saved orgs:**
+
+```bash
+ls .monomind/orgs/*.json 2>/dev/null | xargs -I{} basename {} .json 2>/dev/null || echo "(none — run /mastermind:createorg to define one)"
+```
+
+**Usage:**
+
+```
+/mastermind:runorg --org <name>
+
+/mastermind:runorg --org content-team --task "Publish the Q2 product roundup post by Friday"
+
+/mastermind:runorg --org research-pod "Focus this week on competitor pricing changes"
+```
+
+**Options:**
+`--org <name>` — which saved org to start (required; prompted if omitted)
+`--task <task>` — override the org's default goal for this run
+Any remaining text is passed as additional context to the boss agent.
+
+No orgs yet? Run `/mastermind:createorg` to define one.
+
+---
+
+**If $ARGUMENTS is non-empty:** Execute the flow below.
+
+---
+
+Parse `$ARGUMENTS` for:
+- `--org <name>` → org_name = <name>
+- `--task <task>` → task_override = <task> (if omitted, task_override = null — the skill uses org's stored goal)
+- Remaining text = additional context passed to the boss agent
+
+If `--org` is not provided, list saved orgs and ask which to run:
+```bash
+orgs=$(ls .monomind/orgs/*.json 2>/dev/null | xargs -I{} basename {} .json 2>/dev/null)
+if [ -z "$orgs" ]; then
+  echo "No saved orgs found. Run /mastermind:createorg first."
+  exit 1
+fi
+echo "$orgs"
+```
+Ask: "Which org would you like to start? Available: <list from above>"
+
+Verify the org file exists before proceeding:
+```bash
+[ -f ".monomind/orgs/${org_name}.json" ] || { echo "Org '${org_name}' not found."; exit 1; }
+```
+If the file does not exist, stop and suggest running `/mastermind:createorg --name ${org_name}`.
+
+Load brain context for the `ops` domain (follow _protocol.md Brain Load Procedure, namespace: `ops`).
+
+Generate a session ID as a real shell variable:
+```bash
+session_id="mm-$(date -u +%Y%m%dT%H%M%S)"
+```
+
+Emit `session:start` to dashboard:
+```bash
+curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg org "$org_name" \
+    '{type:"session:start",session:$session,domain:"ops",prompt:("Running org: "+$org),mode:"auto",ts:(now*1000|floor)}')" || true
+```
+
+Emit `domain:dispatch`:
+```bash
+curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg org "$org_name" \
+    '{type:"domain:dispatch",session:$session,domain:"ops",cmd:("Starting org "+$org+" as persistent daemon"),ts:(now*1000|floor)}')" || true
+```
+
+Invoke `Skill("mastermind:runorg")` passing: brain_context, org_name: `$org_name`, session_id: `$session_id`, task: task_override, caller: "command".
+
+After the skill spawns the boss agent and returns: note the status. Emit `session:complete`:
+```bash
+curl -s -X POST "http://localhost:4242/api/mastermind/event" \
+  -H "Content-Type: application/json" \
+  -d "$(jq -cn \
+    --arg session "$session_id" \
+    --arg status "<status>" \
+    '{type:"session:complete",session:$session,domain:"ops",status:$status,domains:["ops"],ts:(now*1000|floor)}')" || true
+```
+
+Follow _protocol.md Brain Write Procedure for domain `ops`.

package/.claude/commands/mastermind/sales.md

@@ -0,0 +1,22 @@
+---
+name: mastermind-sales
+description: Mastermind sales domain — outreach sequences, proposals, pipeline management. Default mode: confirm.
+---
+
+Parse `$ARGUMENTS` for:
+- `--auto` flag → mode = auto
+- `--confirm` flag → mode = confirm
+- `--project <name>` → project_name = <name>
+- Remaining text = prompt
+
+If prompt is empty: ask "What sales task would you like to tackle?"
+
+Load brain context for the `sales` domain (follow _protocol.md Brain Load Procedure).
+
+Run intake if prompt is vague (follow _intake.md — stop at Q3, domain is already known as `sales`).
+
+Default mode for this command: **confirm** (unless `--auto` flag present or intake Q4 says auto).
+
+Invoke `Skill("mastermind:sales")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
+
+After skill returns: follow _protocol.md Brain Write Procedure for domain `sales`.

package/.claude/commands/mastermind/techport.md

@@ -0,0 +1,17 @@
+---
+name: mastermind-techport
+description: Tech Port — deep-analyzes a foreign project folder and recommends porting valuable features, patterns, or infrastructure into the current monomind base project.
+---
+
+Parse `$ARGUMENTS` for:
+- First path-like token (starts with `/`, `./`, `../`, or `~`) → source_path
+- `--auto` flag → mode = auto (port immediately after analysis)
+- `--confirm` flag → mode = confirm (present plan, wait for approval before porting)
+- `--partial` flag → suggest partial/selective ports only (no full port option)
+- Remaining text after flags = focus_hint (optional: what kind of value to look for)
+
+If source_path is empty: ask "What is the path to the project you want to analyze?"
+
+Default mode: **confirm** (show analysis + port plan, wait before executing anything).
+
+Invoke `Skill("mastermind:techport")` passing: source_path, focus_hint, mode.