monomind 1.18.15 → 2.0.0

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

@@ -1,259 +0,0 @@
----
-name: mastermind-threads
-description: Mastermind threads — list, view, and create conversation threads within an org. Threads are human-or-agent discussions attached to issues, goals, or the org itself. Reads from -threads.jsonl org state files.
-type: domain-skill
-default_mode: auto
----
-
-# Mastermind Threads
-
-This skill is invoked by `mastermind:threads` or directly via `/mastermind:threads`.
-
----
-
-## Inputs
-
-- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
-- `org_name`: org to query (required)
-- `action`: list | view | create | reply
-- `thread_id`: thread ID (required for view/reply)
-- `issue_id`: filter by issue ID (optional)
-- `message`: message body (required for create/reply)
-- `author`: author name or agent ID (default: current user)
-- `limit`: max threads to show (default: 20)
-- `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 — Load Threads File
-
-```bash
-orgFile=".monomind/orgs/${org_name}.json"
-[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
-
-threadsFile=".monomind/orgs/${org_name}-threads.jsonl"
-limit="${limit:-20}"
-```
-
----
-
-## Step 2 — Execute Action
-
-### list (default)
-
-```bash
-echo "THREADS — $org_name"
-echo "────────────────────────────────────────────────────────"
-
-if [ ! -f "$threadsFile" ] || [ ! -s "$threadsFile" ]; then
-  echo "  No threads found."
-  echo ""
-  echo "  Create: /mastermind:threads --org $org_name --action create --message 'Hello team'"
-  exit 0
-fi
-
-python3 - "$threadsFile" "${issue_id:-}" "$limit" <<'PYEOF'
-import json, sys
-
-path       = sys.argv[1]
-issue_f    = sys.argv[2]
-limit      = int(sys.argv[3])
-
-threads = []
-with open(path) as f:
-    for line in f:
-        line = line.strip()
-        if not line: continue
-        try:
-            t = json.loads(line)
-            if t.get("type","thread") == "thread":
-                threads.append(t)
-        except: pass
-
-if issue_f:
-    threads = [t for t in threads if t.get("issueId") == issue_f]
-
-threads = threads[-limit:]
-
-if not threads:
-    print(f"  (no threads{'  filtered by issue=' + issue_f if issue_f else ''})")
-else:
-    print(f"  {'ID':<28} {'SUBJECT':<32} {'AUTHOR':<20} {'MSGS':<6} CREATED")
-    print("  " + "─" * 96)
-    for t in threads:
-        tid     = t.get("id","?")[:28]
-        subj    = (t.get("subject") or "(no subject)")[:32]
-        author  = (t.get("authorName") or t.get("authorId") or "—")[:20]
-        msgs    = len(t.get("messages", []))
-        created = (t.get("createdAt") or "-")[:10]
-        print(f"  {tid:<28} {subj:<32} {author:<20} {msgs:<6} {created}")
-
-print(f"\n  {len(threads)} thread(s). View: /mastermind:threads --org <org> --action view --thread-id <id>")
-PYEOF
-```
-
-### view
-
-```bash
-[ -z "$thread_id" ] && { echo "ERROR: --thread-id required."; exit 1; }
-
-if [ ! -f "$threadsFile" ]; then
-  echo "No threads found for org '$org_name'."
-  exit 0
-fi
-
-python3 - "$threadsFile" "$thread_id" <<'PYEOF'
-import json, sys
-
-path, tid = sys.argv[1], sys.argv[2]
-
-thread = None
-with open(path) as f:
-    for line in f:
-        line = line.strip()
-        if not line: continue
-        try:
-            t = json.loads(line)
-            if t.get("id") == tid and t.get("type","thread") == "thread":
-                thread = t
-        except: pass
-
-if not thread:
-    print(f"ERROR: Thread '{tid}' not found.")
-    sys.exit(1)
-
-subj   = thread.get("subject","(no subject)")
-issue  = thread.get("issueId","")
-created = thread.get("createdAt","-")
-
-print(f"THREAD: {subj}")
-print(f"  ID:       {tid}")
-if issue: print(f"  Issue:    {issue}")
-print(f"  Created:  {created}")
-print()
-print("MESSAGES")
-print("────────────────────────────────────────────────────────")
-
-msgs = thread.get("messages", [])
-if not msgs:
-    print("  (no messages)")
-else:
-    for m in msgs:
-        author = m.get("authorName") or m.get("authorId") or "?"
-        ts     = (m.get("createdAt") or "?")[:16].replace("T"," ")
-        body   = m.get("body","")
-        print(f"  [{ts}] {author}:")
-        for line in body.split("\n"):
-            print(f"    {line}")
-        print()
-PYEOF
-```
-
-### create
-
-```bash
-[ -z "$message" ] && { echo "ERROR: --message required."; exit 1; }
-
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-newId="thread-$(python3 -c 'import time; print(int(time.time()*1000))')"
-authorVal="${author:-operator}"
-
-python3 - "$threadsFile" "$newId" "${title:-}" "$message" "$authorVal" "${issue_id:-}" "$ts" <<'PYEOF'
-import json, sys
-
-path, tid, subj, body, author, issue, ts = sys.argv[1:]
-thread = {
-    "id": tid,
-    "type": "thread",
-    "subject": subj or "(no subject)",
-    "issueId": issue or None,
-    "authorId": author,
-    "authorName": author,
-    "createdAt": ts,
-    "messages": [{
-        "id": f"msg-{tid}",
-        "authorId": author,
-        "authorName": author,
-        "body": body,
-        "createdAt": ts,
-    }]
-}
-with open(path, "a") as f:
-    f.write(json.dumps(thread) + "\n")
-print(f"  Created thread: {tid}")
-print(f"  Subject: {subj or '(no subject)'}")
-print(f"  Message: {body[:80]}{'...' if len(body) > 80 else ''}")
-PYEOF
-```
-
-### reply
-
-```bash
-[ -z "$thread_id" ] && { echo "ERROR: --thread-id required."; exit 1; }
-[ -z "$message" ] && { echo "ERROR: --message required."; exit 1; }
-
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-authorVal="${author:-operator}"
-
-# Read all threads, append message to matching thread, rewrite file
-python3 - "$threadsFile" "$thread_id" "$message" "$authorVal" "$ts" <<'PYEOF'
-import json, sys
-
-path, tid, body, author, ts = sys.argv[1:]
-threads = []
-found = False
-with open(path) as f:
-    for line in f:
-        line = line.strip()
-        if not line: continue
-        try:
-            t = json.loads(line)
-            if t.get("id") == tid:
-                msg_id = f"msg-{tid}-{len(t.get('messages',[]))}"
-                t.setdefault("messages",[]).append({
-                    "id": msg_id,
-                    "authorId": author,
-                    "authorName": author,
-                    "body": body,
-                    "createdAt": ts,
-                })
-                found = True
-            threads.append(t)
-        except: pass
-
-if not found:
-    print(f"ERROR: Thread '{tid}' not found.")
-    sys.exit(1)
-
-with open(path, "w") as f:
-    for t in threads:
-        f.write(json.dumps(t) + "\n")
-
-print(f"  Reply added to thread: {tid}")
-print(f"  Author: {author}  |  {ts}")
-PYEOF
-```
-
----
-
-## Step 3 — Return Output
-
-```yaml
-domain: ops
-status: complete
-action: <action>
-org_name: <org_name>
-thread_id: <thread_id or new_id>
-```
-
----
-
-## 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/tree-control.md

@@ -1,250 +0,0 @@
----
-name: mastermind-tree-control
-description: Mastermind tree-control — pause, hold, release, or preview recovery for an issue/task tree in an org. Lets board members stop runaway loops, hold trees during review, and resume work when ready. Mirrors Paperclip's issue-tree-control API.
-type: domain-skill
-default_mode: confirm
----
-
-# Mastermind Tree Control
-
-This skill is invoked by `mastermind:tree-control` or directly via `/mastermind:tree-control`.
-
----
-
-## Inputs
-
-- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
-- `org_name`: org to operate on (required)
-- `issue_id`: root issue/task ID to control (required)
-- `action`: preview | hold | release | cancel
-- `reason`: reason for the hold/cancel (required for hold/cancel)
-- `caller`: command | master
-
----
-
-## Three Invariants (MUST be preserved)
-
-All tree-control actions must respect these invariants:
-
-1. **Productive work continues.** Only hold what genuinely needs to stop; don't block productive branches.
-2. **Only real blockers stop work.** A hold is a deliberate decision, not a pseudo-stop.
-3. **No infinite loops.** Release must be possible — never hold without a clear release path.
-
----
-
-## 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 and Issue
-
-```bash
-orgFile=".monomind/orgs/${org_name}.json"
-[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
-[ -z "$issue_id" ] && { echo "ERROR: --issue-id required."; exit 1; }
-
-issuesFile=".monomind/orgs/${org_name}-issues.json"
-[ ! -f "$issuesFile" ] && { echo "ERROR: No issues file found for org '${org_name}'."; exit 1; }
-```
-
----
-
-## Step 2 — Execute Action
-
-### preview (default)
-
-Preview what a hold/cancel would affect without making changes:
-
-```bash
-echo "TREE CONTROL PREVIEW — $org_name  root: $issue_id"
-echo "════════════════════════════════════════════════════════"
-
-python3 - "$issuesFile" "$issue_id" <<'PYEOF'
-import json, sys
-
-data   = json.load(open(sys.argv[1]))
-rootId = sys.argv[2]
-issues = {i["id"]: i for i in data.get("issues", [])}
-
-root = issues.get(rootId)
-if not root:
-    print(f"ERROR: Issue '{rootId}' not found.")
-    sys.exit(1)
-
-print(f"  Root:   {root.get('id')} — {root.get('title','?')} [{root.get('status','?')}]")
-print()
-
-# Find subtree
-def subtree(iid, depth=0):
-    children = [i for i in issues.values() if i.get("parentId") == iid or iid in (i.get("blockedByIssueIds") or [])]
-    for c in children:
-        st = c.get("status","?")
-        icon = "⚠" if st in ("in_progress","in_review") else "○"
-        print(f"  {'  ' * depth}{icon} {c['id']} — {c.get('title','?')} [{st}]")
-        subtree(c["id"], depth + 1)
-
-subtree(rootId)
-
-active = [i for i in issues.values()
-          if i.get("status") in ("in_progress","in_review")
-          and (i.get("parentId") == rootId or rootId in (i.get("blockedByIssueIds") or []))]
-print()
-print(f"  Active issues in subtree: {len(active)}")
-print(f"  Holding root would affect all {len(active)} active issue(s).")
-print()
-print("  To hold: /mastermind:tree-control --org <org> --action hold --issue-id <id> --reason 'Review needed'")
-print("  To cancel: /mastermind:tree-control --org <org> --action cancel --issue-id <id> --reason 'No longer needed'")
-PYEOF
-```
-
-### hold
-
-Place a hold on the issue tree (pauses all active work in the subtree):
-
-```bash
-[ -z "$reason" ] && { echo "ERROR: --reason required for hold action."; exit 1; }
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-
-python3 - "$issuesFile" "$issue_id" "$reason" "$ts" <<'PYEOF'
-import json, sys
-
-path, rootId, reason, ts = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]
-data = json.load(open(path))
-issues = data.get("issues", [])
-
-# Add hold metadata to root issue
-held = 0
-for iss in issues:
-    if iss.get("id") == rootId:
-        iss.setdefault("holds", []).append({
-            "id": f"hold-{int(ts.replace('-','').replace(':','').replace('T','').replace('Z',''))[:14]}",
-            "reason": reason,
-            "createdAt": ts,
-            "status": "active"
-        })
-        held += 1
-        break
-
-if not held:
-    print(f"ERROR: Issue '{rootId}' not found.")
-    sys.exit(1)
-
-data["issues"] = issues
-with open(path, "w") as f:
-    json.dump(data, f, indent=2)
-
-print(f"  HOLD PLACED on issue tree rooted at: {rootId}")
-print(f"  Reason: {reason}")
-print(f"  Applied: {ts}")
-print()
-print("  Active agents should detect the hold and pause execution.")
-print(f"  To release: /mastermind:tree-control --org <org> --action release --issue-id {rootId}")
-PYEOF
-```
-
-### release
-
-Release a hold from the issue tree:
-
-```bash
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-
-python3 - "$issuesFile" "$issue_id" "$ts" <<'PYEOF'
-import json, sys
-
-path, rootId, ts = sys.argv[1], sys.argv[2], sys.argv[3]
-data = json.load(open(path))
-issues = data.get("issues", [])
-
-released = 0
-for iss in issues:
-    if iss.get("id") == rootId:
-        holds = iss.get("holds", [])
-        active_holds = [h for h in holds if h.get("status") == "active"]
-        for h in active_holds:
-            h["status"] = "released"
-            h["releasedAt"] = ts
-            released += 1
-        iss["holds"] = holds
-        break
-
-if not released:
-    print(f"  No active holds found on issue '{rootId}'.")
-    print("  (Issue may already be running or was never held.)")
-else:
-    data["issues"] = issues
-    with open(path, "w") as f:
-        json.dump(data, f, indent=2)
-    print(f"  HOLD RELEASED on {rootId} — {released} hold(s) cleared.")
-    print(f"  Released: {ts}")
-    print()
-    print("  Agents can now resume work on this issue tree.")
-PYEOF
-```
-
-### cancel
-
-Cancel an issue and its entire subtree:
-
-```bash
-[ -z "$reason" ] && { echo "ERROR: --reason required for cancel action."; exit 1; }
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-
-echo "WARNING: This will mark '$issue_id' and its subtree as cancelled."
-echo "Reason: $reason"
-echo ""
-
-python3 - "$issuesFile" "$issue_id" "$reason" "$ts" <<'PYEOF'
-import json, sys
-
-path, rootId, reason, ts = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]
-data = json.load(open(path))
-issues = data.get("issues", [])
-issues_map = {i["id"]: i for i in issues}
-
-def cancel_subtree(iid):
-    iss = issues_map.get(iid)
-    if not iss:
-        return 0
-    if iss.get("status") in ("done","cancelled"):
-        return 0
-    iss["status"] = "cancelled"
-    iss["cancelledAt"] = ts
-    iss["cancelReason"] = reason
-    count = 1
-    children = [i for i in issues if i.get("parentId") == iid]
-    for c in children:
-        count += cancel_subtree(c["id"])
-    return count
-
-cancelled = cancel_subtree(rootId)
-
-data["issues"] = issues
-with open(path, "w") as f:
-    json.dump(data, f, indent=2)
-
-print(f"  CANCELLED: {cancelled} issue(s) in tree rooted at {rootId}")
-print(f"  Reason: {reason}")
-print(f"  Applied: {ts}")
-PYEOF
-```
-
----
-
-## Step 3 — Return Output
-
-```yaml
-domain: ops
-status: complete
-action: <action>
-org_name: <org_name>
-issue_id: <issue_id>
-```
-
----
-
-## 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/verify.md

@@ -1,196 +0,0 @@
----
-name: mastermind-verify
-description: Mastermind verification gate — enforces evidence-before-claims before any completion, commit, PR, or agent-delegation step. The Iron Law of verification.
-type: domain-skill
-default_mode: auto
----
-
-# Mastermind Verify
-
-This skill is invoked by `mastermind:master` or directly via `/mastermind:verify`.
-
-Claiming work is complete without verification is dishonesty, not efficiency.
-
-**Core principle:** Evidence before claims, always.
-
-**Violating the letter of this rule is violating the spirit of this rule.**
-
----
-
-## Inputs
-
-- `brain_context`: BRAIN CONTEXT block (injected by master, or loaded standalone via _protocol.md brain load)
-- `prompt`: what to verify and what claim is being made
-- `project_name`: monotask space name
-- `board_id`: monotask board ID (set by master, or created standalone)
-- `mode`: auto | confirm
-
----
-
-## The Iron Law
-
-```
-NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE
-```
-
-If you haven't run the verification command in this message, you cannot claim it passes.
-
----
-
-## The Gate Function
-
-```
-BEFORE claiming any status or expressing satisfaction:
-
-1. IDENTIFY: What command proves this claim?
-2. RUN: Execute the FULL command (fresh, complete)
-3. READ: Full output, check exit code, count failures
-4. VERIFY: Does output confirm the claim?
-   - If NO: State actual status with evidence
-   - If YES: State claim WITH evidence
-5. ONLY THEN: Make the claim
-
-Skip any step = lying, not verifying
-```
-
----
-
-## Common Failures
-
-| Claim | Requires | Not Sufficient |
-|-------|----------|----------------|
-| Tests pass | Test command output: 0 failures | Previous run, "should pass" |
-| Linter clean | Linter output: 0 errors | Partial check, extrapolation |
-| Build succeeds | Build command: exit 0 | Linter passing, logs look good |
-| Bug fixed | Test original symptom: passes | Code changed, assumed fixed |
-| Regression test works | Red-green cycle verified | Test passes once |
-| Agent completed | VCS diff shows changes | Agent reports "success" |
-| Requirements met | Line-by-line checklist | Tests passing |
-
----
-
-## Red Flags - STOP
-
-- Using "should", "probably", "seems to"
-- Expressing satisfaction before verification ("Great!", "Perfect!", "Done!", etc.)
-- About to commit/push/PR without verification
-- Trusting agent success reports
-- Relying on partial verification
-- Thinking "just this once"
-- Tired and wanting work over
-- **ANY wording implying success without having run verification**
-
----
-
-## Rationalization Prevention
-
-| Excuse | Reality |
-|--------|---------|
-| "Should work now" | RUN the verification |
-| "I'm confident" | Confidence ≠ evidence |
-| "Just this once" | No exceptions |
-| "Linter passed" | Linter ≠ compiler |
-| "Agent said success" | Verify independently |
-| "I'm tired" | Exhaustion ≠ excuse |
-| "Partial check is enough" | Partial proves nothing |
-| "Different words so rule doesn't apply" | Spirit over letter |
-
----
-
-## Key Patterns
-
-**Tests:**
-```
-✅ [Run test command] [See: 34/34 pass] "All tests pass"
-❌ "Should pass now" / "Looks correct"
-```
-
-**Regression tests (TDD Red-Green):**
-```
-✅ Write → Run (pass) → Revert fix → Run (MUST FAIL) → Restore → Run (pass)
-❌ "I've written a regression test" (without red-green verification)
-```
-
-**Build:**
-```
-✅ [Run build] [See: exit 0] "Build passes"
-❌ "Linter passed" (linter doesn't check compilation)
-```
-
-**Requirements:**
-```
-✅ Re-read plan → Create checklist → Verify each → Report gaps or completion
-❌ "Tests pass, phase complete"
-```
-
-**Agent delegation:**
-```
-✅ Agent reports success → Check VCS diff → Verify changes → Report actual state
-❌ Trust agent report
-```
-
----
-
-## Execution
-
-### Complexity Assessment
-
-**Simple (direct verification):** Single command, one claim:
-- "Do the tests pass?"
-- "Does the build succeed?"
-- Run the command, report the output.
-
-**Complex (multi-gate verification):** Multiple claims or multi-step requirements:
-- "Is this feature complete?" → decompose into requirement checklist, run each gate
-- Spawn a Verification Coordinator if needed
-
-### Steps
-
-1. **Parse the claim or task being verified.** If the prompt is empty or vague, ask: "What claim or task needs verification?"
-
-2. **Identify all verification gates.** For each claim, determine the exact command that proves or disproves it.
-
-3. **Run each gate fresh.** Execute commands in this session. Do not rely on prior output.
-
-4. **Collect evidence.** Exit code, line counts, failure messages, diff output.
-
-5. **Report findings with evidence.** Never summarize without quoting relevant output.
-
----
-
-## When To Apply
-
-**ALWAYS before:**
-- ANY variation of success/completion claims
-- ANY expression of satisfaction
-- ANY positive statement about work state
-- Committing, PR creation, task completion
-- Moving to next task
-- Delegating to agents
-
-**Rule applies to:**
-- Exact phrases
-- Paraphrases and synonyms
-- Implications of success
-- ANY communication suggesting completion/correctness
-
----
-
-## Why This Matters
-
-From failure patterns:
-- Trust broken when claiming done without checking
-- Undefined functions shipped — would crash
-- Missing requirements shipped — incomplete features
-- Time wasted on false completion → redirect → rework
-- Violates: "Honesty is a core value. If you lie, you'll be replaced."
-
----
-
-## The Bottom Line
-
-**No shortcuts for verification.**
-
-Run the command. Read the output. THEN claim the result.
-
-This is non-negotiable.