feed-the-machine 1.6.1 → 1.7.1

package/hooks/ftm-map-autodetect.sh

@@ -1,79 +1,79 @@
-#!/usr/bin/env bash
-# UserPromptSubmit hook: auto-detect unmapped projects when ftm skills are invoked.
-# Detects greenfield vs brownfield and injects instructions to bootstrap ftm-map.
-# Only fires once per project (writes .ftm-map/.offered marker).
-
-set -euo pipefail
-
-INPUT=$(cat)
-PROMPT=$(echo "$INPUT" | jq -r '.prompt // ""' 2>/dev/null)
-
-# Quick exit if no prompt or jq unavailable
-[ -n "$PROMPT" ] || exit 0
-
-# Only fire on ftm-related invocations
-PROMPT_LOWER=$(echo "$PROMPT" | tr '[:upper:]' '[:lower:]')
-IS_FTM=false
-for trigger in "/ftm" "ftm-" "brainstorm" "research" "debug this" "audit" "deep dive" "investigate"; do
-  if [[ "$PROMPT_LOWER" == *"$trigger"* ]]; then
-    IS_FTM=true
-    break
-  fi
-done
-$IS_FTM || exit 0
-
-# Already mapped — nothing to do
-[ -f ".ftm-map/map.db" ] && exit 0
-
-# Already offered for this project — don't nag
-[ -f ".ftm-map/.offered" ] && exit 0
-
-# --- Greenfield vs Brownfield detection ---
-
-# Count source files (fast, capped at 500 to avoid slow ls on huge repos)
-SRC_COUNT=0
-if command -v find &>/dev/null; then
-  SRC_COUNT=$(find . -maxdepth 4 \
-    \( -name "*.py" -o -name "*.js" -o -name "*.ts" -o -name "*.tsx" \
-       -o -name "*.jsx" -o -name "*.go" -o -name "*.rs" -o -name "*.swift" \
-       -o -name "*.java" -o -name "*.rb" -o -name "*.sh" -o -name "*.mjs" \
-       -o -name "*.cjs" \) \
-    -not -path "*/node_modules/*" \
-    -not -path "*/.venv/*" \
-    -not -path "*/__pycache__/*" \
-    -not -path "*/.git/*" \
-    -not -path "*/.worktrees/*" \
-    2>/dev/null | head -500 | wc -l | tr -d ' ')
-fi
-
-# Git history depth
-COMMIT_COUNT=0
-if git rev-parse --is-inside-work-tree &>/dev/null 2>&1; then
-  COMMIT_COUNT=$(git rev-list --count HEAD 2>/dev/null || echo "0")
-fi
-
-# Classify
-if [ "$SRC_COUNT" -le 5 ] && [ "$COMMIT_COUNT" -le 3 ]; then
-  PROJECT_TYPE="greenfield"
-  PROJECT_DESC="Greenfield project (~${SRC_COUNT} source files, ${COMMIT_COUNT} commits). Small enough to index instantly."
-elif [ "$SRC_COUNT" -le 50 ]; then
-  PROJECT_TYPE="small-brownfield"
-  PROJECT_DESC="Small brownfield project (~${SRC_COUNT} source files, ${COMMIT_COUNT} commits). Quick to index."
-elif [ "$SRC_COUNT" -le 200 ]; then
-  PROJECT_TYPE="medium-brownfield"
-  PROJECT_DESC="Medium brownfield project (~${SRC_COUNT} source files, ${COMMIT_COUNT} commits). Index takes ~30s."
-else
-  PROJECT_TYPE="large-brownfield"
-  PROJECT_DESC="Large brownfield project (~${SRC_COUNT} source files, ${COMMIT_COUNT} commits). Index may take 1-2 min."
-fi
-
-# Write marker so we don't ask again
-mkdir -p .ftm-map
-echo "$PROJECT_TYPE" > .ftm-map/.offered
-
-# Inject context
-cat <<EOJSON
-{
-  "additionalContext": "[ftm-map-autodetect] This project has no code knowledge graph yet (.ftm-map/map.db missing). ${PROJECT_DESC} Before proceeding with the ftm skill, bootstrap the map: run \`ftm-map/scripts/setup.sh\` then \`ftm-map/scripts/.venv/bin/python3 ftm-map/scripts/index.py --bootstrap .\` in the background. This enables structural queries (blast radius, dependency chains) and keeps INTENT.md/ARCHITECTURE.mmd in sync via the post-commit hook. If the user's request is time-sensitive, proceed with the skill and index in parallel."
-}
-EOJSON
+#!/usr/bin/env bash
+# UserPromptSubmit hook: auto-detect unmapped projects when ftm skills are invoked.
+# Detects greenfield vs brownfield and injects instructions to bootstrap ftm-map.
+# Only fires once per project (writes .ftm-map/.offered marker).
+
+set -euo pipefail
+
+INPUT=$(cat)
+PROMPT=$(echo "$INPUT" | jq -r '.prompt // ""' 2>/dev/null)
+
+# Quick exit if no prompt or jq unavailable
+[ -n "$PROMPT" ] || exit 0
+
+# Only fire on ftm-related invocations
+PROMPT_LOWER=$(echo "$PROMPT" | tr '[:upper:]' '[:lower:]')
+IS_FTM=false
+for trigger in "/ftm" "ftm-" "brainstorm" "research" "debug this" "audit" "deep dive" "investigate"; do
+  if [[ "$PROMPT_LOWER" == *"$trigger"* ]]; then
+    IS_FTM=true
+    break
+  fi
+done
+$IS_FTM || exit 0
+
+# Already mapped — nothing to do
+[ -f ".ftm-map/map.db" ] && exit 0
+
+# Already offered for this project — don't nag
+[ -f ".ftm-map/.offered" ] && exit 0
+
+# --- Greenfield vs Brownfield detection ---
+
+# Count source files (fast, capped at 500 to avoid slow ls on huge repos)
+SRC_COUNT=0
+if command -v find &>/dev/null; then
+  SRC_COUNT=$(find . -maxdepth 4 \
+    \( -name "*.py" -o -name "*.js" -o -name "*.ts" -o -name "*.tsx" \
+       -o -name "*.jsx" -o -name "*.go" -o -name "*.rs" -o -name "*.swift" \
+       -o -name "*.java" -o -name "*.rb" -o -name "*.sh" -o -name "*.mjs" \
+       -o -name "*.cjs" \) \
+    -not -path "*/node_modules/*" \
+    -not -path "*/.venv/*" \
+    -not -path "*/__pycache__/*" \
+    -not -path "*/.git/*" \
+    -not -path "*/.worktrees/*" \
+    2>/dev/null | head -500 | wc -l | tr -d ' ')
+fi
+
+# Git history depth
+COMMIT_COUNT=0
+if git rev-parse --is-inside-work-tree &>/dev/null 2>&1; then
+  COMMIT_COUNT=$(git rev-list --count HEAD 2>/dev/null || echo "0")
+fi
+
+# Classify
+if [ "$SRC_COUNT" -le 5 ] && [ "$COMMIT_COUNT" -le 3 ]; then
+  PROJECT_TYPE="greenfield"
+  PROJECT_DESC="Greenfield project (~${SRC_COUNT} source files, ${COMMIT_COUNT} commits). Small enough to index instantly."
+elif [ "$SRC_COUNT" -le 50 ]; then
+  PROJECT_TYPE="small-brownfield"
+  PROJECT_DESC="Small brownfield project (~${SRC_COUNT} source files, ${COMMIT_COUNT} commits). Quick to index."
+elif [ "$SRC_COUNT" -le 200 ]; then
+  PROJECT_TYPE="medium-brownfield"
+  PROJECT_DESC="Medium brownfield project (~${SRC_COUNT} source files, ${COMMIT_COUNT} commits). Index takes ~30s."
+else
+  PROJECT_TYPE="large-brownfield"
+  PROJECT_DESC="Large brownfield project (~${SRC_COUNT} source files, ${COMMIT_COUNT} commits). Index may take 1-2 min."
+fi
+
+# Write marker so we don't ask again
+mkdir -p .ftm-map
+echo "$PROJECT_TYPE" > .ftm-map/.offered
+
+# Inject context
+cat <<EOJSON
+{
+  "additionalContext": "[ftm-map-autodetect] This project has no code knowledge graph yet (.ftm-map/map.db missing). ${PROJECT_DESC} Before proceeding with the ftm skill, bootstrap the map: run \`ftm-map/scripts/setup.sh\` then \`ftm-map/scripts/.venv/bin/python3 ftm-map/scripts/index.py --bootstrap .\` in the background. This enables structural queries (blast radius, dependency chains) and keeps INTENT.md/ARCHITECTURE.mmd in sync via the post-commit hook. If the user's request is time-sensitive, proceed with the skill and index in parallel."
+}
+EOJSON

