@monoes/monomindcli 2.10.9 → 2.10.13

package/.claude/skills/mastermind-liveness/SKILL.md

@@ -64,6 +64,38 @@ issuesFile=".monomind/orgs/${org_name}-issues.json"
 stateFile=".monomind/orgs/${org_name}-state.json"
 ```
 
+Normalize any legacy records written by a pre-2.10 version of these skills. Idempotent — safe to run on every load. Guarded because this skill tolerates a missing issues file.
+
+```bash
+[ -f "$issuesFile" ] && python3 - "$issuesFile" <<'PYEOF'
+import json, sys
+path = sys.argv[1]
+data = json.load(open(path))
+RENAME = {
+    "assignee_id": "assigneeId", "assigned_to": "assigneeId",
+    "created_at": "createdAt", "updated_at": "updatedAt",
+    "closed_at": "closedAt", "project_id": "projectId",
+    "parent_id": "parentId", "recovery_status": "recoveryStatus",
+    "lastActivityAt": "updatedAt",
+}
+changed = False
+for iss in data.get("issues", []):
+    for old, new in RENAME.items():
+        if old in iss:
+            iss.setdefault(new, iss.pop(old))
+            iss.pop(old, None)
+            changed = True
+    if iss.get("status") == "open":
+        iss["status"] = "todo"
+        changed = True
+if changed:
+    tmp = path + ".tmp"
+    with open(tmp, "w") as f:
+        json.dump(data, f, indent=2)
+    import os; os.replace(tmp, path)
+PYEOF
+```
+
 ---
 
 ## Step 2 — Execute Action
@@ -108,35 +140,44 @@ now = datetime.utcnow()
 
 for iss in issues:
     status = iss.get("status","")
-    if status in terminal_statuses or status not in non_terminal_statuses:
+    iid    = iss.get("id","?")
+    title  = (iss.get("title") or "?")[:50]
+
+    if status in terminal_statuses:
+        continue
+    if status not in non_terminal_statuses:
+        # Silently skipping an unknown status is how issues become invisible.
+        warnings.append((iid, title, status, f"unknown status '{status}' — outside the canonical vocabulary"))
         continue
 
-    aId = iss.get("assigneeAgentId") or iss.get("assigneeId")
+    aId = iss.get("assigneeAgentId")
     uId = iss.get("assigneeUserId")
-    iid = iss.get("id","?")
-    title = iss.get("title","?")[:50]
 
-    # User-owned: skip strict execution checks
+    # Human-owned: the next move belongs to a person, not an execution path.
     if uId and not aId:
         healthy.append((iid, title, status, "user-owned"))
         continue
 
-    # Evaluate liveness
     paths = []
 
     run_id = iss.get("executionRunId") or iss.get("checkoutRunId")
     if run_id and run_id in active_runs:
         paths.append("active-run")
 
+    resolved_ids = {i.get("id") for i in issues if i.get("status") in terminal_statuses}
     blockers = iss.get("blockedByIssueIds") or []
-    if status == "blocked" and blockers:
-        unresolved = [b for b in blockers if b not in
-                      {i["id"] for i in issues if i.get("status") in terminal_statuses}]
-        if unresolved:
-            paths.append(f"blocked-by:{','.join(unresolved[:2])}")
-        else:
-            # All blockers resolved — should transition
-            warnings.append((iid, title, status, "all blockers resolved but issue still blocked"))
+    if status == "blocked":
+        if blockers:
+            unresolved = [b for b in blockers if b not in resolved_ids]
+            if unresolved:
+                paths.append(f"blocked-by:{','.join(unresolved[:2])}")
+            else:
+                warnings.append((iid, title, status, "all blockers resolved but issue still blocked"))
+        elif not iss.get("recoveryActions"):
+            # Liveness Contract: blocked requires a named dependency or an
+            # explicit human decision. This issue records neither.
+            stalled.append((iid, title, status, "blocked with no blockedByIssueIds and no recovery action"))
+            continue
 
     if iss.get("executionPolicy", {}).get("monitor", {}).get("nextCheckAt"):
         paths.append("monitor")
@@ -150,7 +191,10 @@ for iss in issues:
     if iss.get("currentParticipant"):
         paths.append("participant")
 
-    # Stale heartbeat check (in_progress with no run and no recent update)
+    if status == "in_review" and not (iss.get("reviewerId") or iss.get("currentParticipant")):
+        stalled.append((iid, title, status, "in_review with no named reviewer"))
+        continue
+
     if status == "in_progress" and aId and not paths:
         updated = iss.get("updatedAt","")
         if updated:
@@ -159,16 +203,19 @@ for iss in issues:
                 if age > timedelta(hours=2):
                     stalled.append((iid, title, status, f"in_progress {int(age.total_seconds()//3600)}h with no active path"))
                     continue
-            except: pass
+            except Exception:
+                pass
         stalled.append((iid, title, status, "in_progress with no active execution path"))
         continue
 
-    if not paths and status == "todo" and aId:
-        warnings.append((iid, title, status, "todo assigned to agent — may need wakeup"))
-    elif paths:
+    if paths:
         healthy.append((iid, title, status, " + ".join(paths)))
+    elif not aId:
+        warnings.append((iid, title, status, "no assignee — nothing will pick this up"))
+    elif status == "todo":
+        warnings.append((iid, title, status, "todo assigned to agent — may need wakeup"))
     else:
-        healthy.append((iid, title, status, "no agent assignee"))
+        stalled.append((iid, title, status, f"{status} with an agent assignee but no execution path"))
 
 print(f"  ✓ Healthy: {len(healthy)}")
 if healthy:
@@ -206,7 +253,7 @@ Claim an issue for execution by an agent run. Sets `checkoutRunId` and `executio
 ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 
 python3 - "$issuesFile" "$issue_id" "$agent_id" "$run_id" "$ts" <<'PYEOF'
