monomind 1.16.6 → 1.16.7

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

@@ -0,0 +1,259 @@
+---
+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/packages/@monomind/cli/.claude/skills/mastermind/tree-control.md

@@ -0,0 +1,250 @@
+---
+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/packages/@monomind/cli/.claude/skills/mastermind/verify.md

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