@monoes/monomindcli 2.10.4 → 2.10.6

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

@@ -275,3 +275,277 @@ Systematic approach vs random fixing:
 - Time to fix: 15-30 min vs 2-3 hours of thrashing
 - First-time fix rate: ~95% vs ~40%
 - New bugs introduced by the fix: near zero vs common
+# monomind:start skills:claude:mastermind-debug
+# mastermind:debug — Systematic Debugging
+
+## Overview
+
+Random fixes waste time and create new bugs. Quick patches mask underlying issues.
+
+**Core principle:** ALWAYS find root cause before attempting fixes. Symptom fixes are failure.
+
+**Violating the letter of this process is violating the spirit of debugging.**
+
+## The Iron Law
+
+```
+NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST
+```
+
+If you haven't completed Phase 1, you cannot propose fixes.
+
+## When to Use
+
+Use for ANY technical issue:
+- Test failures
+- Bugs in production or staging
+- Unexpected behavior
+- Performance regressions
+- Build failures
+- Integration issues
+
+**Use this ESPECIALLY when:**
+- Under time pressure (emergencies make guessing tempting)
+- "Just one quick fix" seems obvious
+- You've already tried multiple fixes that didn't work
+- Previous fix didn't resolve the issue
+- You don't fully understand what's happening
+
+**Don't skip when:**
+- Issue seems simple (simple bugs have root causes too)
+- You're in a hurry (systematic is faster than thrashing)
+- The user wants it fixed immediately (systematic approach finds the real fix faster)
+
+## The Four Phases
+
+You MUST complete each phase before proceeding to the next.
+
+---
+
+### Phase 1: Root Cause Investigation
+
+**BEFORE attempting ANY fix:**
+
+1. **Read Error Messages Carefully**
+   - Don't skim errors or warnings
+   - They often contain the exact solution
+   - Read stack traces completely
+   - Note line numbers, file paths, error codes
+
+2. **Reproduce Consistently**
+   - Can you trigger the issue reliably?
+   - What are the exact steps?
+   - Does it happen every time?
+   - If not reproducible → gather more data, don't guess
+
+3. **Check Recent Changes**
+   - What changed that could cause this?
+   - `git diff`, recent commits, new dependencies, config changes
+   - Environmental differences between working and broken states
+
+4. **Gather Evidence in Multi-Component Systems**
+
+   **WHEN the system has multiple components (CI → build → deploy, API → service → database):**
+
+   **BEFORE proposing fixes, add diagnostic instrumentation:**
+   ```
+   For EACH component boundary:
+     - Log what data enters the component
+     - Log what data exits the component
+     - Verify config/env propagation at each layer
+     - Check state at each boundary
+
+   Run once to gather evidence showing WHERE it breaks
+   THEN analyze evidence to identify the failing component
+   THEN investigate that specific component
+   ```
+
+   **Example:**
+   ```bash
+   # Layer 1: entry point
+   echo "=== Input received: ==="
+   echo "VAR: ${VAR:+SET}${VAR:-UNSET}"
+
+   # Layer 2: processing
+   echo "=== State after processing: ==="
+   env | grep VAR || echo "VAR not in environment"
+
+   # Layer 3: output/result
+   echo "=== Final state: ==="
+   ```
+
+5. **Trace Data Flow**
+
+   **WHEN the error is deep in a call stack:**
+   - Where does the bad value originate?
+   - What called this with the bad value?
+   - Keep tracing up until you find the source
+   - Fix at the source, not at the symptom — a `null` crashing in layer 4 usually entered in layer 1
+
+---
+
+### Phase 2: Pattern Analysis
+
+Once you understand WHERE the break is, find existing working examples:
+
+1. **Find working code that solves the same problem**
+   - Search the codebase for similar patterns
+   - Check git history for when this worked
+   - Find the canonical implementation to compare against
+
+2. **Compare against references**
+   - If implementing a pattern, read the reference implementation COMPLETELY
+   - Don't skim — read every line
+   - Understand the pattern fully before applying it
+
+3. **Compare broken vs. working**
+   - What's different?
+   - List every difference, not just the obvious one — don't assume "that can't matter"
+   - Environment, config, data, timing
+
+4. **Understand dependencies**
+   - What other components does this need?
+   - What settings, config, environment?
+   - What assumptions does it make?
+
+---
+
+### Phase 3: Form and Test a Hypothesis
+
+1. **State your hypothesis explicitly:**
+   > "I believe the root cause is [X] because [evidence Y] and [evidence Z]."
+
+2. **Test the hypothesis minimally**
+   - Change one thing and observe the result
+   - If it doesn't confirm or deny, gather more evidence
+   - A confirmed hypothesis means you understand the root cause
+
+3. **If hypothesis is wrong:** Do NOT add more fixes. Return to Phase 1 with the new information.
+
+4. **When you don't know:** Say "I don't understand X". Don't pretend to know. Research more or ask the user — a stated unknown beats a confident guess.
+
+---
+
+### Phase 4: Implementation
+
+1. **Write a failing test first** (before touching production code)
+   - Automated test where possible; a one-off test script if no framework
+   - Use `Skill("mastermind-tdd")` for writing proper failing tests
+   - The test MUST fail before the fix proves it
+
+2. **Implement a single fix**
+   - Address the root cause identified in Phase 3
+   - ONE change at a time
+   - No "while I'm here" improvements
+   - No bundled refactoring
+
+3. **Verify the fix**
+   - Test passes now?
+   - No other tests broken?
+   - Issue actually resolved?
+   - Use `Skill("mastermind-review")` to verify before declaring done
+
+4. **If the fix doesn't work:**
+   - STOP
+   - Count: How many fixes have you tried?
+   - If < 3: Return to Phase 1, re-analyze with the new information
+   - **If ≥ 3: STOP — this is likely an architectural problem (see Phase 4.5 below)**
+   - Do NOT attempt a 4th fix without architectural discussion
+
+---
+
+### Phase 4.5 — If 3+ Fixes Have Failed: Question the Architecture
+
+**Pattern indicating an architectural problem:**
+- Each fix reveals new coupling or shared state issues in a different place
+- Each fix creates new symptoms elsewhere
+- Fixes require "massive refactoring" to implement cleanly
+
+**STOP and question fundamentals:**
+- Is this design pattern fundamentally sound?
+- Are we continuing out of inertia?
+- Should we refactor the architecture rather than continue patching?
+
+**Discuss with the user before attempting more fixes.** This is not a failed hypothesis — this is the wrong architecture.
+
+---
+
+## Red Flags — STOP and Return to Phase 1
+
+If you catch yourself thinking or doing any of these:
+
+| Thought / Action | What it means |
+|---|---|
+| "Quick fix for now, investigate later" | You're skipping root cause. Return to Phase 1. |
+| "Just try changing X and see if it works" | Guessing. Return to Phase 1. |
+| "Add multiple changes, run tests" | Can't isolate what worked. Return to Phase 1. |
+| "Skip the test, I'll manually verify" | Untested fixes don't stick. Write the failing test. |
+| "Pattern says X but I'll adapt it differently" | Partial understanding guarantees bugs. Read the reference completely. |
+| "Here are the main problems: …" (listing fixes without investigation) | Solutions before evidence. Return to Phase 1. |
+| "It's probably X, let me fix that" | Assumed root cause. Verify it first. Return to Phase 1. |
+| "I don't fully understand but this might work" | You don't have a hypothesis. Return to Phase 1. |
+| Proposing solutions before tracing data flow | No root cause. Return to Phase 1. |
+| "One more fix attempt" (already tried 2+) | 3+ failures = architectural problem. Phase 4.5. |
+| Each fix reveals a new problem in a different place | Architectural problem. Phase 4.5. |
+
+## User Signals You're Doing It Wrong
+
+Watch for these redirections from the user:
+
+| Signal | What it means |
+|---|---|
+| "Is that actually happening?" | You assumed without verifying. Add evidence gathering. |
+| "What does the output show?" | You should have checked before proposing a fix. |
+| "Stop guessing" | You're proposing fixes without root cause. Phase 1. |
+| "We keep going in circles" | 3+ fix attempts = architectural problem. Phase 4.5. |
+
+## Common Rationalizations
+
+| Excuse | Reality |
+|---|---|
+| "Issue is simple, don't need process" | Simple issues have root causes too. Process is fast for simple bugs. |
+| "Emergency, no time for process" | Systematic debugging is FASTER than guess-and-check thrashing. |
+| "Just try this first, then investigate" | First fix sets the pattern. Do it right from the start. |
+| "I'll write the test after confirming the fix works" | Untested fixes don't stick. Test first proves it. |
+| "Multiple fixes at once saves time" | Can't isolate what worked. Creates new bugs. |
+| "Reference too long, I'll adapt the pattern" | Partial understanding guarantees bugs. Read it completely. |
+| "I can see the problem, let me fix it" | Seeing symptoms ≠ understanding root cause. |
+| "One more fix attempt" (after 2+ failures) | 3+ failures = architectural problem. Question the pattern. |
+
+## Quick Reference
+
+| Phase | Key Activities | Success Criteria |
+|---|---|---|
+| **1. Root Cause** | Read errors, reproduce, check changes, gather evidence | Understand WHAT and WHY |
+| **2. Pattern** | Find working examples, compare | Identified differences |
+| **3. Hypothesis** | Form theory, test minimally | Confirmed or new hypothesis |
+| **4. Implementation** | Write failing test, fix, verify | Bug resolved, tests pass |
+
+## When the Process Reveals "No Root Cause"
+
+If systematic investigation reveals the issue is truly environmental, timing-dependent, or external:
+
+1. You've completed the process
+2. Document what you investigated
+3. Implement appropriate handling (retry, timeout, clear error message)
+4. Add monitoring/logging for future investigation
+
+**But:** 95% of "no root cause" cases are incomplete investigation.
+
+## Supporting Techniques
+
+- **Root-cause tracing:** when a bad value crashes deep in the stack, trace it backward caller by caller until you find where it was created; fix there. Adding a guard at the crash site only hides the origin.
+- **Defense in depth:** AFTER fixing the root cause, add validation at the layers the bad value passed through unchecked — so the next bad value fails loudly at its first boundary, not silently at its fourth.
+- **Condition-based waiting:** replace arbitrary sleeps/timeouts in flaky tests and scripts with polling for the actual condition ("wait until the file exists / the port answers"), with a hard cap. Timing guesses are bugs waiting for a slower machine.
+
+**Related skills:**
+- `Skill("mastermind-tdd")` — for creating the failing test case (Phase 4, Step 1)
+- `Skill("mastermind-verify")` — verify the fix worked before claiming success
+
+## Impact
+
+Systematic approach vs random fixing:
+- Time to fix: 15-30 min vs 2-3 hours of thrashing
+- First-time fix rate: ~95% vs ~40%
+- New bugs introduced by the fix: near zero vs common
+# monomind:end skills:claude:mastermind-debug

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

