@monoes/monomindcli 1.9.16 → 1.10.0

package/.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/.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`.