-import json, sys
+import json, os, sys
 
 path, iid, agentId, runId, ts = sys.argv[1:]
 data = json.load(open(path))
@@ -224,6 +271,7 @@ for iss in issues:
         iss["executionRunId"] = runId
         iss["assigneeId"]     = agentId
         iss["assigneeAgentId"]= agentId
+        iss["assigneeUserId"] = None
         iss["status"]         = "in_progress"
         iss["checkedOutAt"]   = ts
         iss["updatedAt"]      = ts
@@ -237,9 +285,16 @@ if not found:
     sys.exit(1)
 
 data["issues"] = issues
-with open(path, "w") as f:
+tmp = path + ".tmp"
+with open(tmp, "w") as f:
     json.dump(data, f, indent=2)
+os.replace(tmp, path)
 PYEOF
+
+activityFile=".monomind/orgs/${org_name}-activity.jsonl"
+jq -cn --arg iid "$issue_id" --arg ts "$ts" --arg st "in_progress" --arg ag "$agent_id" --arg sm "checkout $issue_id" \
+  '{issue_id:$iid, ts:$ts, status:$st, tokens:null, agent:$ag, type:"checkout", summary:$sm}' \
+  >> "$activityFile"
 ```
 
 ### release
@@ -269,13 +324,21 @@ for iss in issues:
         print(f"  RELEASED: Checkout cleared for issue {iid}")
         print(f"  Status remains: {iss.get('status','?')} — update separately if needed.")
         data["issues"] = issues
-        with open(path, "w") as f:
+        tmp = path + ".tmp"
+        with open(tmp, "w") as f:
             json.dump(data, f, indent=2)
+        os.replace(tmp, path)
         sys.exit(0)
 
 print(f"  ERROR: Issue '{iid}' not found.")
 sys.exit(1)
 PYEOF
+
+activityFile=".monomind/orgs/${org_name}-activity.jsonl"
+currentStatus=$(jq -r --arg id "$issue_id" '(.issues // [])[] | select(.id == $id) | .status // "todo"' "$issuesFile")
+jq -cn --arg iid "$issue_id" --arg ts "$ts" --arg st "$currentStatus" --arg ag "${agent_id:-operator}" --arg sm "release $issue_id" \
+  '{issue_id:$iid, ts:$ts, status:$st, tokens:null, agent:$ag, type:"release", summary:$sm}' \
+  >> "$activityFile"
 ```
 
 ### wakeup
