🦛 Hippo Memory Insights — 2026-05-02

[github-actions[bot]]

Summary

• Memories in store: 513 (active: 486 after consolidation)
• New lessons learned from commits today: 0 (1 duplicate skipped)
• Highest-confidence memory: mem_4fa1dab787d9 — stale .lock.yml files cause CI churn (score=1.007, verified, retrieved 2x)
• Consolidation merged 120 episodic memories, created 50 new semantic entries, deduped 23 duplicates

Top Memories Surfaced

1. [score=1.007, verified] Recurring incident: stale workflow .lock.yml files cause churn and CI friction — run make recompile after markdown workflow edits (mem_4fa1dab787d9)
2. [score=0.761] Error reporting standard: reports errors with suggestions — linked to skills/error-messages/SKILL.md (mem_368f1217da7d)
3. [score=0.665] Error-message style guide for validation errors (mem_32d36a82674e)
4. [score=0.662] Diagnostic output (messages, warnings, errors) must go to stderr (mem_1da02bb64509)
5. [score=0.661] CI validation: validate-yaml job scans all YAML for ANSI escape sequences before other jobs run (mem_61ba8b71567a)
6. [score=0.636] Pre-commit checklist is NOT optional — skipping it causes immediate CI failures (mem_b04d788ad761)
7. [score=0.598] make test causes 5 CI failures in a single day if pre-commit validation is skipped (mem_f5a0d13c5c53)

Suggested Improvements

Error Patterns

• Add intermediate validation checkpoint: After the first major code edit, run make build immediately — not just at end of session. This surfaces compile errors early before more context is spent on subsequent edits (mem_1685e97ed879).
• Enforce error-to-stderr routing: Diagnostic output must always go to stderr. Audit any new commands/tools added recently to verify this pattern is followed.
• Guard list_code_scanning_alerts calls: Always include state: open and severity: critical,high in workflow prompts to avoid oversized MCP responses (mem_3cfa9f53bdad).

Code Quality

• JavaScript refactoring: pkg/workflow/js/ contains JavaScript that should be split into separate .cjs files. Guide available at skills/javascript-refactoring/SKILL.md.
• Validation file splitting: Any validation file over 300 lines or containing 2+ distinct domains should be split — decision tree documented in memory store (mem_9961279f8eef).
• Type safety: Use named types (WorkflowID, JobName, StepID) to prevent mixing similar string/int types — prevents subtle bugs caught multiple times (mem_48b8ec2cfa77).
• 7 low-quality memories flagged by audit — run hippo audit to review and prune.

CI Health

