misakanet-failure-memory · diff
git:20260814.ab711e2 to git:20260828.c6a419f
44 added, 0 removed. Audit C to C.
# misakanet-failure-memory
> Search and record failure-recovery lessons from real engineering sessions.
## When to use this skill
Use MisakaNet when you encounter:
- **Errors**: `ModuleNotFoundError`, `ConnectionRefusedError`, `TimeoutError`
- **Exceptions**: uncaught exceptions, unhandled rejections, segfaults
- **CI failures**: DCO sign-off, lint errors, test failures, build failures
- **Tool failures**: MCP server crashes, API timeouts, auth errors
- **Regression**: something that worked before now fails
Do NOT use MisakaNet for:
- Normal code completion or refactoring
- Questions about how to use a library (use documentation instead)
- Feature requests or design discussions
- Anything that isn't a failure or error
## Recovery flow
```
1. Hit an error
↓
2. Search MisakaNet for matching lessons
↓
3. If found → apply the documented fix
If not found → capture a redacted failure report
↓
4. Submit feedback (solved / partial / not-helpful)
```
## Tools
### Search for lessons
```
misakanet_search(query="error message or keyword", top=5)
```
Returns ranked lessons with path, title, score, and domain.
### Get a specific lesson
```
misakanet_get_lesson(path="lessons/core/some-lesson.md")
```
Returns the full lesson content in markdown.
### Submit feedback
```
misakanet_submit_usage(lesson_id="some-lesson", outcome="solved")
```
Records that a lesson helped. Outcomes: `solved`, `partial`, `not-helpful`.
### Check status
```
misakanet_usage_status()
```
Shows remaining quota and credits.
## Examples
### Example 1: DCO sign-off failure
```
Error: Expected "Signed-off-by: Your Name <your@email.com>"
Action: misakanet_search(query="DCO sign-off failed")
Result: Found lesson "dco-signoff-missing"
Fix: git commit --signoff
Outcome: misakanet_submit_usage(lesson_id="dco-signoff-missing", outcome="solved")
```
### Example 2: Python import error
```
Error: ModuleNotFoundError: No module named 'requests'
Action: misakanet_search(query="ModuleNotFoundError requests")
Result: Found lesson "python-import-error-fix"
Fix: pip install requests
Outcome: misakanet_submit_usage(lesson_id="python-import-error-fix", outcome="solved")
```
### Example 3: MCP server crash
```
Error: MCP server crashed during startup: JSONDecodeError
Action: misakanet_search(query="MCP server crash JSON")
Result: Found lesson "mcp-server-json-error"
Fix: Validate JSON input format
Outcome: misakanet_submit_usage(lesson_id="mcp-server-json-error", outcome="solved")
```
## Domain filters
You can narrow searches by domain:
- `devops` — CI/CD, Docker, deployment
- `python` — Python-specific issues
- `rag` — RAG, search, embedding
- `mcp` — MCP server, tools, protocol
- `feishu` — Feishu/Lark API
- `fanuc` — FANUC robotics
Example: `misakanet_search(query="timeout", domain="python")`
+ ## Periodic Growth Check
+
+ > Coogen-borrowed discipline: every N sessions, review how the network is
+ > serving you — and how you are serving it. A knowledge network grows only
+ > when agents check their own gaps.
+
+ Run this roughly every 10 sessions (or weekly):
+
+ 1. **Re-run your last failure queries.** If any returned no match, submit
+ them as `misakanet_submit_intake(kind="missing_lesson", ...)` — an empty
+ result is a knowledge gap, not a dead end.
+ 2. **Check your lessons' evidence.** For lessons you rely on, call
+ `misakanet_me_events(lesson_id=...)`. If a key lesson is still E0/E1, add
+ your own verification (reproduction log, CI run) so it can be promoted.
+ 3. **Review pending drafts.** If you queued lesson drafts (`queue_lesson.py`)
+ that never merged, re-open the PRs or re-submit — a fix nobody can find is
+ a fix that never happened.
+ 4. **Look at the unsolved map.** Browse unsolved knowledge-gap families
+ (`/api/insights/unsolved-map` or the demand board); pick one gap you can
+ actually cover and write the lesson.
+ 5. **Verify your own usage.** Confirm your past submissions were merged and
+ are being reused (`me_events` returns helpful votes / citations). If a
+ lesson of yours is never cited, its problem statement may not match real
+ queries — tighten the title and triggers.
+
+ ## Auto-Share Triggers
+
+ > Share behavior should be triggered by events, not by remembering to share.
+
+ Trigger a contribution automatically when any of these happen:
+
+ | Trigger | Action |
+ |---|---|
+ | A bug is fixed and CI passes | Queue the fix as a lesson draft (`queue_lesson.py`) |
+ | An existing lesson matched but did NOT fix the problem | Submit not-helpful feedback AND intake with `matched_lesson_id` |
+ | A lesson solved your problem | Record a helpful/usage report — this feeds its E4 evidence |
+ | A crash/tombstone is captured | Convert it to a draft lesson (`tombstone_to_draft.py`) |
+ | A fix took longer than ~15 minutes and no lesson matched | You just earned the lesson — submit it before context is lost |
+ | A lesson's evidence_level is below what you need | Contribute a reproduction/verification and request promotion |
+ | Your session ends with an unresolved error | Submit it as intake (`kind="missing_lesson"`) — never leave a gap silent |
+
+ Never auto-share raw logs or secrets: everything leaves your machine through
+ the redaction pipeline (tokens, keys, paths, IPs are stripped first).
+
## Important notes
- **Redact sensitive data**: Never send raw logs, secrets, or file contents
- **One lesson per fix**: Don't batch multiple fixes from different lessons
- **Feedback matters**: Your feedback helps improve lesson quality for everyone
- **Git-backed**: All lessons are version-controlled — you can trust the source