monomind 1.10.0 → 1.10.1

package/.claude/skills/mastermind/memory.md

@@ -1,321 +0,0 @@
----
-name: mastermind-memory
-description: Mastermind memory — org-scoped persistent memory using PARA method (Projects, Areas, Resources, Archives). Ingest facts, recall context, maintain knowledge graph, run weekly synthesis. Reads from .monomind/orgs/<org>-memory/ directory. Port of Paperclip's para-memory-files skill for org-level context.
-type: domain-skill
-default_mode: auto
----
-
-# Mastermind Memory
-
-This skill is invoked by `mastermind:memory` or directly via `/mastermind:memory`.
-
----
-
-## Inputs
-
-- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
-- `org_name`: org whose memory to operate on (required)
-- `action`: ingest | recall | query | update | forget | synthesize | decay | list
-- `topic`: topic or entity name (required for ingest/recall/update/forget)
-- `layer`: knowledge | daily | tacit (default: knowledge)
-- `category`: projects | areas | resources | archives (for layer=knowledge; default: resources)
-- `content`: fact or note body (required for ingest/update)
-- `caller`: command | master
-
----
-
-## Memory Architecture (PARA)
-
-Three layers, mirrored to `.monomind/orgs/<org_name>-memory/`:
-
-```
-.monomind/orgs/<org>-memory/
-  knowledge/              ← Layer 1: PARA knowledge graph
-    projects/<topic>/
-      summary.md
-      items.yaml
-    areas/<topic>/
-      summary.md
-      items.yaml
-    resources/<topic>/
-      summary.md
-      items.yaml
-    archives/<topic>/
-      summary.md
-      items.yaml
-    index.md
-  daily/                  ← Layer 2: Raw timeline (YYYY-MM-DD.md)
-  tacit.md                ← Layer 3: Org operating patterns
-```
-
-**PARA rules:**
-- **projects** — active work with a goal/deadline; archive when complete
-- **areas** — ongoing responsibilities, no end date
-- **resources** — reference material, topics of interest
-- **archives** — inactive items from any category
-
----
-
-## 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 — Resolve Memory Root
-
-```bash
-memRoot=".monomind/orgs/${org_name}-memory"
-mkdir -p "$memRoot/knowledge/projects" "$memRoot/knowledge/areas" \
-         "$memRoot/knowledge/resources" "$memRoot/knowledge/archives" \
-         "$memRoot/daily"
-```
-
----
-
-## Step 2 — Execute Action
-
-### ingest (default for new facts)
-
-Store a durable fact in Layer 1 (knowledge graph) or Layer 2 (daily note).
-
-```bash
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-day=$(date -u +%Y-%m-%d)
-layer="${layer:-knowledge}"
-category="${category:-resources}"
-topicSlug=$(echo "${topic:-general}" | tr '[:upper:]' '[:lower:]' | tr ' ' '-' | tr -cd 'a-z0-9-')
-
-if [ "$layer" = "daily" ]; then
-  dailyFile="$memRoot/daily/${day}.md"
-  [ ! -f "$dailyFile" ] && echo "# Daily Notes — ${day}" > "$dailyFile"
-  echo "" >> "$dailyFile"
-  echo "## [${ts}] ${topic:-note}" >> "$dailyFile"
-  echo "${content}" >> "$dailyFile"
-  echo "  [daily] Appended to $dailyFile"
-elif [ "$layer" = "tacit" ]; then
-  [ ! -f "$memRoot/tacit.md" ] && echo "# Org Operating Patterns — ${org_name}" > "$memRoot/tacit.md"
-  echo "" >> "$memRoot/tacit.md"
-  echo "## ${topic}" >> "$memRoot/tacit.md"
-  echo "${content}" >> "$memRoot/tacit.md"
-  echo "  [tacit] Pattern saved."
-else
-  # Layer 1: knowledge graph
-  entityDir="$memRoot/knowledge/${category}/${topicSlug}"
-  mkdir -p "$entityDir"
-  factId="fact-$(python3 -c 'import time; print(int(time.time()*1000))')"
-  python3 - "$entityDir/items.yaml" "$factId" "${topic}" "${content}" "$ts" <<'PYEOF'
-import sys, yaml, os
-path, fid, topic, body, ts = sys.argv[1:]
-facts = []
-if os.path.exists(path):
-    try:
-        with open(path) as f:
-            loaded = yaml.safe_load(f)
-            if isinstance(loaded, list): facts = loaded
-    except: pass
-facts.append({"id": fid, "topic": topic, "body": body, "createdAt": ts, "status": "active"})
-with open(path, "w") as f:
-    yaml.dump(facts, f, default_flow_style=False, allow_unicode=True)
-print(f"  Fact saved: {fid} → {path}")
-PYEOF
-fi
-```
-
-### recall / query
-
-Search org memory across all layers for a topic or keyword.
-
-```bash
-q="${topic:-${content}}"
-echo "MEMORY RECALL — ${org_name}"
-echo "Query: $q"
-echo "────────────────────────────────────────────────────────"
-
-python3 - "$memRoot" "$q" <<'PYEOF'
-import os, sys, yaml, re
-root, query = sys.argv[1], sys.argv[2].lower()
-results = []
-
-# Layer 1: scan items.yaml files
-kg = os.path.join(root, "knowledge")
-for cat in ["projects","areas","resources","archives"]:
-    cpath = os.path.join(kg, cat)
-    if not os.path.isdir(cpath): continue
-    for topic in os.listdir(cpath):
-        ypath = os.path.join(cpath, topic, "items.yaml")
-        if not os.path.exists(ypath): continue
-        try:
-            facts = yaml.safe_load(open(ypath)) or []
-            for f in facts:
-                if f.get("status") == "superseded": continue
-                body = str(f.get("body","")).lower()
-                ftopic = str(f.get("topic","")).lower()
-                if query in body or query in ftopic or query in topic.lower():
-                    results.append(("knowledge/"+cat+"/"+topic, f.get("createdAt","?")[:10], f.get("body","")[:120]))
-        except: pass
-
-# Layer 2: daily notes
-daily_dir = os.path.join(root, "daily")
-if os.path.isdir(daily_dir):
-    for fname in sorted(os.listdir(daily_dir), reverse=True)[:30]:
-        try:
-            text = open(os.path.join(daily_dir, fname)).read().lower()
-            if query in text:
-                results.append(("daily/"+fname, fname[:10], "(match in daily notes)"))
-        except: pass
-
-# Layer 3: tacit
-tacit = os.path.join(root, "tacit.md")
-if os.path.exists(tacit):
-    text = open(tacit).read().lower()
-    if query in text:
-        results.append(("tacit.md", "", "(match in org patterns)"))
-
-if not results:
-    print("  No matches found.")
-else:
-    print(f"  {len(results)} result(s):")
-    for path, date, body in results[:20]:
-        print(f"\n  [{date}] {path}")
-        print(f"    {body[:100]}{'...' if len(body)>100 else ''}")
-PYEOF
-```
-
-### list
-
-List all entities in the knowledge graph.
-
-```bash
-echo "KNOWLEDGE GRAPH — ${org_name}"
-echo "────────────────────────────────────────────────────────"
-
-python3 - "$memRoot/knowledge" <<'PYEOF'
-import os, sys, yaml
-kg = sys.argv[1]
-total = 0
-for cat in ["projects","areas","resources","archives"]:
-    cpath = os.path.join(kg, cat)
-    if not os.path.isdir(cpath): continue
-    topics = [d for d in os.listdir(cpath) if os.path.isdir(os.path.join(cpath,d))]
-    if not topics: continue
-    print(f"\n  {cat.upper()} ({len(topics)})")
-    for t in sorted(topics):
-        ypath = os.path.join(cpath, t, "items.yaml")
-        count = 0
-        try:
-            facts = yaml.safe_load(open(ypath)) or []
-            count = len([f for f in facts if f.get("status") != "superseded"])
-        except: pass
-        print(f"    · {t}  ({count} facts)")
-    total += len(topics)
-print(f"\n  Total entities: {total}")
-PYEOF
-```
-
-### forget
-
-Mark a fact as superseded (never delete — supersede).
-
-```bash
-topicSlug=$(echo "${topic}" | tr '[:upper:]' '[:lower:]' | tr ' ' '-' | tr -cd 'a-z0-9-')
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-category="${category:-resources}"
-entityDir="$memRoot/knowledge/${category}/${topicSlug}"
-ypath="$entityDir/items.yaml"
-
-python3 - "$ypath" "$ts" "${content:-forgot}" <<'PYEOF'
-import sys, yaml, os
-path, ts, reason = sys.argv[1], sys.argv[2], sys.argv[3]
-if not os.path.exists(path):
-    print("  No facts found for this entity.")
-    sys.exit(0)
-facts = yaml.safe_load(open(path)) or []
-active = [f for f in facts if f.get("status") == "active"]
-for f in active:
-    f["status"] = "superseded"
-    f["supersededAt"] = ts
-    f["supersededReason"] = reason
-with open(path, "w") as out:
-    yaml.dump(facts, out, default_flow_style=False, allow_unicode=True)
-print(f"  {len(active)} fact(s) superseded in {path}")
-PYEOF
-```
-
-### synthesize
-
-Rebuild summary.md for an entity from its active facts.
-
-```bash
-topicSlug=$(echo "${topic}" | tr '[:upper:]' '[:lower:]' | tr ' ' '-' | tr -cd 'a-z0-9-')
-category="${category:-resources}"
-entityDir="$memRoot/knowledge/${category}/${topicSlug}"
-ypath="$entityDir/items.yaml"
-[ ! -f "$ypath" ] && { echo "  No facts found for '${topic}'."; exit 0; }
-
-python3 - "$ypath" "$entityDir/summary.md" "${topic}" <<'PYEOF'
-import sys, yaml
-ypath, sumpath, topic = sys.argv[1], sys.argv[2], sys.argv[3]
-facts = [f for f in (yaml.safe_load(open(ypath)) or []) if f.get("status") == "active"]
-lines = [f"# {topic}", "", f"{len(facts)} active fact(s):", ""]
-for f in facts:
-    date = str(f.get("createdAt","?"))[:10]
-    lines.append(f"- [{date}] {f.get('body','')}")
-open(sumpath, "w").write("\n".join(lines) + "\n")
-print(f"  Summary rebuilt: {sumpath}")
-PYEOF
-```
-
-### decay
-
-Archive entities with no facts updated in the last 90 days.
-
-```bash
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-
-python3 - "$memRoot/knowledge" "$ts" <<'PYEOF'
-import os, sys, yaml, shutil
-from datetime import datetime, timedelta
-kg, ts = sys.argv[1], sys.argv[2]
-cutoff = datetime.utcnow() - timedelta(days=90)
-archived = 0
-for cat in ["projects","areas","resources"]:
-    cpath = os.path.join(kg, cat)
-    if not os.path.isdir(cpath): continue
-    for topic in os.listdir(cpath):
-        ypath = os.path.join(cpath, topic, "items.yaml")
-        if not os.path.exists(ypath): continue
-        try:
-            facts = yaml.safe_load(open(ypath)) or []
-            active = [f for f in facts if f.get("status") == "active"]
-            if not active: continue
-            last = max(f.get("createdAt","")[:19] for f in active)
-            dt = datetime.fromisoformat(last)
-            if dt < cutoff:
-                dst = os.path.join(kg, "archives", topic)
-                shutil.move(os.path.join(cpath, topic), dst)
-                archived += 1
-                print(f"  Archived: {cat}/{topic} (last active: {last[:10]})")
-        except: pass
-print(f"\n  Decay complete: {archived} entity/entities moved to archives.")
-PYEOF
-```
-
----
-
-## Step 3 — Return Output
-
-```yaml
-domain: ops
-status: complete
-action: <action>
-org_name: <org_name>
-layer: <layer>
-topic: <topic>
-```
-
----
-
-## Step 4 — Brain Write (standalone only)
-
-If `caller` is not "command", follow _protocol.md Brain Write Procedure for domain `ops`.