• make recompile discipline: The highest-confidence verified memory — stale .lock.yml files from uncompiled workflow markdown edits are a recurring source of CI friction. Enforce make recompile before every commit touching .github/aw/*.md files.
• ANSI escape sequences: validate-yaml job guards CI, but origin is in how descriptions/comments are written. The compiler does strip ANSI via stringutil.StripANSI() in pkg/workflow/compiler_yaml.go, but the root cause (raw ANSI in source) should still be addressed upstream.
• Full test suite is slow (>5 min): Let CI handle make test. Locally use make test-unit (~3 min) during development.

Quick Wins

1. Run make recompile after every .md workflow edit — highest impact, already-known rule that keeps causing incidents.
2. Add make build as intermediate checkpoint in development workflow — catches compile errors earlier, saves context.
3. Audit and prune 7 low-quality memories — run hippo audit to identify and remove stale or low-value entries.
4. Run make lint-cjs after any JavaScript changes in pkg/workflow/js/ — memory store flags this as a required step.
5. Use make fmt before committing — flagged multiple times in consolidated memories as a frequent miss.

Longer-term Themes

• Pre-commit discipline: Multiple memories converge on the same theme — skipping pre-commit validation (fmt, build, recompile) is the rejig docs #1 source of preventable CI failures. Consider a local git pre-commit hook to enforce make fmt && make build && make recompile.
• Type system patterns: Repeated memories about interface vs concrete type usage suggest the team is still building intuition around this. A short internal doc or ADR on when to use each pattern could help.
• MCP tool reliability: Several memories note that mcpscripts-* tools can fail after long inactivity (session expiry). Add retry logic or session-refresh patterns to workflow scripts that use MCP tools.
• Workflow compiler correctness: ANSI sanitization, YAML validation, and schema changes each have their own guard-rails, but they're scattered. A single make validate target that runs all pre-compile checks would reduce cognitive load.

Memory Health

Memory Store Statistics

• Total memories: 513
• Active after consolidation: 486
• Decayed/removed: 0
• Episodic merged → semantic: 120 (50 new semantic entries)
• Cross-layer duplicates deduped: 23
• Low-quality memories flagged: 7 (run hippo audit for details)
• High-value memories auto-shared to global store: 1
• Store health: mostly fresh (<7d), steady operation, mostly episodic, high avg strength, diverse topics
• Embeddings: 509 new embeddings created (513/513 total)

Memories Worth Reviewing/Pruning

• mem_be9497e47848 — strength: 0.30 (low), tags: very-slow-5-min-avoid-during-development — may be stale
• mem_2f4fed6eff16 — strength: 0.30 (low) — likely candidate for pruning
• Run hippo audit for the full list of 7 flagged low-quality memories

References:

• §25246220509

Generated by Daily Hippo Learn · ● 407.7K · ◷

• expires on May 5, 2026, 6:57 AM UTC

[pelikhan]

/q run hippo audit to identify inefficiencies, suggest up to quick wins as agentic talk prompts

[github-actions[bot]]

🔧 Pay attention, 007! Q is preparing your gadgets for this discussion comment...

[github-actions[bot]]

🦛 Q Hippo Audit — Quick Wins

Analyzed 5 runs of daily-hippo-learn (Apr 23 – May 1) and the hippo-embed workflow. Here's what the logs show.

---

📊 Findings from Live Data

Metric	Value
Runs analyzed	5 (4 success, 1 infra failure)
Avg effective tokens/run	~475k
Avg hippo MCP calls/run	~11
Avg duration	~7 min
Firewall blocks	13 unknown-domain (loopback)
hippo-embed runs in 30d	0 (never triggered)

Failure root cause (run #25039075428, Apr 28): Docker container awf-api-proxy unhealthy on startup — infrastructure issue, not workflow logic. The discussion was already created successfully before the failure.

---

🏆 Quick Wins — as Agentic Talk Prompts

These are formatted as /copilot prompts you can drop into an issue or discussion:

---

Quick Win 1 — Add a daily schedule to hippo-embed

hippo-embed has never run automatically — it's workflow_dispatch only. Add a weekly cron (e.g. Sunday 3:00 UTC) so the vector index gets a full audit+embed maintenance pass independent of the daily learn cycle.

/copilot Add a weekly schedule trigger (Sunday ~3:00 UTC) to `.github/workflows/hippo-embed.md` 
so it runs automatically, not just on manual dispatch. The `daily-hippo-learn` does incremental 
embeds but a weekly full audit-and-embed pass would catch any drift.

---

Quick Win 2 — Consolidate duplicate hippo list calls

Each run calls hippo list twice (once piped to grep for count, once for tail). Combine into one call.

/copilot In `.github/workflows/daily-hippo-learn.md`, the Memory Health step calls `hippo list` 
twice — once piped to grep for count and once for tail. Replace with a single call piped to 
`tee /tmp/hippo_list.txt` then grep/tail from the file, saving one MCP round-trip per run.

---

Quick Win 3 — Run 4 recall lenses in parallel, not sequentially

The workflow specifies 4 recall commands. From the logs, some runs execute them sequentially. Explicit parallel execution (bash & + wait) would save ~30–60s per run.

/copilot In `.github/workflows/daily-hippo-learn.md` Step 3, explicitly wrap all four 
`mcpscripts-hippo recall` commands in a bash subshell with `&` and a final `wait` to ensure 
parallel execution. Currently the agent sometimes runs them sequentially, wasting ~30-60s.

---

Quick Win 4 — Add --no-share flag to sleep for non-main branches

The sleep command promotes memories to the global store every run. On a daily cadence this is fine, but using --no-share unless there's a meaningful threshold (e.g. >5 new lessons) would reduce noise in the global store.

/copilot In `.github/workflows/daily-hippo-learn.md` Step 2, add logic: if `hippo learn --git` 
returns 0 new lessons, call `hippo sleep --no-share` instead of `hippo sleep` to avoid 
polluting the global memory store on low-signal days.

---

Quick Win 5 — Cache the hippo export output

The export command is called every run but its output (~200 lines) is only used for the current discussion. Writing it to /tmp/gh-aw/cache-memory/hippo-last-export.json would let future runs do incremental diffs rather than full re-analysis.

/copilot In `.github/workflows/daily-hippo-learn.md`, after Step 3's `hippo export`, save the 
output to `/tmp/gh-aw/cache-memory/hippo-last-export.json`. In Step 4, diff against the 
previous export to surface *new* patterns only, making the discussion more signal-dense.

---

📋 Runs Analyzed

• 25039075428 (failure — infra), 24821356676, 24924922523, 25095448770, 25206062060

🎩 Equipped by Q · ● 1.4M · ◷

[github-actions[bot]]

This discussion has been marked as outdated by Daily Hippo Learn.

A newer discussion is available at Discussion #30089.