eagle-mem 4.8.1 → 4.8.2

package/README.md

@@ -11,7 +11,7 @@
 
 Eagle Mem turns AI coding sessions into compounding project knowledge. It gives Claude Code and Codex the same local memory, labels which agent created each memory, blocks risky release commands until affected features are verified, and lets broad work split into durable worker lanes.
 
-**v4.8.1 ships the communication refresh for the new architecture:** cross-agent orchestration, compact Codex hook recall, enforced anti-regression checks, configurable RTK token guardrails, and a memory-sync fix for large memory files.
+**v4.8.2 ships Codex output polish:** Codex final replies now stay clean by default instead of printing large `<eagle-summary>` capture blocks. Eagle Mem still captures summaries from the Stop transcript, while Claude Code can keep using the richer explicit summary path where it behaves cleanly.
 
 **Website:** [Product](https://eagleisbatman.github.io/eagle-mem/) |
 [Architecture](https://eagleisbatman.github.io/eagle-mem/architecture.html) |
@@ -149,6 +149,10 @@ Eagle Mem prevents Claude from repeating past mistakes:
 | `eagle-mem scan` | Scan codebase and generate overview |
 | `eagle-mem index` | Index source files for FTS5 code search |
 
+### v4.8.2 Patch
+
+Codex no longer gets instructed to print large user-visible `<eagle-summary>` XML blocks. The installer/update path rewrites existing `~/.codex/AGENTS.md` Eagle Mem instructions to the clean-output contract, context-pressure nudges use normal prose, and Codex-oriented skills/worker prompts avoid raw capture templates.
+
 ### v4.8.1 Patch
 
 `eagle-mem memories sync` is now safe on large Claude Code/Codex memory files. The memory mirror parser no longer uses early-exit pipelines under `pipefail`, avoiding exit `141` during sync.

package/hooks/session-start.sh

@@ -171,7 +171,7 @@ fi
 if [ "$agent" = "codex" ] && [ "${stat_with_summaries:-0}" -eq 0 ] 2>/dev/null; then
     context+="
 === Eagle Mem: Codex Capture Warming Up ===
-Codex hooks are active. End important turns with an <eagle-summary> block so future Claude Code and Codex sessions can recall decisions, gotchas, key files, and next steps from this project.
+Codex hooks are active. Keep final replies clean; Eagle Mem will capture decisions, gotchas, key files, and next steps from the transcript automatically.
 "
 fi
 
@@ -439,7 +439,7 @@ fi
 if [ "$agent" = "codex" ]; then
     context+="
 === Eagle Mem: Active ===
-Memory active for '$project'. Emit <eagle-summary> in final responses with request, completed, learned, decisions, gotchas, next_steps, key_files, files_read, files_modified, affected_features, verified_features, and regression_risks.
+Memory active for '$project'. Keep user-facing Codex replies clean: do not print Eagle Mem summary capture blocks, XML, JSON hook payloads, or internal templates unless the user explicitly asks. The Stop hook captures summaries from the transcript automatically.
 "
 elif [ "$source_type" = "compact" ] || [ "$source_type" = "clear" ]; then
     context+="

package/hooks/stop.sh

@@ -238,7 +238,7 @@ if [ "$needs_enrichment" -eq 1 ]; then
     if [ "$provider" != "none" ] && [ -n "$text_content" ]; then
         excerpt=$(echo "$text_content" | tail -c 3000)
 
-        enrich_prompt="Extract facts from this Claude Code session. Only include items with clear evidence in the session text. Do NOT invent or repeat example content.
+        enrich_prompt="Extract facts from this AI coding session. Only include items with clear evidence in the session text. Do NOT invent or repeat example content.
 
 Respond with EXACTLY these sections (omit sections with no evidence):
 
@@ -263,7 +263,7 @@ Each as: <filepath>
 SESSION TEXT:
 $excerpt"
 
-        enrich_system="You extract structured facts from development sessions. Output format for decisions: '- Did X — why: Y'. Output format for gotchas: '- Gotcha description'. Be concise. Only include items with clear evidence in the session text. Never fabricate content."
+        enrich_system="You extract structured facts from Claude Code and Codex development sessions. Output format for decisions: '- Did X — why: Y'. Output format for gotchas: '- Gotcha description'. Be concise. Only include items with clear evidence in the session text. Never fabricate content."
         enrich_result=$(eagle_llm_call "$enrich_prompt" "$enrich_system" 768 2>/dev/null)
         llm_rc=$?
 

package/hooks/user-prompt-submit.sh

@@ -44,18 +44,32 @@ if [ -n "$session_id" ] && eagle_validate_session_id "$session_id"; then
     eagle_log "INFO" "UserPromptSubmit: turn=$turn_count session=$session_id"
 
     if [ "$turn_count" -ge 30 ]; then
-        context+="
+        if [ "$codex_compact" -eq 1 ]; then
+            context+="
+=== Eagle Mem: Context Pressure Critical ($turn_count turns since compact) ===
+Keep the next Codex reply user-clean. Do not print Eagle Mem summary capture blocks or other internals. Include a short normal handoff note if useful, then ask the user to run /compact.
+"
+        else
+            context+="
 === Eagle Mem: Context Pressure Critical ($turn_count turns since compact) ===
 IMMEDIATELY emit a detailed <eagle-summary> covering ALL work this session.
 Tell the user to run /compact NOW to avoid losing context.
 "
+        fi
         echo "$turn_count" > "$EAGLE_MEM_DIR/.context-pressure"
     elif [ "$turn_count" -ge 20 ]; then
-        context+="
+        if [ "$codex_compact" -eq 1 ]; then
+            context+="
+=== Eagle Mem: Context Pressure High ($turn_count turns since compact) ===
+Keep the next Codex reply clean. Do not print Eagle Mem summary capture blocks or other internals. Summarize any durable decisions in normal prose only.
+"
+        else
+            context+="
 === Eagle Mem: Context Pressure High ($turn_count turns since compact) ===
 Include a thorough <eagle-summary> in your next response — capture all decisions, gotchas, and learned context before compaction.
 Suggest the user run /compact to free context for continued work.
 "
+        fi
         echo "$turn_count" > "$EAGLE_MEM_DIR/.context-pressure"
     else
         rm -f "$EAGLE_MEM_DIR/.context-pressure" 2>/dev/null

package/lib/common.sh

@@ -659,10 +659,7 @@ eagle_patch_claude_md() {
                 skip && /^## / { skip=0 }
                 !skip { print }
             ' "$claude_md" > "$tmp_md"
-            # Remove trailing blank lines left by section removal
-            sed -e :a -e '/^[[:space:]]*$/{ $d; N; ba; }' "$tmp_md" > "${tmp_md}.clean"
-            mv "${tmp_md}.clean" "$claude_md"
-            rm -f "$tmp_md"
+            mv "$tmp_md" "$claude_md"
             _eagle_claude_md_section >> "$claude_md"
             return 0
         fi
@@ -692,30 +689,13 @@ _eagle_codex_agents_section() {
 
 Eagle Mem hooks are active for Codex in this project. SessionStart and UserPromptSubmit inject project recall from the shared Eagle Mem database at `~/.eagle-mem/memory.db`. PostToolUse records observations and marks affected features for verification.
 
-**Rule:** Before your final response in every session, emit an `<eagle-summary>` block so the Stop hook can capture a rich summary.
-
-```
-<eagle-summary>
-request: [what user asked]
-completed: [what shipped]
-learned: [non-obvious discoveries]
-decisions: [choice — why]
-gotchas: [what surprised]
-next_steps: [concrete actions]
-key_files: [path — role]
-files_read: [path, ...]
-files_modified: [path, ...]
-affected_features: [feature, ...]
-verified_features: [feature, ...]
-regression_risks: [risk, ...]
-</eagle-summary>
-```
+**User-visible output rule:** Keep Codex final answers clean. Do not print Eagle Mem summary capture blocks, XML, JSON hook payloads, or internal templates to the user unless the user explicitly asks for raw Eagle Mem internals. The Stop hook captures Codex summaries from the transcript automatically.
 
 **How to apply:**
 - Attribute recalled context as "Eagle Mem recalls:" when it is injected
 - Use the Eagle Mem skills when relevant: `eagle-mem-search`, `eagle-mem-overview`, `eagle-mem-memories`, `eagle-mem-tasks`, and `eagle-mem-orchestrate`
 - For broad multi-agent work, YOU run `eagle-mem orchestrate`; do not ask the user to run these commands
-- For important decisions, preferences, gotchas, or durable project facts, explicitly include them in the `<eagle-summary>` block so Codex-originated memories become available to future Claude Code and Codex sessions
+- For important decisions, preferences, gotchas, or durable project facts, include them briefly in normal prose. Eagle Mem will extract them from the transcript.
 - Do not revert Eagle Mem-surfaced decisions without asking the user
 - If Eagle Mem reports pending feature verification, verify or waive it before push/PR/publish
 - Never put raw secrets in summaries
@@ -729,6 +709,23 @@ eagle_patch_codex_agents_md() {
     mkdir -p "$(dirname "$agents_md")"
 
     if [ -f "$agents_md" ] && grep -qF "$marker" "$agents_md" 2>/dev/null; then
+        if grep -qF 'emit an `<eagle-summary>` block' "$agents_md" 2>/dev/null \
+            || grep -qF 'emit an <eagle-summary> block' "$agents_md" 2>/dev/null \
+            || grep -qF 'explicitly include them in the `<eagle-summary>` block' "$agents_md" 2>/dev/null \
+            || grep -qF 'explicitly include them in the <eagle-summary> block' "$agents_md" 2>/dev/null \
+            || ! grep -qF 'Keep Codex final answers clean' "$agents_md" 2>/dev/null; then
+            local tmp_md
+            tmp_md=$(mktemp)
+            awk -v marker="$marker" '
+                $0 ~ marker { skip=1; next }
+                skip && /^---$/ { skip=0; next }
+                skip && /^## / { skip=0 }
+                !skip { print }
+            ' "$agents_md" > "$tmp_md"
+            mv "$tmp_md" "$agents_md"
+            _eagle_codex_agents_section >> "$agents_md"
+            return 0
+        fi
         if ! grep -qF 'eagle-mem orchestrate' "$agents_md" 2>/dev/null; then
             local tmp_md
             tmp_md=$(mktemp)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eagle-mem",
-  "version": "4.8.1",
+  "version": "4.8.2",
   "description": "Shared memory, release guardrails, RTK token protection, and worker lanes for Claude Code and Codex",
   "bin": {
     "eagle-mem": "bin/eagle-mem"

package/scripts/orchestrate.sh

@@ -301,7 +301,7 @@ Rules:
 - If blocked, run: eagle-mem orchestrate lane --project "$project" --name "$name" block "$lane_key" --notes "<concrete blocker>"
 - If you finish manually before the wrapper updates status, run: eagle-mem orchestrate lane --project "$project" --name "$name" complete "$lane_key" --notes "<validation result>"
 - Run the validation command when one is provided and it is safe for the lane.
-- Before final response, emit an <eagle-summary> with request, completed, learned, decisions, gotchas, next_steps, key_files, files_read, files_modified, affected_features, verified_features, and regression_risks.
+- Keep user-facing final responses clean. Claude Code workers may emit an Eagle Mem summary block when their UI handles it cleanly; Codex workers should not print XML, JSON, or internal capture blocks unless the user explicitly asks. Eagle Mem Stop hooks capture Codex summaries from the transcript automatically.
 PROMPT
 }
 

package/skills/eagle-mem-memories/SKILL.md

@@ -68,7 +68,7 @@ eagle-mem memories tasks show <file_path>
 
 Two paths feed the mirror:
 
-**Real-time hooks.** Claude Code memory/plan/task files are mirrored when written. Codex sessions are captured through SessionStart/UserPromptSubmit/PostToolUse/Stop hooks, and important durable facts should be placed in `<eagle-summary>` so they become shared recall.
+**Real-time hooks.** Claude Code memory/plan/task files are mirrored when written. Codex sessions are captured through SessionStart/UserPromptSubmit/PostToolUse/Stop hooks. In Codex, keep user-facing replies clean and put important durable facts in normal prose; Eagle Mem extracts them from the transcript.
 
 **Backfill (sync command).** For memories, plans, and tasks that existed before Eagle Mem was installed, or that were written outside a hooked session:
 ```bash

package/skills/eagle-mem-orchestrate/SKILL.md

@@ -129,8 +129,10 @@ ending a broad session.
 - Every lane should have a validation command when one is obvious.
 - If a lane is blocked, update the lane with a concrete note rather than
   silently stopping.
-- After completing a lane, emit an `<eagle-summary>` so Eagle Mem captures the
-  decision and files touched.
+- After completing a lane, keep the user-facing final response clean. Claude Code
+  may use the Eagle Mem summary block when that UI handles it cleanly; Codex
+  should record durable decisions in normal prose and let the Stop hook capture
+  the transcript.
 
 ## Reference
 

package/skills/eagle-mem-tasks/SKILL.md

@@ -66,7 +66,7 @@ Mark the current task in progress (`TaskUpdate(in_progress)` in Claude Code, or
 
 ### 4. Complete — record what happened
 
-Mark the task completed (`TaskUpdate(completed)` in Claude Code, or `eagle-mem tasks complete <id> --agent codex` in Codex). Emit `<eagle-summary>` so Eagle Mem captures what was accomplished.
+Mark the task completed (`TaskUpdate(completed)` in Claude Code, or `eagle-mem tasks complete <id> --agent codex` in Codex). In Claude Code, use the Eagle Mem summary block when that UI handles it cleanly. In Codex, keep the final reply clean and record durable decisions in normal prose; Eagle Mem captures the transcript automatically.
 
 If the task produced decisions that downstream tasks need, update those task descriptions now:
 ```