package/hooks/ftm-pending-sync-check.sh

@@ -1,22 +1,22 @@
-#!/usr/bin/env bash
-# UserPromptSubmit hook: checks for pending commit syncs from out-of-session commits
-
-PENDING_FILE="$HOME/.claude/ftm-state/.pending-commit-syncs"
-
-# Quick exit if no pending syncs
-[ -f "$PENDING_FILE" ] || { echo '{}'; exit 0; }
-[ -s "$PENDING_FILE" ] || { echo '{}'; exit 0; }
-
-# Count pending entries
-COUNT=$(wc -l < "$PENDING_FILE" | tr -d ' ')
-
-# Read all pending entries
-ENTRIES=$(cat "$PENDING_FILE")
-
-# Consume the file (mark as processed)
-rm -f "$PENDING_FILE"
-
-# Inject context
-cat <<EOJSON
-{"additionalContext": "There are $COUNT pending out-of-session commits that need ftm-map incremental sync. Run ftm-map incremental for each:\n$ENTRIES"}
-EOJSON
+#!/usr/bin/env bash
+# UserPromptSubmit hook: checks for pending commit syncs from out-of-session commits
+
+PENDING_FILE="$HOME/.claude/ftm-state/.pending-commit-syncs"
+
+# Quick exit if no pending syncs
+[ -f "$PENDING_FILE" ] || { echo '{}'; exit 0; }
+[ -s "$PENDING_FILE" ] || { echo '{}'; exit 0; }
+
+# Count pending entries
+COUNT=$(wc -l < "$PENDING_FILE" | tr -d ' ')
+
+# Read all pending entries
+ENTRIES=$(cat "$PENDING_FILE")
+
+# Consume the file (mark as processed)
+rm -f "$PENDING_FILE"
+
+# Inject context
+cat <<EOJSON
+{"additionalContext": "There are $COUNT pending out-of-session commits that need ftm-map incremental sync. Run ftm-map incremental for each:\n$ENTRIES"}
+EOJSON

