eagle-mem 4.9.8 → 4.9.9

package/hooks/post-tool-use.sh

@@ -17,13 +17,10 @@ LIB_DIR="$SCRIPT_DIR/../lib"
 input=$(eagle_read_stdin)
 [ -z "$input" ] && exit 0
 
-session_id=$(echo "$input" | jq -r '.session_id // empty')
-cwd=$(echo "$input" | jq -r '.cwd // empty')
-tool_name=$(echo "$input" | jq -r '.tool_name // empty')
+IFS=$'\x1f' read -r session_id cwd tool_name hook_event <<< \
+    "$(echo "$input" | jq -r '[.session_id, .cwd, .tool_name, .hook_event_name] | map(. // "") | join("")')"
 agent=$(eagle_agent_source_from_json "$input")
 
-hook_event=$(echo "$input" | jq -r '.hook_event_name // empty')
-
 if [ -z "$session_id" ]; then exit 0; fi
 
 # TaskCreated/TaskCompleted dedicated events — parse top-level fields and exit
@@ -73,7 +70,7 @@ esac
 
 # Only track relevant tools
 case "$tool_name" in
-    Read|Write|Edit|TaskCreate|TaskUpdate|apply_patch) ;;
+    Read|Write|Edit|apply_patch|TaskUpdate) ;;
     *) eagle_is_shell_tool "$tool_name" || exit 0 ;;
 esac
 
@@ -153,9 +150,18 @@ case "$tool_name" in
             *) command_category="other" ;;
         esac
         ;;
-    TaskCreate|TaskUpdate)
-        task_subject=$(echo "$input" | jq -r '.tool_input.subject // empty')
-        tool_summary="$tool_name: $task_subject"
+    TaskUpdate)
+        task_id=$(echo "$input" | jq -r '.tool_input.taskId // empty')
+        task_status=$(echo "$input" | jq -r '.tool_input.status // empty')
+        tool_summary="TaskUpdate: ${task_id} → ${task_status}"
+        if [ -n "$task_id" ] && [ -n "$task_status" ]; then
+            fp_sql=$(eagle_sql_escape "event://${session_id}/${task_id}")
+            stat_sql=$(eagle_sql_escape "$task_status")
+            eagle_db_pipe <<SQL
+UPDATE agent_tasks SET status = '$stat_sql', updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE file_path = '$fp_sql';
+SQL
+        fi
         ;;
 esac
 
@@ -199,7 +205,6 @@ esac
 # ─── Dispatch to extracted responsibilities ───────────────
 
 eagle_posttool_mirror_writes "$tool_name" "$fp" "$session_id" "$project" "$agent"
-eagle_posttool_mirror_tasks "$tool_name" "$session_id" "$project" "$input" "$agent"
 eagle_posttool_stale_hint "$tool_name" "$fp" "$project" "$agent"
 eagle_posttool_decision_surface "$tool_name" "$fp" "$project" "$agent"
 

package/hooks/pre-tool-use.sh

@@ -21,7 +21,8 @@ LIB_DIR="$SCRIPT_DIR/../lib"
 input=$(eagle_read_stdin)
 [ -z "$input" ] && exit 0
 
-tool_name=$(echo "$input" | jq -r '.tool_name // empty')
+IFS=$'\x1f' read -r tool_name session_id cwd <<< \
+    "$(echo "$input" | jq -r '[.tool_name, .session_id, .cwd] | map(. // "") | join("")')"
 agent=$(eagle_agent_source_from_json "$input")
 
 case "$tool_name" in
@@ -30,9 +31,6 @@ case "$tool_name" in
 esac
 
 [ ! -f "$EAGLE_MEM_DB" ] && exit 0
-
-session_id=$(echo "$input" | jq -r '.session_id // empty')
-cwd=$(echo "$input" | jq -r '.cwd // empty')
 project=$(eagle_project_from_hook_input "$input")
 [ -z "$project" ] && exit 0
 