@@ -296,7 +359,7 @@ if not iss:
     print(f"  ERROR: Issue '{iid}' not found.")
     sys.exit(1)
 
-checkout_agent = iss.get("assigneeAgentId") or iss.get("assigneeId","")
+checkout_agent = iss.get("assigneeAgentId") or ""
 checkout_run   = iss.get("checkoutRunId","")
 
 # Port of Paperclip's shouldWakeAssigneeOnCheckout logic
@@ -338,7 +401,7 @@ ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 recoveryId="recovery-$(python3 -c 'import time; print(int(time.time()*1000))')"
 
 python3 - "$issuesFile" "$issue_id" "$recoveryId" "${agent_id:-operator}" "$reason" "$ts" <<'PYEOF'
-import json, sys
+import json, os, sys
 
 path, iid, rid, owner, cause, ts = sys.argv[1:]
 data = json.load(open(path))
@@ -359,8 +422,10 @@ for iss in issues:
         iss["status"] = "blocked"
         iss["updatedAt"] = ts
         data["issues"] = issues
-        with open(path, "w") as f:
+        tmp = path + ".tmp"
+        with open(tmp, "w") as f:
             json.dump(data, f, indent=2)
+        os.replace(tmp, path)
         print(f"  RECOVERY ACTION FILED: {rid}")
         print(f"  Issue {iid} → status: blocked (pending recovery)")
         print(f"  Owner: {owner}")
@@ -371,6 +436,11 @@ for iss in issues:
 print(f"  ERROR: Issue '{iid}' not found.")
 sys.exit(1)
 PYEOF
+
+activityFile=".monomind/orgs/${org_name}-activity.jsonl"
+jq -cn --arg iid "$issue_id" --arg ts "$ts" --arg st "blocked" --arg ag "${agent_id:-operator}" --arg sm "recover $issue_id" \
+  '{issue_id:$iid, ts:$ts, status:$st, tokens:null, agent:$ag, type:"recover", summary:$sm}' \
+  >> "$activityFile"
 ```
 
 ---

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

@@ -319,319 +319,3 @@ topic: <topic>
 ## Step 4 — Brain Write (standalone only)
 
 If `caller` is not "command", follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.
-# monomind:start skills:claude:mastermind-memory
-# 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 mastermind-protocol/SKILL.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 mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.
-# monomind:end skills:claude:mastermind-memory

package/.claude/skills/mastermind-my-issues/SKILL.md

@@ -18,7 +18,7 @@ This skill is invoked by `mastermind:my-issues` or directly via `/mastermind:my-
 - `action`: list | assign-self | unassign | close
 - `assignee_id`: user/agent id to filter by (default: local-operator)
 - `issue_id`: issue id (required for assign-self / unassign / close)
-- `status_filter`: open | in_progress | all (default: open+in_progress)
+- `status_filter`: active | todo | in_progress | blocked | in_review | done | cancelled | all (default: active = todo+in_progress)
 - `caller`: command | master
 
 ---