package/hooks/ftm-plan-gate.sh

@@ -1,92 +1,92 @@
-#!/usr/bin/env bash
-# ftm-plan-gate.sh
-# PreToolUse hook for Edit/Write tools.
-#
-# Checks if a plan has been presented this session before allowing code edits.
-# If no plan marker exists and the edit count is climbing, injects warnings
-# telling Claude to stop and present a plan first.
-#
-# The marker file (~/.claude/ftm-state/.plan-presented) is created by Claude
-# when it presents a plan. Any non-empty content counts as "plan presented".
-# The file is cleaned up by the blackboard enforcer at session end.
-#
-# Hook: PreToolUse (matcher: Edit|Write)
-
-set -euo pipefail
-
-INPUT=$(cat)
-TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // ""')
-
-# Only gate Edit and Write tools
-if [[ "$TOOL_NAME" != "Edit" && "$TOOL_NAME" != "Write" ]]; then
-  exit 0
-fi
-
-STATE_DIR="$HOME/.claude/ftm-state"
-PLAN_MARKER="$STATE_DIR/.plan-presented"
-EDIT_COUNTER="$STATE_DIR/.edit-count"
-
-# Get the file being edited
-FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // ""')
-
-# Always allow edits to: skill files, ftm-state, drafts, .gitignore, markdown docs
-# These are "meta" edits that happen during planning/setup, not code grinding
-if [[ "$FILE_PATH" == *".claude/skills/"* ]] || \
-   [[ "$FILE_PATH" == *".claude/ftm-state/"* ]] || \
-   [[ "$FILE_PATH" == *".ftm-drafts/"* ]] || \
-   [[ "$FILE_PATH" == *".gitignore" ]] || \
-   [[ "$FILE_PATH" == *"INTENT.md"* ]] || \
-   [[ "$FILE_PATH" == *"ARCHITECTURE.mmd"* ]] || \
-   [[ "$FILE_PATH" == *"STYLE.md"* ]] || \
-   [[ "$FILE_PATH" == *"DEBUG.md"* ]] || \
-   [[ "$FILE_PATH" == *"PROGRESS.md"* ]] || \
-   [[ "$FILE_PATH" == *"CLAUDE.md"* ]]; then
-  exit 0
-fi
-
-# If plan marker exists (any content), allow edits
-if [[ -f "$PLAN_MARKER" ]] && [[ -s "$PLAN_MARKER" ]]; then
-  exit 0
-fi
-
-# Reset edit counter if it's stale (older than 4 hours = likely a new session)
-if [[ -f "$EDIT_COUNTER" ]]; then
-  COUNTER_AGE=$(( $(date +%s) - $(stat -c %Y "$EDIT_COUNTER" 2>/dev/null || echo "0") ))
-  if [[ "$COUNTER_AGE" -gt 14400 ]]; then
-    rm -f "$EDIT_COUNTER"
-  fi
-fi
-
-# Count edits without a plan marker
-EDIT_COUNT=0
-if [[ -f "$EDIT_COUNTER" ]]; then
-  EDIT_COUNT=$(cat "$EDIT_COUNTER" 2>/dev/null || echo "0")
-fi
-
-EDIT_COUNT=$((EDIT_COUNT + 1))
-echo "$EDIT_COUNT" > "$EDIT_COUNTER"
-
-# First 2 edits get a soft reminder (don't block — could be micro tasks)
-# After 3+ edits without a plan marker, escalate the warning
-if [[ $EDIT_COUNT -le 2 ]]; then
-  cat <<'JSON'
-{
-  "hookSpecificOutput": {
-    "hookEventName": "PreToolUse",
-    "additionalContext": "[ftm-plan-gate] You are editing files without having presented a plan this session. If this task is medium+ (touches 3+ files, involves external systems, or has stakeholder coordination), you MUST present a numbered plan and get user approval BEFORE editing code. If this is a micro/small task, you can proceed — but create the plan marker: write any content to ~/.claude/ftm-state/.plan-presented to acknowledge you've considered it."
-  }
-}
-JSON
-  exit 0
-fi
-
-# 3+ edits without a plan — stronger warning
-cat <<'JSON'
-{
-  "hookSpecificOutput": {
-    "hookEventName": "PreToolUse",
-    "additionalContext": "[ftm-plan-gate WARNING] You have made 3+ file edits this session without presenting a plan. This is exactly the 'grinding without a plan' pattern that ftm-mind is supposed to prevent. STOP editing and do one of: (1) Present a numbered plan to the user and wait for approval, then write any content to ~/.claude/ftm-state/.plan-presented. (2) If the user explicitly said 'just do it' or this is genuinely a micro task, write the plan marker to acknowledge you've considered it. Do NOT continue editing without addressing this."
-  }
-}
-JSON
-exit 0
+#!/usr/bin/env bash
+# ftm-plan-gate.sh
+# PreToolUse hook for Edit/Write tools.
+#
+# Checks if a plan has been presented this session before allowing code edits.
+# If no plan marker exists and the edit count is climbing, injects warnings
+# telling Claude to stop and present a plan first.
+#
+# The marker file (~/.claude/ftm-state/.plan-presented) is created by Claude
+# when it presents a plan. Any non-empty content counts as "plan presented".
+# The file is cleaned up by the blackboard enforcer at session end.
+#
+# Hook: PreToolUse (matcher: Edit|Write)
+
+set -euo pipefail
+
+INPUT=$(cat)
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // ""')
+
+# Only gate Edit and Write tools
+if [[ "$TOOL_NAME" != "Edit" && "$TOOL_NAME" != "Write" ]]; then
+  exit 0
+fi
+
+STATE_DIR="$HOME/.claude/ftm-state"
+PLAN_MARKER="$STATE_DIR/.plan-presented"
+EDIT_COUNTER="$STATE_DIR/.edit-count"
+
+# Get the file being edited
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // ""')
+
+# Always allow edits to: skill files, ftm-state, drafts, .gitignore, markdown docs
+# These are "meta" edits that happen during planning/setup, not code grinding
+if [[ "$FILE_PATH" == *".claude/skills/"* ]] || \
+   [[ "$FILE_PATH" == *".claude/ftm-state/"* ]] || \
+   [[ "$FILE_PATH" == *".ftm-drafts/"* ]] || \
+   [[ "$FILE_PATH" == *".gitignore" ]] || \
+   [[ "$FILE_PATH" == *"INTENT.md"* ]] || \
+   [[ "$FILE_PATH" == *"ARCHITECTURE.mmd"* ]] || \
+   [[ "$FILE_PATH" == *"STYLE.md"* ]] || \
+   [[ "$FILE_PATH" == *"DEBUG.md"* ]] || \
+   [[ "$FILE_PATH" == *"PROGRESS.md"* ]] || \
+   [[ "$FILE_PATH" == *"CLAUDE.md"* ]]; then
+  exit 0
+fi
+
+# If plan marker exists (any content), allow edits
+if [[ -f "$PLAN_MARKER" ]] && [[ -s "$PLAN_MARKER" ]]; then
+  exit 0
+fi
+
+# Reset edit counter if it's stale (older than 4 hours = likely a new session)
+if [[ -f "$EDIT_COUNTER" ]]; then
+  COUNTER_AGE=$(( $(date +%s) - $(stat -c %Y "$EDIT_COUNTER" 2>/dev/null || echo "0") ))
+  if [[ "$COUNTER_AGE" -gt 14400 ]]; then
+    rm -f "$EDIT_COUNTER"
+  fi
+fi
+
+# Count edits without a plan marker
+EDIT_COUNT=0
+if [[ -f "$EDIT_COUNTER" ]]; then
+  EDIT_COUNT=$(cat "$EDIT_COUNTER" 2>/dev/null || echo "0")
+fi
+
+EDIT_COUNT=$((EDIT_COUNT + 1))
+echo "$EDIT_COUNT" > "$EDIT_COUNTER"
+
+# First 2 edits get a soft reminder (don't block — could be micro tasks)
+# After 3+ edits without a plan marker, escalate the warning
+if [[ $EDIT_COUNT -le 2 ]]; then
+  cat <<'JSON'
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "additionalContext": "[ftm-plan-gate] You are editing files without having presented a plan this session. If this task is medium+ (touches 3+ files, involves external systems, or has stakeholder coordination), you MUST present a numbered plan and get user approval BEFORE editing code. If this is a micro/small task, you can proceed — but create the plan marker: write any content to ~/.claude/ftm-state/.plan-presented to acknowledge you've considered it."
+  }
+}
+JSON
+  exit 0
+fi
+
+# 3+ edits without a plan — stronger warning
+cat <<'JSON'
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "additionalContext": "[ftm-plan-gate WARNING] You have made 3+ file edits this session without presenting a plan. This is exactly the 'grinding without a plan' pattern that ftm-mind is supposed to prevent. STOP editing and do one of: (1) Present a numbered plan to the user and wait for approval, then write any content to ~/.claude/ftm-state/.plan-presented. (2) If the user explicitly said 'just do it' or this is genuinely a micro task, write the plan marker to acknowledge you've considered it. Do NOT continue editing without addressing this."
+  }
+}
+JSON
+exit 0