package/.claude/skills/mastermind/monotask.md

@@ -1,350 +0,0 @@
----
-name: mastermind-monotask
-description: Authoritative monotask CLI reference for mastermind agents — boards, columns, cards (with filters, subtasks, prerequisites, scoring, attachments), spaces, GitHub/Linear sync, and common agent workflows. Version 1.1.4.
-type: reference-skill
----
-
-# Monotask CLI — Agent Reference (v1.1.4)
-
-Monotask is a P2P local-first task manager. All data is stored in SQLite (`~/.local/share/monotask/monotask.db`). Always use `--json` for machine-readable output.
-
----
-
-## Global Flags
-
-```
---data-dir <PATH>   Override storage directory (must be consistent per instance)
-```
-
----
-
-## Board
-
-```bash
-# Create — returns {id, title, deep_link}
-monotask board create "Sprint 42" --json
-
-# List — returns [{id, title}] (search by title with jq .title)
-monotask board list --json
-
-# Rename
-monotask board rename <BOARD_ID> "New Title" --json
-```
-
----
-
-## Column
-
-```bash
-# Create — returns {id, board_id}
-monotask column create <BOARD_ID> "Todo" --json
-
-# List — returns [{id, title, card_ids:[]}]  ← field is "title", NOT "name"
-monotask column list <BOARD_ID> --json
-
-# Rename
-monotask column rename <BOARD_ID> <COL_ID> "New Title" --json
-
-# Delete (soft-deletes all cards in it)
-monotask column delete <BOARD_ID> <COL_ID> --json
-```
-
----
-
-## Card
-
-### Listing
-
-```bash
-# All cards in board (flat, includes col_id + col_title per card)
-monotask card list <BOARD_ID> --json
-
-# Filter by column (server-side, fast)
-monotask card list <BOARD_ID> --col <COL_ID> --json
-
-# Filter by label (server-side, exact match)
-monotask card list <BOARD_ID> --label "role:writer" --json
-
-# Combine filters
-monotask card list <BOARD_ID> --col <TODO_COL> --label "role:reviewer" --json
-```
-
-JSON schema per item from `card list`:
-```json
-{ "id":"<uuid>", "title":"<str>", "col_id":"<uuid>", "col_title":"<str>",
-  "labels":[], "due_date":null, "impact":null, "effort":null, "direct_priority":null }
-```
-
-### Create / View / Move
-
-```bash
-# Create — returns {id, title, board_id, number}
-CARD=$(monotask card create <BOARD_ID> <COL_ID> "Task title" --json | jq -r .id)
-
-# View full card (includes parent + subtasks)
-monotask card view <BOARD_ID> <CARD_ID> --json
-
-# Move to different column (auto-detects current column)
-monotask card move <BOARD_ID> <CARD_ID> <TO_COL_ID> --json
-
-# Copy to another column (same board)
-monotask card copy <BOARD_ID> <CARD_ID> <TARGET_COL_ID> --json
-
-# Rename
-monotask card rename <BOARD_ID> <CARD_ID> "New title" --json
-
-# Soft-delete (hidden from all views)
-monotask card delete <BOARD_ID> <CARD_ID> --json
-
-# Soft-archive (hidden from normal views)
-monotask card archive <BOARD_ID> <CARD_ID> --json
-```
-
-### Metadata
-
-```bash
-monotask card set-description <BOARD_ID> <CARD_ID> "Markdown text" --json
-monotask card set-due-date    <BOARD_ID> <CARD_ID> "2026-06-01" --json  # "none" to clear
-monotask card set-cover       <BOARD_ID> <CARD_ID> "#e74c3c" --json     # "none" to clear
-```
-
-### Priority / Scoring
-
-```bash
-# ICE scoring: priority = floor((impact + 10 - effort) / 2), range 0–10
-monotask card set-impact  <BOARD_ID> <CARD_ID> 8 --json
-monotask card set-effort  <BOARD_ID> <CARD_ID> 3 --json
-
-# Direct priority (bypasses impact/effort)
-monotask card set-direct-priority <BOARD_ID> <CARD_ID> 9 --json
-monotask card set-direct-priority <BOARD_ID> <CARD_ID> --clear --json
-
-# Clear all scoring
-monotask card clear-priority <BOARD_ID> <CARD_ID> --json
-```
-
-### Labels
-
-```bash
-monotask card label add    <BOARD_ID> <CARD_ID> "role:writer" --json
-monotask card label remove <BOARD_ID> <CARD_ID> "role:writer" --json
-monotask card label list   <BOARD_ID> <CARD_ID> --json  # → ["str",...]
-```
-
-**Convention for org agents:**
-- `role:<role_id>` — which role should handle this card
-- `claimed` — card has been picked up by an agent (in Doing column)
-
-### Assignee
-
-```bash
-# PUBKEY = 64-char hex (get via: monotask profile show)
-monotask card set-assignee <BOARD_ID> <CARD_ID> <PUBKEY> --json
-monotask card set-assignee <BOARD_ID> <CARD_ID> none --json  # clear
-```
-
-### Comments
-
-```bash
-monotask card comment add    <BOARD_ID> <CARD_ID> "text" --json
-monotask card comment list   <BOARD_ID> <CARD_ID> --json
-monotask card comment delete <BOARD_ID> <CARD_ID> <COMMENT_ID> --json
-```
-
-### Subtasks (parent/child hierarchy)
-
-```bash
-# Create a subtask (new card linked as child of PARENT_CARD)
-monotask card subtask add <PARENT_BOARD> <PARENT_CARD> <CHILD_BOARD> <COL_ID> "Subtask title" --json
-# → returns {id, title, board_id}
-
-# List subtasks of a card
-monotask card subtask list <BOARD_ID> <CARD_ID> --json
-# → [{board_id, card_id},...]
-
-# card view includes "subtasks" and "parent" fields automatically
-```
-
-### Prerequisites (dependency ordering)
-
-```bash
-# PREREQ_CARD must be Done before CARD can be claimed
-monotask card prerequisite add    <BOARD_ID> <CARD_ID> <PREREQ_BOARD> <PREREQ_CARD_ID> --json
-monotask card prerequisite list   <BOARD_ID> <CARD_ID> --json  # → [{board_id, card_id},...]
-monotask card prerequisite remove <BOARD_ID> <CARD_ID> <PREREQ_BOARD> <PREREQ_CARD_ID> --json
-```
-
-### Attachments
-
-```bash
-# Attach image (stored as base64; returns img:<6char-id> token for markdown)
-ATT=$(monotask card attach-image <BOARD_ID> <CARD_ID> screenshot.png --json | jq -r .token)
-monotask card set-description <BOARD_ID> <CARD_ID> "See: ![$ATT]($ATT)"
-
-monotask card list-attachments <BOARD_ID> <CARD_ID> --json
-monotask card save-attachment  <BOARD_ID> <CARD_ID> <ATTACHMENT_ID> --output ./out.png
-```
-
-### Checklists
-
-```bash
-CL=$(monotask checklist add      <BOARD_ID> <CARD_ID> "Definition of Done" --json | jq -r .id)
-ITEM=$(monotask checklist item-add   <BOARD_ID> <CARD_ID> $CL "Write tests" --json | jq -r .id)
-monotask checklist item-check   <BOARD_ID> <CARD_ID> $CL $ITEM
-monotask checklist item-uncheck <BOARD_ID> <CARD_ID> $CL $ITEM
-```
-
----
-
-## Space (Collaboration)
-
-```bash
-# Create / list
-monotask space create "Team Name"
-monotask space list   # → "<id> | <name> | <N> members"
-monotask space info <SPACE_ID>
-
-# Associate boards
-monotask space boards add    <SPACE_ID> <BOARD_ID>
-monotask space boards remove <SPACE_ID> <BOARD_ID>
-monotask space boards list   <SPACE_ID>
-
-# Invite / join
-monotask space invite export  <SPACE_ID> invite.space  # preferred (includes space doc)
-monotask space invite generate <SPACE_ID>               # token only
-monotask space invite revoke   <SPACE_ID>
-monotask space join invite.space                        # or raw token
-
-# Members
-monotask space members list <SPACE_ID>
-monotask space members kick <SPACE_ID> <PUBKEY>
-```
-
----
-
-## GitHub Integration
-
-```bash
-monotask github connect ghp_yourtoken           # save token
-monotask github repos                           # list accessible repos
-monotask github link <BOARD_ID> <ORG> <REPO> --done-col <COL_ID>  # link repo
-monotask github unlink <BOARD_ID>
-monotask github sync <BOARD_ID>                 # bidirectional sync
-```
-
----
-
-## Linear Integration
-
-```bash
-monotask linear connect lin_api_yourkey         # save key
-monotask linear status
-monotask linear teams                           # list teams
-monotask linear projects <TEAM_ID>
-monotask linear link <BOARD_ID> --team <TEAM_ID> --project <PROJECT_ID> [--done-col <COL_ID>]
-monotask linear unlink <BOARD_ID>
-monotask linear sync <BOARD_ID>                 # bidirectional sync
-```
-
----
-
-## P2P Sync Daemon
-
-```bash
-monotask sync --detach --port 7272              # start background daemon
-monotask sync --status
-monotask sync --stop
-monotask sync --peer /ip4/192.168.1.10/tcp/7272 # connect to known peer
-```
-
----
-
-## Profile
-
-```bash
-monotask profile show
-monotask profile set-name "Alice"
-monotask profile set-avatar ~/avatar.png
-monotask profile import-ssh-key ~/.ssh/id_ed25519  # changes pubkey — run before joining spaces
-```
-
----
-
-## Common Agent Workflows
-
-### Set up an org task board
-```bash
-BOARD=$(monotask board create "org-tasks" --json | jq -r .id)
-TODO=$(monotask column create $BOARD "Todo"  --json | jq -r .id)
-DOING=$(monotask column create $BOARD "Doing" --json | jq -r .id)
-DONE=$(monotask column create $BOARD "Done"  --json | jq -r .id)
-```
-
-### Task assignment loop (boss agent pattern)
-```bash
-# List unclaimed Todo cards
-monotask card list $BOARD --col $TODO --json | jq '[.[] | select(.labels | index("claimed") | not)]'
-
-# Claim a card for a role agent
-monotask card move $BOARD $CARD_ID $DOING
-monotask card label add $BOARD $CARD_ID "claimed"
-
-# Complete a card
-monotask card move $BOARD $CARD_ID $DONE
-
-# Find all cards for a specific role across all columns
-monotask card list $BOARD --label "role:writer" --json
-```
-
-### Check prerequisites before claiming
-```bash
-# Get prereqs of a card
-PREREQS=$(monotask card prerequisite list $BOARD $CARD_ID --json)
-# Check all prereqs are in Done column
-echo "$PREREQS" | jq -r '.[].card_id' | while read PREREQ_ID; do
-  COL=$(monotask card list $BOARD --json | jq -r --arg id "$PREREQ_ID" '.[] | select(.id==$id) | .col_id')
-  [ "$COL" != "$DONE" ] && echo "BLOCKED: $PREREQ_ID not done" && exit 1
-done
-```
-
-### Find board by title
-```bash
-BOARD_ID=$(monotask board list --json | jq -r '.[] | select(.title=="org-tasks") | .id')
-```
-
-### Find column by title  (field is "title", NOT "name")
-```bash
-COLS=$(monotask column list $BOARD --json)
-TODO=$(echo "$COLS" | jq -r '.[] | select(.title=="Todo") | .id')
-DONE=$(echo "$COLS" | jq -r '.[] | select(.title=="Done") | .id')
-```
-
----
-
-## ID Formats
-
-| Type | Format |
-|---|---|
-| Board / Column / Card / Space / Comment / Checklist | UUID v4 |
-| Attachment | 6-char hex (reference as `img:<id>` in markdown) |
-| Card number | `<prefix>-<seq>` — human display only; CLI requires full UUID |
-
-## HLC Timestamps
-
-All `created_at` fields use Hybrid Logical Clock format `<wall_ms_hex>-<logical_hex>`.
-
-```js
-ms = parseInt(hlc.split('-')[0], 16)     // → Unix ms
-new Date(ms).toISOString()               // → ISO date
-```
-
-## Error Handling
-
-All commands exit 0 on success, non-zero on error. Errors go to stderr (never mixed into `--json` stdout). Common causes: ID not found, invalid UUID, corrupted board file, invalid invite token.
-
-## Key Limitations
-
-- CLI operates on **local data only** — P2P sync requires the desktop app or `sync --detach`
-- `card create` uses placeholder prefix `"aaaa"` for card numbers (full identity wiring planned)
-- No `board delete` command — orphaned boards must be removed via SQLite directly
-- `card move` auto-detects current column — no need to specify source column