@@ -77,8 +75,6 @@ Pending checks:"
             done <<< "$pending_rows"
 
             jq -nc --arg reason "$block_reason" '{
-                "decision":"block",
-                "reason":$reason,
                 "hookSpecificOutput":{
                     "hookEventName":"PreToolUse",
                     "permissionDecision":"deny",
@@ -104,8 +100,6 @@ Recommended compact command:
 One-off developer bypass:
   touch $EAGLE_RAW_BASH_UNLOCK"
             jq -nc --arg reason "$reason" '{
-                "decision":"block",
-                "reason":$reason,
                 "hookSpecificOutput":{
                     "hookEventName":"PreToolUse",
                     "permissionDecision":"deny",
@@ -131,8 +125,6 @@ Install RTK or switch enforcement to auto:
 One-off developer bypass:
   touch $EAGLE_RAW_BASH_UNLOCK"
         jq -nc --arg reason "$reason" '{
-            "decision":"block",
-            "reason":$reason,
             "hookSpecificOutput":{
                 "hookEventName":"PreToolUse",
                 "permissionDecision":"deny",

package/hooks/stop.sh

@@ -21,16 +21,12 @@ eagle_ensure_db
 input=$(eagle_read_stdin)
 [ -z "$input" ] && exit 0
 
-session_id=$(echo "$input" | jq -r '.session_id // empty')
-cwd=$(echo "$input" | jq -r '.cwd // empty')
-transcript_path=$(echo "$input" | jq -r '.transcript_path // empty')
+IFS=$'\x1f' read -r session_id cwd transcript_path agent_type <<< \
+    "$(echo "$input" | jq -r '[.session_id, .cwd, .transcript_path, .agent_type] | map(. // "") | join("")')"
 last_assistant_message=$(echo "$input" | jq -r '.last_assistant_message // empty')
 agent=$(eagle_agent_source_from_json "$input")
 
 [ -z "$session_id" ] && exit 0
-
-# Skip subagent contexts
-agent_type=$(echo "$input" | jq -r '.agent_type // empty')
 [ -n "$agent_type" ] && [ "$agent_type" != "main" ] && exit 0
 
 project=$(eagle_project_from_hook_input "$input")

package/hooks/user-prompt-submit.sh

@@ -18,8 +18,8 @@ LIB_DIR="$SCRIPT_DIR/../lib"
 input=$(eagle_read_stdin)
 [ -z "$input" ] && exit 0
 
-session_id=$(echo "$input" | jq -r '.session_id // empty')
-cwd=$(echo "$input" | jq -r '.cwd // empty')
+IFS=$'\x1f' read -r session_id cwd <<< \
+    "$(echo "$input" | jq -r '[.session_id, .cwd] | map(. // "") | join("")')"
 user_prompt=$(echo "$input" | jq -r '.prompt // empty')
 agent=$(eagle_agent_source_from_json "$input")
 

package/lib/common.sh

@@ -672,6 +672,15 @@ eagle_project_from_hook_input() {
     cwd=$(printf '%s' "$input" | jq -r '.cwd // empty' 2>/dev/null)
     transcript_path=$(printf '%s' "$input" | jq -r '.transcript_path // empty' 2>/dev/null)
 
+    if [ -n "${CLAUDE_PROJECT_DIR:-}" ]; then
+        project=$(eagle_project_from_workspace_path "$CLAUDE_PROJECT_DIR")
+        if [ -n "$project" ]; then
+            [ -n "$session_id" ] && eagle_remember_session_project "$session_id" "$project" 1 >/dev/null 2>&1
+            printf '%s\n' "$project"
+            return
+        fi
+    fi
+
     workspace_project=$(printf '%s' "$input" | jq -r '.workspace.project_dir // empty' 2>/dev/null)
     if [ -n "$workspace_project" ]; then
         project=$(eagle_project_from_workspace_path "$workspace_project")

package/lib/db-features.sh

@@ -110,16 +110,16 @@ eagle_record_pending_feature_verifications() {
         local fid; fid=$(eagle_sql_int "$feature_id")
         local name_esc; name_esc=$(eagle_sql_escape "$feature_name")
 
-        if [ -n "$change_fingerprint" ]; then
-            already_resolved=$(eagle_db "SELECT 1 FROM pending_feature_verifications
-                WHERE project = '$p_esc'
-                  AND feature_id = $fid
-                  AND file_path = '$fp_esc'
-                  AND change_fingerprint = '$fp_hash_esc'
-                  AND status IN ('verified', 'waived')
-                LIMIT 1;")
-            [ -n "$already_resolved" ] && continue
-        fi
+        already_resolved=$(eagle_db "SELECT 1 FROM pending_feature_verifications
+            WHERE project = '$p_esc'
+              AND feature_id = $fid
+              AND file_path = '$fp_esc'
+              AND (
+                  (change_fingerprint = '$fp_hash_esc' AND status = 'verified')
+                  OR status = 'waived'
+              )
+            LIMIT 1;")
+        [ -n "$already_resolved" ] && continue
 
         eagle_db "INSERT INTO pending_feature_verifications
             (project, feature_id, feature_name, file_path, reason, source_session_id, trigger_tool, change_fingerprint)

package/lib/hooks-posttool.sh

@@ -33,31 +33,6 @@ eagle_posttool_mirror_writes() {
     esac
 }
 
-eagle_posttool_mirror_tasks() {
-    local tool_name="$1" session_id="$2" project="$3" input="$4"
-    local agent="${5:-$(eagle_agent_source)}"
-
-    case "$tool_name" in
-        TaskCreate|TaskUpdate)
-            if eagle_validate_session_id "$session_id"; then
-                local task_dir="$EAGLE_CLAUDE_TASKS_DIR/$session_id"
-                if [ -d "$task_dir" ]; then
-                    local task_id
-                    task_id=$(echo "$input" | jq -r '.tool_input.id // empty')
-                    if [ -z "$task_id" ]; then
-                        local newest
-                        newest=$(ls -t "$task_dir"/*.json 2>/dev/null | head -1)
-                        [ -n "$newest" ] && [ -f "$newest" ] && eagle_capture_agent_task "$newest" "$session_id" "$project" "$agent"
-                    elif eagle_validate_session_id "$task_id"; then
-                        local task_json="$task_dir/$task_id.json"
-                        [ -f "$task_json" ] && eagle_capture_agent_task "$task_json" "$session_id" "$project" "$agent"
-                    fi
-                fi
-            fi
-            ;;
-    esac
-}
-
 eagle_posttool_stale_hint() {
     local tool_name="$1" fp="$2" project="$3"
     local agent="${4:-$(eagle_agent_source)}"

package/lib/hooks.sh

@@ -4,6 +4,18 @@
 # Shared by install.sh and update.sh
 # ═══════════════════════════════════════════════════════════
 
+eagle_clean_hook_entries() {
+    local settings="$1"
+    local event="$2"
+    local command="$3"
+
+    local tmp
+    tmp=$(mktemp)
+    jq --arg cmd "$command" \
+        ".hooks.${event} = ((.hooks.${event} // []) | map(select(.hooks | all(.command != \$cmd))))" \
+        "$settings" > "$tmp" && mv "$tmp" "$settings"
+}
+
 eagle_patch_hook() {
     local settings="$1"
     local event="$2"

package/package.json

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

package/scripts/feature.sh

@@ -125,13 +125,7 @@ case "$subcommand" in
 
     waive)
         id="${1:-}"
-        [ -z "$id" ] && { eagle_err "Usage: eagle-mem feature waive <id> --reason <text>"; exit 1; }
-        case "$id" in
-            *[!0-9]*)
-                eagle_err "Invalid ID: '$id' (must be numeric)"
-                exit 1
-                ;;
-        esac
+        [ -z "$id" ] && { eagle_err "Usage: eagle-mem feature waive <id|name> --reason <text>"; exit 1; }
         shift
         reason=""
         while [ $# -gt 0 ]; do
@@ -147,14 +141,27 @@ case "$subcommand" in
                 *) reason="$1"; shift ;;
             esac
         done
-        [ -z "$reason" ] && { eagle_err "Usage: eagle-mem feature waive <id> --reason <text>"; exit 1; }
-        waived=$(eagle_waive_pending_feature_verification "$project" "$id" "$reason" | tail -1)
-        if [ "${waived:-0}" -gt 0 ] 2>/dev/null; then
-            eagle_ok "Pending verification #$id waived"
-        else
-            eagle_err "No pending verification found with ID $id"
-            exit 1
-        fi
+        [ -z "$reason" ] && { eagle_err "Usage: eagle-mem feature waive <id|name> --reason <text>"; exit 1; }
+        case "$id" in
+            *[!0-9]*)
+                waived=$(eagle_resolve_pending_feature_verifications "$project" "$id" "waived" "$reason" | tail -1)
+                if [ "${waived:-0}" -gt 0 ] 2>/dev/null; then
+                    eagle_ok "Waived $waived pending verification(s) for '$id'"
+                else
+                    eagle_err "No pending verifications found for feature '$id'"
+                    exit 1
+                fi
+                ;;
+            *)
+                waived=$(eagle_waive_pending_feature_verification "$project" "$id" "$reason" | tail -1)
+                if [ "${waived:-0}" -gt 0 ] 2>/dev/null; then
+                    eagle_ok "Pending verification #$id waived"
+                else
+                    eagle_err "No pending verification found with ID $id"
+                    exit 1
+                fi
+                ;;
+        esac
         ;;
 
     add)

package/scripts/install.sh

@@ -226,7 +226,11 @@ if [ "$claude_found" = true ]; then
         "$EAGLE_MEM_DIR/hooks/stop.sh" \
         "Stop hook"
 
-    eagle_patch_hook "$SETTINGS" "PostToolUse" "Read|Write|Edit|Bash|TaskCreate|TaskUpdate" \
+    # Clean old registrations before re-registering (handles matcher changes across versions)
+    eagle_clean_hook_entries "$SETTINGS" "PostToolUse" "$EAGLE_MEM_DIR/hooks/post-tool-use.sh"
+    eagle_clean_hook_entries "$SETTINGS" "PreToolUse" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh"
+
+    eagle_patch_hook "$SETTINGS" "PostToolUse" "Read|Write|Edit|Bash|TaskUpdate" \
         "$EAGLE_MEM_DIR/hooks/post-tool-use.sh" \
         "PostToolUse hook"
 
@@ -246,21 +250,9 @@ if [ "$claude_found" = true ]; then
         "$EAGLE_MEM_DIR/hooks/user-prompt-submit.sh" \
         "UserPromptSubmit hook"
 
-    eagle_patch_hook "$SETTINGS" "PreToolUse" "Bash" \
-        "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh" \
-        "PreToolUse hook (Bash)"
-
-    eagle_patch_hook "$SETTINGS" "PreToolUse" "Read" \
-        "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh" \
-        "PreToolUse hook (Read)"
-
-    eagle_patch_hook "$SETTINGS" "PreToolUse" "Edit" \
-        "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh" \
-        "PreToolUse hook (Edit)"
-
-    eagle_patch_hook "$SETTINGS" "PreToolUse" "Write" \
+    eagle_patch_hook "$SETTINGS" "PreToolUse" "Bash|Read|Edit|Write" \
         "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh" \
-        "PreToolUse hook (Write)"
+        "PreToolUse hook"
 else
     eagle_info "Claude hooks skipped ${DIM}(Claude Code not detected)${RESET}"
 fi

package/scripts/update.sh

@@ -76,23 +76,18 @@ fi
 # ─── Re-register hooks (idempotent) ───────────────────────
 
 if [ "$claude_found" = true ] && [ -f "$SETTINGS" ] && command -v jq &>/dev/null; then
-    # Update PostToolUse matcher if it has the old value (pre-v1.3.0)
-    if jq -e '.hooks.PostToolUse[]? | select(.matcher == "Read|Write|Edit|Bash")' "$SETTINGS" &>/dev/null; then
-        _tmp=$(mktemp)
-        jq '(.hooks.PostToolUse[] | select(.matcher == "Read|Write|Edit|Bash")).matcher = "Read|Write|Edit|Bash|TaskCreate|TaskUpdate"' "$SETTINGS" > "$_tmp" && mv "$_tmp" "$SETTINGS"
-    fi
+    # Clean old registrations before re-registering (handles matcher changes across versions)
+    eagle_clean_hook_entries "$SETTINGS" "PostToolUse" "$EAGLE_MEM_DIR/hooks/post-tool-use.sh"
+    eagle_clean_hook_entries "$SETTINGS" "PreToolUse" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh"
 
     eagle_patch_hook "$SETTINGS" "SessionStart" "" "$EAGLE_MEM_DIR/hooks/session-start.sh"
     eagle_patch_hook "$SETTINGS" "Stop" "" "$EAGLE_MEM_DIR/hooks/stop.sh"
-    eagle_patch_hook "$SETTINGS" "PostToolUse" "Read|Write|Edit|Bash|TaskCreate|TaskUpdate" "$EAGLE_MEM_DIR/hooks/post-tool-use.sh"
+    eagle_patch_hook "$SETTINGS" "PostToolUse" "Read|Write|Edit|Bash|TaskUpdate" "$EAGLE_MEM_DIR/hooks/post-tool-use.sh"
     eagle_patch_hook "$SETTINGS" "TaskCreated" "" "$EAGLE_MEM_DIR/hooks/post-tool-use.sh"
     eagle_patch_hook "$SETTINGS" "TaskCompleted" "" "$EAGLE_MEM_DIR/hooks/post-tool-use.sh"
     eagle_patch_hook "$SETTINGS" "SessionEnd" "" "$EAGLE_MEM_DIR/hooks/session-end.sh"
     eagle_patch_hook "$SETTINGS" "UserPromptSubmit" "" "$EAGLE_MEM_DIR/hooks/user-prompt-submit.sh"
-    eagle_patch_hook "$SETTINGS" "PreToolUse" "Bash" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh"
-    eagle_patch_hook "$SETTINGS" "PreToolUse" "Read" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh"
-    eagle_patch_hook "$SETTINGS" "PreToolUse" "Edit" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh"
-    eagle_patch_hook "$SETTINGS" "PreToolUse" "Write" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh"
+    eagle_patch_hook "$SETTINGS" "PreToolUse" "Bash|Read|Edit|Write" "$EAGLE_MEM_DIR/hooks/pre-tool-use.sh"
 
     eagle_ok "Hooks registered"
 fi

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

@@ -0,0 +1,123 @@
+---
+name: eagle-mem-feature
+description: >
+  Manage Eagle Mem feature verification and anti-regression guardrails. Use when:
+  'feature pending', 'verify feature', 'waive feature', 'feature verification',
+  'pending verifications', 'release blocked', 'feature guard', 'smoke test',
+  'what needs verification', 'mark feature verified', 'skip verification'.
+  Uses the eagle-mem CLI.
+---
+
+# Eagle Mem — Feature Verification
+
+## Purpose
+
+**For the user:** Every tracked feature has files, dependencies, and smoke tests. When you edit a tracked file, Eagle Mem automatically flags the feature as needing re-verification. Release-boundary commands stay blocked until all pending verifications are resolved. This prevents shipping regressions.
+
+**For you:** The pending verification list tells you what's at risk after your edits. Resolve each one: run smoke tests and `verify`, or explain why it's safe and `waive`. Don't leave pending items unresolved — they block the user's workflow.
+
+## Core Concepts
+
+### Verify vs Waive
+
+These are semantically different operations:
+
+**Verify** = "I tested this exact change and it works." Fingerprint-specific — tied to the current diff hash. If the file changes again, a new pending verification appears.
+
+**Waive** = "I accept changes to this feature+file pair." Fingerprint-agnostic — covers the current change AND all future changes to that file for that feature. Use when the change is known-safe (e.g., comment-only edit, unrelated code path).
+
+**Decision rule:** Did you run the smoke test or manually confirm behavior? Use `verify`. Is the change structurally irrelevant to the feature? Use `waive`.
+
+### Pending Verifications
+
+When you Edit/Write a file tracked by a feature, PostToolUse automatically creates a pending verification record. Each record is keyed by (project, feature, file, fingerprint). The `pending` list shows what needs attention before release.
+
+### Release Boundary
+
+Release-boundary commands (publish, deploy) check for unresolved pending verifications. If any exist, the command is blocked with a list of what's pending. This is the enforcement mechanism — it only gates release, not development.
+
+## Steps
+
+### 1. Check what's pending
+
+```bash
+eagle-mem feature pending              # current project
+eagle-mem feature pending --raw        # include trigger, fingerprint, timestamp
+eagle-mem feature pending --limit 100  # show more than default 50
+```
+
+Each entry shows: feature name, file path, reason, and smoke test command (if registered).
+
+### 2. Resolve by verifying
+
+After running smoke tests or confirming the feature works:
+
+```bash
+eagle-mem feature verify <feature-name> --notes "smoke tests pass, tested login flow"
+```
+
+This marks ALL pending verifications for that feature as verified (for the current fingerprints) and updates the feature's `last_verified_at` timestamp.
+
+### 3. Resolve by waiving
+
+When a change is known-safe without testing — waive by feature name:
+
+```bash
+eagle-mem feature waive <feature-name> --reason "comment-only change, no behavior impact"
+```
+
+Or waive a single pending record by ID:
+
+```bash
+eagle-mem feature waive <id> --reason "unrelated code path"
+```
+
+**Prefer waive-by-name** over waive-by-ID. IDs are ephemeral (new edits create new IDs), but names are stable. Waiving by name resolves all pending records for that feature at once.
+
+A reason is always required — it's the audit trail for why verification was skipped.
+
+### 4. Register a new feature
+
+```bash
+eagle-mem feature add auth-flow \
+  --desc "User authentication and session management" \
+  --file src/auth/login.ts \
+  --file src/auth/session.ts \
+  --smoke "npm test -- --grep auth" \
+  --requires env_var:AUTH_SECRET
+```
+
+### 5. List and inspect features
+
+```bash
+eagle-mem feature list                 # all active features
+eagle-mem feature show <name>          # files, deps, smoke tests, last verified
+```
+
+## Judgment
+
+**Always verify when:**
+- You edited core logic in a tracked file
+- The smoke test exists and is quick to run
+- Multiple features depend on the changed file
+
+**Waive when:**
+- The edit is cosmetic (formatting, comments, imports)
+- The changed code path is unrelated to the feature's functionality
+- The feature's smoke test would test something you already tested another way
+
+**Don't ignore pending verifications.** If you see them in the recall block, address them before your session ends. The user will be blocked on release otherwise.
+
+## Reference
+
+| Command | What it does |
+|---|---|
+| `feature list` | All active features with file/dep/test counts |
+| `feature show <name>` | Full detail: files, dependencies, smoke tests |
+| `feature pending` | All unresolved pending verifications |
+| `feature verify <name>` | Mark feature verified (fingerprint-specific) |
+| `feature waive <name\|id>` | Waive verification (fingerprint-agnostic for name) |
+| `feature add <name>` | Register a new feature with files/deps/tests |
+| `--notes "text"` | Attach notes to verify/waive (audit trail) |
+| `--reason "text"` | Required for waive — explains why safe |
+| `--raw` | Show trigger, fingerprint, and timestamp in pending |