@rulemetric/hooks 0.7.5 → 0.7.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulemetric/hooks",
-  "version": "0.7.5",
+  "version": "0.7.7",
   "publishConfig": {
     "access": "public"
   },

package/scripts/session-start.sh

@@ -168,12 +168,19 @@ _rulemetric_suggest_instructions() {
     else
       event_type="surfaced"
     fi
+    # Include the harness session id (HOOK_SESSION_ID — the external Claude Code /
+    # Cursor / … session id, UUID-validated by _normalize.sh). The DB session row
+    # usually doesn't exist yet at session-start (the proxy creates it from the
+    # first wire traffic), so the API can't resolve it here — instead it stores
+    # this external id and reconciles it to a treatment_exposures row at session
+    # close (reimport matches sessions.external_session_id). Without this, every
+    # surfaced event has session_id=NULL and suggestions can never be measured.
     curl -s --noproxy '*' --max-time 3 -X POST \
       "${api_url}/api/instruction-suggestions/${sid}/events" \
       -H "Authorization: Bearer ${auth_token}" \
       -H "Content-Type: application/json" \
-      -d "$(jq -n --arg eventType "$event_type" --arg tool "$tool" --arg projectPath "$project_path" \
-        '{eventType: $eventType, tool: $tool, projectPath: $projectPath}')" \
+      -d "$(jq -n --arg eventType "$event_type" --arg tool "$tool" --arg projectPath "$project_path" --arg sessionId "$HOOK_SESSION_ID" \
+        '{eventType: $eventType, tool: $tool, projectPath: $projectPath, sessionId: $sessionId}')" \
       >/dev/null 2>&1 &
     disown 2>/dev/null || true
     i=$((i + 1))
@@ -181,3 +188,77 @@ _rulemetric_suggest_instructions() {
 }
 
 _rulemetric_suggest_instructions || true
+
+# ── Memory injection (non-blocking) ──
+# Surface this project's durable memories (facts / decisions / corrections /
+# conventions distilled from prior sessions) to the model as session context, then
+# stamp a treatment exposure per injected memory so their MEASURED effect flows
+# through the effectiveness engine (GET /api/insights/memory-impact). The DB session
+# doesn't exist yet at session-start (the proxy creates it from the first wire
+# traffic), so the exposure is BUFFERED by this harness session id and reconciled at
+# session close (reimport). All failures are silent — this block MUST NOT prevent
+# session start. Same 4s read / 3s write timeouts as the suggestion block above.
+# Mirrors _rulemetric_suggest_instructions() deliberately.
+_rulemetric_inject_memories() {
+  local api_url="${RULEMETRIC_API_URL:-}"
+  local auth_token="${RULEMETRIC_API_KEY:-${RULEMETRIC_ACCESS_TOKEN:-}}"
+  local project_path
+  project_path="$(realpath -m "$(pwd)" 2>/dev/null || pwd)"
+
+  [ -n "$api_url" ] && [ -n "$auth_token" ] || return 0
+  command -v jq >/dev/null 2>&1 || return 0
+
+  local encoded_path
+  encoded_path="$(python3 -c \
+    "import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1]))" \
+    "$project_path" 2>/dev/null)" || encoded_path="$project_path"
+
+  local response
+  # Cap at 10 so a large memory set can't blow the context budget. Trust-gated
+  # priority ordering (inject the proven-helpful ones first) is the distiller's
+  # job — a later slice; today this is newest-active-first.
+  response="$(curl -s --noproxy '*' --max-time 4 \
+    "${api_url}/api/memories?projectPath=${encoded_path}&status=active&limit=10" \
+    -H "Authorization: Bearer ${auth_token}" 2>/dev/null)" || return 0
+
+  local count
+  count="$(printf '%s' "$response" | jq -r '.memories | length' 2>/dev/null)" || return 0
+  [ "$count" != "0" ] && [ "$count" != "null" ] && [ -n "$count" ] || return 0
+
+  printf '\n---\n'
+  printf '[rulemetric] %s durable project memory(ies) from prior sessions included as context.\n' "$count"
+
+  local i=0
+  while [ "$i" -lt "$count" ]; do
+    local kind title body
+    kind="$(printf '%s' "$response"  | jq -r ".memories[$i].kind"  2>/dev/null)" || break
+    title="$(printf '%s' "$response" | jq -r ".memories[$i].title" 2>/dev/null)" || break
+    body="$(printf '%s' "$response"  | jq -r ".memories[$i].body"  2>/dev/null)" || break
+    printf '\n### [%s] %s\n%s\n' "$kind" "$title" "$body"
+    i=$((i + 1))
+  done
+
+  printf '\n---\n'
+
+  # Stamp an exposure per injected memory (fire-and-forget). Keyed by the harness
+  # session id (HOOK_SESSION_ID); the DB session is created later by the proxy, so
+  # the API buffers the exposure (pending_treatment_exposures) and reconciles it to
+  # a treatment_exposures row at session close. Idempotent server-side, so duplicate
+  # hook fires are safe.
+  i=0
+  while [ "$i" -lt "$count" ]; do
+    local mid
+    mid="$(printf '%s' "$response" | jq -r ".memories[$i].id" 2>/dev/null)" || break
+    curl -s --noproxy '*' --max-time 3 -X POST \
+      "${api_url}/api/memories/${mid}/exposures" \
+      -H "Authorization: Bearer ${auth_token}" \
+      -H "Content-Type: application/json" \
+      -d "$(jq -n --arg externalSessionId "$HOOK_SESSION_ID" --arg projectPath "$project_path" \
+        '{externalSessionId: $externalSessionId, projectPath: $projectPath}')" \
+      >/dev/null 2>&1 &
+    disown 2>/dev/null || true
+    i=$((i + 1))
+  done
+}
+
+_rulemetric_inject_memories || true