package/hooks/ftm-post-commit-trigger.sh

@@ -1,57 +1,57 @@
-#!/usr/bin/env bash
-# PostToolUse hook: detect git commits and inject ftm-map update instructions
-
-set -euo pipefail
-
-# Read stdin into variable
-INPUT=$(cat)
-
-# Exit gracefully if stdin is empty or jq is unavailable
-if [ -z "$INPUT" ]; then
-  echo "{}"
-  exit 0
-fi
-
-if ! command -v jq &>/dev/null; then
-  echo "{}"
-  exit 0
-fi
-
-# Extract tool_name
-TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
-
-if [ -z "$TOOL_NAME" ]; then
-  echo "{}"
-  exit 0
-fi
-
-# Check if this is a commit operation
-IS_COMMIT=0
-
-if [ "$TOOL_NAME" = "mcp__git__git_commit" ]; then
-  IS_COMMIT=1
-elif [ "$TOOL_NAME" = "Bash" ]; then
-  COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
-  if [ -n "$COMMAND" ] && echo "$COMMAND" | grep -qE '^\s*git\s+commit'; then
-    IS_COMMIT=1
-  fi
-fi
-
-# Exit quickly for non-commit operations
-if [ "$IS_COMMIT" -eq 0 ]; then
-  echo "{}"
-  exit 0
-fi
-
-# Only trigger for mapped projects
-if [ ! -f ".ftm-map/map.db" ]; then
-  echo "{}"
-  exit 0
-fi
-
-# Output additionalContext to trigger ftm-map update workflow
-cat <<'EOF'
-{
-  "additionalContext": "A commit was just made. Run ftm-map incremental on changed files, then update INTENT.md and ARCHITECTURE.mmd via ftm-intent and ftm-diagram."
-}
-EOF
+#!/usr/bin/env bash
+# PostToolUse hook: detect git commits and inject ftm-map update instructions
+
+set -euo pipefail
+
+# Read stdin into variable
+INPUT=$(cat)
+
+# Exit gracefully if stdin is empty or jq is unavailable
+if [ -z "$INPUT" ]; then
+  echo "{}"
+  exit 0
+fi
+
+if ! command -v jq &>/dev/null; then
+  echo "{}"
+  exit 0
+fi
+
+# Extract tool_name
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
+
+if [ -z "$TOOL_NAME" ]; then
+  echo "{}"
+  exit 0
+fi
+
+# Check if this is a commit operation
+IS_COMMIT=0
+
+if [ "$TOOL_NAME" = "mcp__git__git_commit" ]; then
+  IS_COMMIT=1
+elif [ "$TOOL_NAME" = "Bash" ]; then
+  COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
+  if [ -n "$COMMAND" ] && echo "$COMMAND" | grep -qE '^\s*git\s+commit'; then
+    IS_COMMIT=1
+  fi
+fi
+
+# Exit quickly for non-commit operations
+if [ "$IS_COMMIT" -eq 0 ]; then
+  echo "{}"
+  exit 0
+fi
+
+# Only trigger for mapped projects
+if [ ! -f ".ftm-map/map.db" ]; then
+  echo "{}"
+  exit 0
+fi
+
+# Output additionalContext to trigger ftm-map update workflow
+cat <<'EOF'
+{
+  "additionalContext": "A commit was just made. Run ftm-map incremental on changed files, then update INTENT.md and ARCHITECTURE.mmd via ftm-intent and ftm-diagram."
+}
+EOF