@@ -41,6 +41,38 @@ issuesFile=".monomind/orgs/${org_name}-issues.json"
 assigneeFilter="${assignee_id:-local-operator}"
 ```
 
+Normalize any legacy records written by a pre-2.10 version of these skills. Idempotent — safe to run on every load.
+
+```bash
+python3 - "$issuesFile" <<'PYEOF'
+import json, sys
+path = sys.argv[1]
+data = json.load(open(path))
+RENAME = {
+    "assignee_id": "assigneeId", "assigned_to": "assigneeId",
+    "created_at": "createdAt", "updated_at": "updatedAt",
+    "closed_at": "closedAt", "project_id": "projectId",
+    "parent_id": "parentId", "recovery_status": "recoveryStatus",
+    "lastActivityAt": "updatedAt",
+}
+changed = False
+for iss in data.get("issues", []):
+    for old, new in RENAME.items():
+        if old in iss:
+            iss.setdefault(new, iss.pop(old))
+            iss.pop(old, None)
+            changed = True
+    if iss.get("status") == "open":
+        iss["status"] = "todo"
+        changed = True
+if changed:
+    tmp = path + ".tmp"
+    with open(tmp, "w") as f:
+        json.dump(data, f, indent=2)
+    import os; os.replace(tmp, path)
+PYEOF
+```
+
 ---
 
 ## Step 2 — Execute Action
@@ -57,19 +89,19 @@ echo "────────────────────────
 jq -r --arg uid "$assigneeFilter" --arg sf "$statusFilter" '
   (.issues // [])[] |
   select(
-    (.assigneeId == $uid or .assigned_to == $uid) and
-    (if $sf == "active" then (.status == "open" or .status == "in_progress")
+    (.assigneeId == $uid) and
+    (if $sf == "active" then (.status == "todo" or .status == "in_progress")
      elif $sf == "all" then true
      else .status == $sf
      end)
   ) |
-  [.id, (.status // "open"), (.priority // "medium"), (.title // "(no title)")] | @tsv
+  [.id, (.status // "todo"), (.priority // "medium"), (.title // "(no title)")] | @tsv
 ' "$issuesFile" | while IFS=$'\t' read -r id st pri title; do
   printf "%-24s %-12s %-10s %s\n" "$id" "$st" "$pri" "$title"
 done
 
 total=$(jq -r --arg uid "$assigneeFilter" \
-  '[(.issues // [])[] | select(.assigneeId == $uid or .assigned_to == $uid)] | length' \
+  '[(.issues // [])[] | select(.assigneeId == $uid)] | length' \
   "$issuesFile")
 echo ""
 echo "Total assigned: $total"
@@ -88,7 +120,7 @@ ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 tmp="${issuesFile}.tmp"
 jq --arg id "$issue_id" --arg uid "$assigneeFilter" --arg ts "$ts" \
   '.issues = [(.issues // [])[] | if .id == $id then
-     .assigneeId = $uid | .lastActivityAt = $ts
+     .assigneeId = $uid | .assigneeUserId = $uid | .assigneeAgentId = null | .updatedAt = $ts
    else . end]' \
   "$issuesFile" > "$tmp" && mv "$tmp" "$issuesFile"
 
@@ -104,7 +136,7 @@ ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 tmp="${issuesFile}.tmp"
 jq --arg id "$issue_id" --arg ts "$ts" \
   '.issues = [(.issues // [])[] | if .id == $id then
-     .assigneeId = null | .lastActivityAt = $ts
+     .assigneeId = null | .assigneeUserId = null | .assigneeAgentId = null | .updatedAt = $ts
    else . end]' \
   "$issuesFile" > "$tmp" && mv "$tmp" "$issuesFile"
 
@@ -120,7 +152,7 @@ ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 tmp="${issuesFile}.tmp"
 jq --arg id "$issue_id" --arg ts "$ts" \
   '.issues = [(.issues // [])[] | if .id == $id then
-     .status = "done" | .closedAt = $ts | .lastActivityAt = $ts
+     .status = "done" | .closedAt = $ts | .updatedAt = $ts
    else . end]' \
   "$issuesFile" > "$tmp" && mv "$tmp" "$issuesFile"
 

package/.claude/skills/mastermind-org/SKILL.md

@@ -14,16 +14,5 @@ Use the `monomind org` commands as the portable organization control surface.
 - Stop a running organization with `monomind org stop <name>`.
 
 Before changing organization configuration, inspect its current status and preserve the user's explicit goal, budget, and safety constraints. Use the platform's native task and agent interfaces when available; otherwise keep the CLI as the functional source of truth.
-# monomind:start skills:claude:mastermind-org
-# Mastermind Organization
-
-Use the `monomind org` commands as the portable organization control surface.
-
-- Create or configure an organization with `monomind org create` or the platform's organization workflow.
-- Run an organization once with `monomind org run <name>`.
-- Host scheduled organizations with `monomind org serve`.
-- Inspect status with `monomind org status [name]` and validate configuration with `monomind org validate [name]`.
-- Stop a running organization with `monomind org stop <name>`.
 
-Before changing organization configuration, inspect its current status and preserve the user's explicit goal, budget, and safety constraints. Use the platform's native task and agent interfaces when available; otherwise keep the CLI as the functional source of truth.
-# monomind:end skills:claude:mastermind-org
+The org runtime does not read `<org>-issues.json`. Work is driven by the org definition's roles and goal plus an optional `--task` string.