@@ -102,3 +102,102 @@ After all tasks complete and are verified:
 - `Skill("mastermind-taskdev")` — subagent-driven parallel task execution (preferred for complex plans)
 - `Skill("mastermind-finish")` — complete the development branch after all tasks
 - `Skill("mastermind-verify")` — verification gate before finishing
+# monomind:start skills:claude:mastermind-execute
+# Mastermind Execute
+
+Load plan, review critically, execute all tasks, report when complete.
+
+**Announce at start:** "I'm using the mastermind:execute skill to implement this plan."
+
+**Note:** This skill works best with subagent support (Claude Code). When subagents are available, prefer `Skill("mastermind-taskdev")` for parallel task execution.
+
+---
+
+## Inputs
+
+- `brain_context`: BRAIN CONTEXT block (injected by master, or loaded standalone via mastermind-protocol/SKILL.md brain load)
+- `plan_path`: path to the plan file to execute
+- `project_name`: monotask space name
+- `board_id`: monotask board ID
+- `mode`: auto | confirm
+
+---
+
+## The Process
+
+### Step 1: Load and Review Plan
+
+1. Read the plan file at `plan_path`
+2. Review critically — identify any questions or concerns:
+   - Missing dependencies or prerequisites
+   - Ambiguous instructions
+   - Steps that contradict each other
+   - Verifications that cannot be run
+3. If concerns exist: raise them with the user before starting
+4. If no concerns: create a TodoWrite with each task and proceed
+
+### Step 2: Execute Tasks
+
+For each task in the plan:
+
+1. Mark as `in_progress`
+2. Follow each step exactly — the plan has bite-sized steps; do not skip or reorder
+3. Run verifications as specified in the plan
+4. Mark as `completed`
+
+When the plan references skills:
+- `mastermind:taskdev` → invoke `Skill("mastermind-taskdev")`
+- `mastermind:verify` → invoke `Skill("mastermind-verify")`
+- Any other `mastermind:*` skill → invoke `Skill("mastermind-<name>")`
+
+### Step 3: Complete Development
+
+After all tasks complete and are verified:
+
+- Announce: "All tasks complete. Handing off to mastermind:finish."
+- **REQUIRED SUB-SKILL:** invoke `Skill("mastermind-finish")`
+- Follow that skill to verify tests, present options, and execute the chosen finish action
+
+---
+
+## When to Stop and Ask for Help
+
+**STOP executing immediately when:**
+- A blocker is encountered (missing dependency, failing test, unclear instruction)
+- The plan has critical gaps preventing a task from starting
+- An instruction cannot be understood without guessing
+- A verification fails repeatedly (more than twice)
+
+**Ask for clarification rather than guessing.** Never invent steps not in the plan.
+
+---
+
+## When to Revisit Earlier Steps
+
+**Return to Step 1 (Review) when:**
+- The user updates the plan based on feedback
+- A fundamental approach needs rethinking due to new information
+
+**Do not force through blockers.** Stop and ask.
+
+---
+
+## Rules
+
+- Review the plan critically before touching any code
+- Follow plan steps exactly — do not improvise
+- Do not skip verifications
+- Reference skills when the plan says to invoke them
+- Stop when blocked; never guess
+- Never start implementation on `main` or `master` without explicit user consent
+
+---
+
+## Integration
+
+**Skills used by this skill:**
+- `Skill("mastermind-plan")` — creates the plan this skill executes
+- `Skill("mastermind-taskdev")` — subagent-driven parallel task execution (preferred for complex plans)
+- `Skill("mastermind-finish")` — complete the development branch after all tasks
+- `Skill("mastermind-verify")` — verification gate before finishing
+# monomind:end skills:claude:mastermind-execute

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

@@ -319,3 +319,319 @@ 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