package/hooks/ftm-post-compaction.sh

@@ -0,0 +1,138 @@
+#!/bin/bash
+# ftm-post-compaction.sh
+# Hook: Post-compaction context restoration for ftm
+# Trigger: UserPromptSubmit
+#
+# Detects when Claude Code has just compacted the session (context was compressed).
+# After compaction, Claude's in-memory context is reset to a summary — it loses
+# the session's working state. This hook injects a re-initialization prompt that
+# tells Claude to reload its state from disk before responding.
+#
+# Detection method: compaction DECREASES the session JSONL line count in-place
+# (same session_id, fewer lines). We track {session_id, line_count} between
+# invocations in .session-state to detect this.
+#
+# Ported from OpenClaw's post-compaction-context.ts pattern.
+#
+# FILES:
+#   ~/.claude/ftm-state/blackboard/context.json  - session gate
+#   ~/.claude/ftm-state/.session-state            - JSON: {session_id, line_count}
+
+FTM_STATE="$HOME/.claude/ftm-state"
+CONTEXT_JSON="$FTM_STATE/blackboard/context.json"
+SESSION_STATE_FILE="$FTM_STATE/.session-state"
+
+# 1. Only run during active ftm sessions
+FTM_ACTIVE=$(python3 -c "
+import json, sys
+try:
+    with open('$CONTEXT_JSON') as f:
+        d = json.load(f)
+    task = d.get('current_task', {})
+    status = task.get('status', '')
+    print('1' if status not in ('', 'completed', 'none') else '0')
+except Exception:
+    print('0')
+" 2>/dev/null)
+
+if [ "$FTM_ACTIVE" != "1" ]; then
+    exit 0
+fi
+
+# 2. Read hook payload from stdin
+PAYLOAD=$(cat)
+if [ -z "$PAYLOAD" ]; then
+    exit 0
+fi
+
+SESSION_ID=$(echo "$PAYLOAD" | python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    print(d.get('session_id', ''))
+except:
+    print('')
+" 2>/dev/null)
+
+TRANSCRIPT_PATH=$(echo "$PAYLOAD" | python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    print(d.get('transcript_path', ''))
+except:
+    print('')
+" 2>/dev/null)
+
+if [ -z "$SESSION_ID" ]; then
+    exit 0
+fi
+
+# 3. Find session JSONL
+JSONL_FILE=""
+if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
+    JSONL_FILE="$TRANSCRIPT_PATH"
+elif [ -n "$SESSION_ID" ]; then
+    JSONL_FILE=$(find "$HOME/.claude/projects/" -name "${SESSION_ID}.jsonl" 2>/dev/null | head -1)
+fi
+
+if [ -z "$JSONL_FILE" ] || [ ! -f "$JSONL_FILE" ]; then
+    exit 0
+fi
+
+# 4. Get current line count
+CURRENT_LINES=$(wc -l < "$JSONL_FILE" 2>/dev/null | tr -d ' ')
+CURRENT_LINES=${CURRENT_LINES:-0}
+
+# 5. Read stored state
+STORED_STATE=$(cat "$SESSION_STATE_FILE" 2>/dev/null || echo '{}')
+STORED_SESSION=$(echo "$STORED_STATE" | python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    print(d.get('session_id', ''))
+except:
+    print('')
+" 2>/dev/null)
+STORED_LINES=$(echo "$STORED_STATE" | python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    print(d.get('line_count', 0))
+except:
+    print(0)
+" 2>/dev/null)
+
+# 6. Always update stored state with current values
+python3 -c "
+import json
+with open('$SESSION_STATE_FILE', 'w') as f:
+    json.dump({'session_id': '$SESSION_ID', 'line_count': $CURRENT_LINES}, f)
+" 2>/dev/null
+
+# 7. Detect compaction: same session, line count DECREASED
+if [ "$STORED_SESSION" != "$SESSION_ID" ]; then
+    exit 0  # New session, not compaction
+fi
+
+if [ -z "$STORED_LINES" ] || [ "$STORED_LINES" = "0" ]; then
+    exit 0  # No baseline yet
+fi
+
+# Check if line count dropped (with a meaningful threshold to avoid noise)
+DIFF=$(( STORED_LINES - CURRENT_LINES ))
+if [ "$DIFF" -lt 10 ] 2>/dev/null; then
+    exit 0  # Line count didn't drop significantly — no compaction
+fi
+
+# 8. Compaction detected! Inject context restoration prompt
+TODAY=$(date +%Y-%m-%d)
+
+echo ""
+echo "[POST-COMPACTION RESTORE — session context was just compacted]:"
+echo "The conversation was just summarized and your in-session state was reset."
+echo "State was preserved in ftm-state. BEFORE responding to the message below:"
+echo "1. Read ~/.claude/ftm-state/blackboard/context.json (current task and session state)"
+echo "2. Read any relevant daily log or session snapshot from ~/.claude/ftm-state/sessions/"
+echo "Then respond as if you just loaded into a fresh ftm session."
+echo "Do not announce this restoration to the user — just do it and proceed."
+echo ""