feed-the-machine 1.0.0 → 1.2.0

package/ftm-resume/SKILL.md

@@ -164,3 +164,50 @@ To save a session for later:
 2. When you need to stop, use /ftm-pause
 3. In a new conversation, use /ftm-resume to continue
 ```
+
+## Requirements
+
+- reference: `~/.claude/ftm-state/STATE.md` | required | saved session state file from ftm-pause
+- reference: `../ftm-pause/references/protocols/SKILL-RESTORE-PROTOCOLS.md` | required | per-skill state field restoration instructions
+- reference: `../ftm-pause/references/protocols/VALIDATION.md` | required | validation protocol for state file integrity
+- reference: `~/.claude/ftm-state/archive/` | optional | archived prior state files
+- tool: `git` | optional | checking git state drift since session was paused
+
+## Risk
+
+- level: low_write
+- scope: archives STATE.md by moving it to ~/.claude/ftm-state/archive/; invokes the target ftm skill with restored context; does not modify project source files
+- rollback: copy archived STATE.md back from archive if restoration was incorrect
+
+## Approval Gates
+
+- trigger: validation finds warnings (git drift, stale state, missing artifacts) | action: present consolidated validation summary and require user acknowledgment before proceeding
+- trigger: validation finds block-level failure | action: stop and report failure; do not invoke target skill
+- trigger: user provides new context along with "yes" | action: capture as post-pause update and inject into skill invocation
+- complexity_routing: micro → auto | small → auto | medium → auto | large → auto | xl → auto
+
+## Fallbacks
+
+- condition: STATE.md not found | action: report "No saved ftm session found" with instructions for saving sessions
+- condition: STATE.md frontmatter missing required fields | action: report validation failure with specific missing fields
+- condition: multiple STATE.md files (STATE.md + STATE-*.md) | action: ask user which to resume, list each with skill type and timestamp
+- condition: state is >7 days old | action: flag as potentially stale with warning, require user acknowledgment
+
+## Capabilities
+
+- cli: `git` | optional | branch and commit state validation
+- env: none required
+
+## Event Payloads
+
+### session_resumed
+- skill: string — "ftm-resume"
+- resumed_skill: string — the ftm skill that was re-invoked
+- phase: string — phase the session is resuming at
+- state_age_hours: number — how long ago the session was paused
+- post_pause_update: boolean — whether user provided new context
+
+### task_completed
+- skill: string — "ftm-resume"
+- resumed_skill: string — the ftm skill re-invoked
+- state_file_archived: string — path where STATE.md was archived

package/ftm-retro/SKILL.md

@@ -187,3 +187,57 @@ After completing, update:
 2. Write experience file to `~/.claude/ftm-state/blackboard/experiences/YYYY-MM-DD_task-slug.json`
 3. Update `experiences/index.json` with the new entry
 4. Emit `task_completed`
+
+## Requirements
+
+- reference: `PROGRESS.md` | optional | executor progress log for auto-triggered mode
+- reference: `~/.claude/ftm-retros/` | optional | prior retro files for pattern analysis
+- reference: `references/protocols/SCORING-RUBRICS.md` | required | scoring scale breakpoints and evidence requirements
+- reference: `references/templates/REPORT-FORMAT.md` | required | retro report output template
+- reference: `~/.claude/ftm-state/blackboard/experiences/index.json` | optional | experience inventory for micro-reflection mode
+- reference: `~/.claude/ftm-state/blackboard/patterns.json` | optional | pattern registry for promotion and decay
+
+## Risk
+
+- level: low_write
+- scope: writes retro report to ~/.claude/ftm-retros/; writes experience files to blackboard; promotes patterns to patterns.json; does not modify project source files
+- rollback: delete retro report file; remove experience entry from blackboard
+
+## Approval Gates
+
+- trigger: pattern promotion triggered (3+ matching experiences) | action: auto-promote to patterns.json without user gate (learning system behavior)
+- complexity_routing: micro → auto | small → auto | medium → auto | large → auto | xl → auto
+
+## Fallbacks
+
+- condition: PROGRESS.md not found and manual mode | action: check ~/.claude/ftm-retros/ for most recent .md file; ask user which execution to review if multiple found
+- condition: execution context not provided by ftm-executor | action: reconstruct from PROGRESS.md or ask user for context
+- condition: scoring rubric file missing | action: apply built-in scoring heuristics from skill body
+- condition: experiences/index.json has fewer than 10 entries | action: cold-start mode — record every task, set all confidence to low
+
+## Capabilities
+
+- env: none required
+
+## Event Payloads
+
+### experience_recorded
+- skill: string — "ftm-retro"
+- experience_path: string — path to written experience file
+- task_type: string — type of task recorded
+- outcome: string — success | partial | failure
+- confidence: string — low | medium | high
+
+### pattern_discovered
+- skill: string — "ftm-retro"
+- pattern_name: string — name of the promoted pattern
+- category: string — codebase_insights | execution_patterns | user_behavior | recurring_issues
+- occurrence_count: number — number of experiences that triggered promotion
+- confidence: string — low | medium | high
+
+### task_completed
+- skill: string — "ftm-retro"
+- report_path: string — absolute path to saved retro report
+- overall_score: number — total score out of 50
+- top_issue: string — most impactful bottleneck identified
+- patterns_promoted: number — new patterns added to patterns.json

package/ftm-routine/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: ftm-routine
+description: Execute named, recurring multi-step workflows from YAML definitions. Use when user says "routine", "run routine", "ftm-routine", "morning triage", or names a known routine.
+---
+
+# FTM Routine Runner
+
+Routines are named, recurring multi-step workflows defined as YAML in `~/.ftm/routines/`. Each routine specifies steps that combine skill invocations, MCP operations, and approval gates.
+
+## Routine Format
+
+Routines are stored as YAML files in `~/.ftm/routines/`:
+
+```yaml
+name: morning-triage
+description: Check all inboxes, prioritize, and plan the day
+trigger: manual  # only "manual" for v1, future: "schedule", "event"
+tags: [triage, daily, ops]
+
+steps:
+  - name: Check Jira backlog
+    action: mcp
+    tool: jira_search
+    params:
+      jql: "assignee = currentUser() AND status != Done ORDER BY priority DESC"
+    approval: none  # no approval needed for read operations
+
+  - name: Check Freshservice tickets
+    action: mcp
+    tool: get_tickets
+    params:
+      filter: "agent_id:me AND status:2"  # open tickets assigned to me
+    approval: none
+
+  - name: Check Slack mentions
+    action: mcp
+    tool: slack_get_channel_history
+    params:
+      channel: "general"
+      limit: 20
+    approval: none
+
+  - name: Check email
+    action: mcp
+    tool: search_emails
+    params:
+      query: "is:unread"
+      max_results: 10
+    approval: none
+
+  - name: Synthesize and prioritize
+    action: skill
+    skill: ftm-mind
+    input: "Based on the above: prioritize today's work. What's urgent? What can wait?"
+    approval: review  # show synthesis for user review before proceeding
+
+  - name: Create today's plan
+    action: skill
+    skill: ftm-mind
+    input: "Create a plan for today's top 3 priorities"
+    approval: approve  # full plan approval before execution
+```
+
+## Invocation
+
+```
+/ftm-routine morning-triage
+```
+
+Or via ftm-mind when it detects a routine name:
+```
+/ftm run my morning triage
+```
+
+## Execution Flow
+
+1. **Load routine** — Read `~/.ftm/routines/[name].yml`
+2. **Validate** — Check all referenced MCP tools and skills are available
+3. **Present as plan** — Convert routine steps to the standard plan format:
+   ```
+   Routine: morning-triage — "Check all inboxes, prioritize, and plan the day"
+
+   1. Check Jira backlog (auto)
+   2. Check Freshservice tickets (auto)
+   3. Check Slack mentions (auto)
+   4. Check email (auto)
+   5. Synthesize and prioritize (review)
+   6. Create today's plan (approve)
+
+   Steps 1-4 run automatically. Step 5 pauses for your review.
+   Step 6 requires your approval before execution.
+
+   Say "go" to start.
+   ```
+4. **Execute** — Run steps in order, respecting approval gates:
+   - `approval: none` — execute automatically, show results
+   - `approval: review` — execute, show results, wait for "continue" or "stop"
+   - `approval: approve` — show plan, wait for "go" before executing
+
+## Step Types
+
+| Action | Description | Example |
+|---|---|---|
+| `mcp` | Call an MCP tool directly | `jira_search`, `slack_post_message` |
+| `skill` | Invoke an FTM skill | `ftm-mind`, `ftm-debug`, `ftm-brainstorm` |
+| `bash` | Run a shell command | `npm test`, `git status` |
+
+## Creating Routines
+
+Users create routines by:
+1. Writing YAML directly to `~/.ftm/routines/[name].yml`
+2. Saving a successful plan as a routine: "save as routine" (future enhancement)
+3. Asking ftm-mind: "create a routine for my morning triage"
+
+## Listing Routines
+
+```
+/ftm-routine list
+```
+Shows all routines in `~/.ftm/routines/` with name and description.
+
+## Example Routines
+
+### morning-triage
+Check Jira, Freshservice, Slack, email → synthesize → prioritize → plan
+
+### deploy-checklist
+Run tests → check CI → review changelog → create release tag → monitor
+
+### new-hire-setup
+Create accounts → set permissions → send welcome email → schedule onboarding
+
+### incident-response
+Check Sentry → check logs → notify channel → create Jira ticket → start investigation
+
+## Requirements
+
+- reference: `~/.ftm/routines/` | required | YAML routine definitions directory
+- config: `~/.claude/ftm-config.yml` | optional | model preferences for skill-type steps
+
+## Risk
+
+- level: medium_write
+- scope: executes MCP tool calls, skill invocations, and bash commands as defined by the routine; external-facing mutations depend entirely on routine definition; approval gates in the routine control which steps require user confirmation
+- rollback: depends on individual routine steps; steps with approval: approve gate let user review before execution; MCP writes (Jira, Slack, email) may not be reversible
+
+## Approval Gates
+
+- trigger: routine step with approval: approve | action: show plan for that step and wait for "go" before executing
+- trigger: routine step with approval: review | action: execute step, show results, wait for "continue" or "stop"
+- trigger: routine step with approval: none | action: execute automatically and show results
+- complexity_routing: micro → auto | small → auto | medium → plan_first (show full routine plan first) | large → plan_first | xl → always_ask
+
+## Fallbacks
+
+- condition: routine YAML file not found | action: show "Routine not found" with list of available routines from ~/.ftm/routines/
+- condition: MCP tool referenced in routine not available | action: report unavailable tool, ask user whether to skip that step or abort
+- condition: skill referenced in routine not available | action: report unavailable skill, ask user whether to skip or abort
+- condition: bash command in step fails with non-zero exit | action: report failure output, ask user whether to continue or abort
+
+## Capabilities
+
+- mcp: various | optional | determined by individual routine definitions
+- cli: various | optional | bash steps in routine definitions
+- env: none required directly
+
+## Event Payloads
+
+### (none)
+ftm-routine does not emit its own events. Events are emitted by the MCPs and skills invoked during routine execution.

package/ftm-state/blackboard/capabilities.json

@@ -0,0 +1,5 @@
+{
+  "discovered_at": null,
+  "expires_at": null,
+  "capabilities": []
+}

package/ftm-state/blackboard/capabilities.schema.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "FTM Capabilities Snapshot",
+  "type": "object",
+  "required": ["discovered_at", "expires_at", "capabilities"],
+  "properties": {
+    "discovered_at": { "type": "string", "format": "date-time" },
+    "expires_at": { "type": "string", "format": "date-time" },
+    "capabilities": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["name", "type", "verified", "confidence"],
+        "properties": {
+          "name": { "type": "string" },
+          "type": { "type": "string", "enum": ["mcp", "cli", "api", "env", "browser"] },
+          "verified": { "type": "boolean" },
+          "last_verified_at": { "type": "string", "format": "date-time" },
+          "operations_verified": { "type": "array", "items": { "type": "string" } },
+          "path": { "type": "string" },
+          "version": { "type": "string" },
+          "confidence": { "type": "string", "enum": ["verified", "known", "inferred", "unavailable"] }
+        }
+      }
+    }
+  }
+}

package/ftm-upgrade/SKILL.md

@@ -151,3 +151,44 @@ Map `CHECK_FAILED <reason>` codes to user-facing messages:
 **Cache location**: `~/.cache/ftm-brain/version-check`
 **Version file**: `~/.claude/skills/ftm-version.txt`
 **Repo**: `kkudumu/ftm-brain`
+
+## Requirements
+
+- tool: `gh` | required | GitHub CLI for querying releases from kkudumu/ftm-brain
+- reference: `~/.claude/skills/ftm-upgrade/scripts/check-version.sh` | required | version check and cache script
+- reference: `~/.claude/skills/ftm-upgrade/scripts/upgrade.sh` | required | download and install latest release script
+- reference: `~/.claude/skills/ftm-version.txt` | optional | locally installed version number
+
+## Risk
+
+- level: high_write
+- scope: downloads and overwrites skill files in ~/.claude/skills/ on upgrade; changes affect all ftm skill behavior going forward; irreversible without restoring previous version from backup or git
+- rollback: restore from ~/.claude/skills/ backup if one was made before upgrade; or reinstall specific version by downloading an older release tarball
+
+## Approval Gates
+
+- trigger: UPGRADE_AVAILABLE detected | action: show current and latest version with changelog URL, wait for explicit "yes" confirmation before running upgrade.sh
+- trigger: version check during preamble (passive notice pattern) | action: show one-line notice only, do NOT ask for confirmation or interrupt workflow
+- complexity_routing: micro → auto | small → auto | medium → auto | large → auto | xl → auto
+
+## Fallbacks
+
+- condition: gh not installed | action: report "GitHub CLI not installed" with brew install gh instructions
+- condition: no internet connection | action: report "Cannot reach GitHub. Check internet connection."
+- condition: kkudumu/ftm-brain repo not found | action: report repo not found, suggest verifying access
+- condition: no releases found | action: report "No releases found yet. Check back later."
+- condition: upgrade.sh exits non-zero | action: report failure output, suggest running script manually
+
+## Capabilities
+
+- cli: `gh` | required | GitHub CLI for release queries and download
+- cli: `bash` | required | for running check-version.sh and upgrade.sh
+
+## Event Payloads
+
+### task_completed
+- skill: string — "ftm-upgrade"
+- action: string — "check" | "upgrade" | "already_up_to_date"
+- current_version: string | null — version before upgrade
+- new_version: string | null — version after upgrade (null if no upgrade)
+- status: string — "success" | "failed" | "up_to_date" | "check_failed"

package/ftm-upgrade/scripts/check-version.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# check-version.sh — Check for ftm-skills updates via GitHub Releases
+# check-version.sh — Check for feed-the-machine updates via GitHub Releases
 # Outputs: UP_TO_DATE | UPGRADE_AVAILABLE <version> <changelog_url> | CHECK_FAILED <reason>
 
 set -uo pipefail

package/ftm-upgrade/scripts/upgrade.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# upgrade.sh — Download and install latest ftm-skills release
+# upgrade.sh — Download and install latest feed-the-machine release
 # Usage: upgrade.sh [--version <tag>]
 
 set -uo pipefail

package/hooks/ftm-blackboard-enforcer.sh

@@ -0,0 +1,94 @@
+#!/usr/bin/env bash
+# ftm-blackboard-enforcer.sh
+# Stop hook that checks if meaningful work was done but no blackboard
+# experience was recorded. If so, blocks the stop and tells Claude
+# to write the experience first.
+#
+# "Meaningful work" = 3+ tool uses detected by the edit counter,
+# or ftm skills were invoked (checked via context.json).
+#
+# Hook: Stop
+
+set -euo pipefail
+
+INPUT=$(cat)
+
+# Prevent infinite loop — if this hook already fired, let Claude stop
+STOP_HOOK_ACTIVE=$(echo "$INPUT" | jq -r '.stop_hook_active // false')
+if [[ "$STOP_HOOK_ACTIVE" == "true" ]]; then
+  exit 0
+fi
+
+STATE_DIR="$HOME/.claude/ftm-state"
+BB_DIR="$STATE_DIR/blackboard"
+EDIT_COUNTER="$STATE_DIR/.edit-count"
+CONTEXT_FILE="$BB_DIR/context.json"
+EXPERIENCES_DIR="$BB_DIR/experiences"
+EXPERIENCE_INDEX="$EXPERIENCES_DIR/index.json"
+
+CURRENT_SESSION="${CLAUDE_SESSION_ID:-unknown}"
+
+# Check 1: Were there meaningful edits this session?
+HAD_EDITS=false
+if [[ -f "$EDIT_COUNTER" ]]; then
+  STORED=$(cat "$EDIT_COUNTER" 2>/dev/null || echo "0:unknown")
+  STORED_SESSION=$(echo "$STORED" | cut -d: -f2)
+  STORED_COUNT=$(echo "$STORED" | cut -d: -f1)
+  if [[ "$STORED_SESSION" == "$CURRENT_SESSION" && "$STORED_COUNT" -ge 3 ]]; then
+    HAD_EDITS=true
+  fi
+fi
+
+# Check 2: Were ftm skills invoked this session?
+HAD_SKILLS=false
+if [[ -f "$CONTEXT_FILE" ]]; then
+  SKILLS_COUNT=$(jq -r '.session_metadata.skills_invoked | length' "$CONTEXT_FILE" 2>/dev/null || echo "0")
+  if [[ "$SKILLS_COUNT" -gt 0 ]]; then
+    HAD_SKILLS=true
+  fi
+fi
+
+# If no meaningful work detected, allow stop
+if [[ "$HAD_EDITS" == "false" && "$HAD_SKILLS" == "false" ]]; then
+  exit 0
+fi
+
+# Check 3: Was an experience recorded today?
+TODAY=$(date +%Y-%m-%d)
+HAS_EXPERIENCE=false
+
+if [[ -d "$EXPERIENCES_DIR" ]]; then
+  # Check for experience files created today
+  TODAY_EXPERIENCE=$(find "$EXPERIENCES_DIR" -name "${TODAY}*" -type f 2>/dev/null | head -1)
+  if [[ -n "$TODAY_EXPERIENCE" ]]; then
+    HAS_EXPERIENCE=true
+  fi
+fi
+
+# Also check if context.json was updated this session (recent_decisions not empty)
+if [[ -f "$CONTEXT_FILE" ]]; then
+  DECISIONS_COUNT=$(jq -r '.recent_decisions | length' "$CONTEXT_FILE" 2>/dev/null || echo "0")
+  LAST_UPDATED=$(jq -r '.session_metadata.last_updated // ""' "$CONTEXT_FILE" 2>/dev/null || echo "")
+  if [[ "$DECISIONS_COUNT" -gt 0 && -n "$LAST_UPDATED" ]]; then
+    # Check if last_updated is from today
+    if [[ "$LAST_UPDATED" == *"$TODAY"* ]]; then
+      HAS_EXPERIENCE=true
+    fi
+  fi
+fi
+
+if [[ "$HAS_EXPERIENCE" == "true" ]]; then
+  # Blackboard was written, allow stop
+  # Clean up session markers
+  rm -f "$EDIT_COUNTER" "$STATE_DIR/.plan-presented" 2>/dev/null
+  exit 0
+fi
+
+# Work was done but no blackboard write — block the stop
+cat <<'JSON'
+{
+  "decision": "block",
+  "reason": "[ftm-blackboard-enforcer] You did meaningful work this session (3+ edits or ftm skills used) but did not record an experience to the blackboard. Before stopping, you MUST: (1) Update ~/.claude/ftm-state/blackboard/context.json with current_task status and recent_decisions. (2) Write an experience file to ~/.claude/ftm-state/blackboard/experiences/ with task_type, tags, outcome, lessons, files_touched, stakeholders, and decisions_made. (3) Update ~/.claude/ftm-state/blackboard/experiences/index.json with the new entry. This is how ftm learns — skipping it means the next session starts from zero."
+}
+JSON
+exit 0

package/hooks/ftm-discovery-reminder.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+# ftm-discovery-reminder.sh
+# UserPromptSubmit hook that detects when a user's prompt mentions
+# external systems, migrations, rerouting, or stakeholder coordination.
+# Injects a reminder about the discovery interview before Claude starts working.
+#
+# This is a soft nudge, not a block — it adds additionalContext that
+# reminds Claude about the ftm-mind discovery interview protocol.
+#
+# Hook: UserPromptSubmit
+
+set -euo pipefail
+
+INPUT=$(cat)
+PROMPT=$(echo "$INPUT" | jq -r '.prompt // ""')
+
+# Lowercase the prompt for matching
+PROMPT_LOWER=$(echo "$PROMPT" | tr '[:upper:]' '[:lower:]')
+
+# Patterns that indicate external system work requiring discovery interview
+EXTERNAL_PATTERNS=(
+  "reroute"
+  "migrate"
+  "migration"
+  "move.*to.*board"
+  "move.*to.*project"
+  "point.*to.*new"
+  "update.*integration"
+  "change.*endpoint"
+  "switch.*from.*to"
+  "redirect.*to"
+  "jira.*automation"
+  "freshservice.*automation"
+  "update.*workflow"
+  "change.*routing"
+  "slack.*message.*to"
+  "email.*to"
+  "draft.*message"
+  "notify.*about"
+  "check.*with"
+  "coordinate.*with"
+  "ask.*about"
+  "tell.*about.*change"
+)
+
+# Patterns that indicate the user already provided comprehensive context
+# (e.g., pasted a Slack thread, gave detailed instructions)
+CONTEXT_SIGNALS=(
+  "here's the slack"
+  "here's the thread"
+  "here's what they said"
+  "per the conversation"
+  "just do it"
+  "no questions"
+  "skip the interview"
+  "don't ask"
+)
+
+# Check if user already provided enough context
+for signal in "${CONTEXT_SIGNALS[@]}"; do
+  if [[ "$PROMPT_LOWER" == *"$signal"* ]]; then
+    exit 0  # User explicitly provided context or asked to skip
+  fi
+done
+
+# Check for external system patterns
+MATCHED=false
+MATCHED_PATTERN=""
+for pattern in "${EXTERNAL_PATTERNS[@]}"; do
+  if echo "$PROMPT_LOWER" | grep -qE "$pattern"; then
+    MATCHED=true
+    MATCHED_PATTERN="$pattern"
+    break
+  fi
+done
+
+if [[ "$MATCHED" == "false" ]]; then
+  exit 0  # No external system work detected
+fi
+
+# Inject discovery interview reminder
+cat <<JSON
+{
+  "hookSpecificOutput": {
+    "hookEventName": "UserPromptSubmit",
+    "additionalContext": "[ftm-discovery-reminder] This request involves external systems or stakeholder coordination (matched: ${MATCHED_PATTERN}). Before generating a plan or starting work, run the Discovery Interview from ftm-mind section 10. Ask 2-4 focused questions about: (1) who else needs to know, (2) downstream dependencies, (3) anything to leave as-is, (4) timeline/approval constraints. The user's answers should feed into the plan. Skip the interview ONLY if the user already provided comprehensive context in their message or explicitly said to skip it."
+  }
+}
+JSON
+exit 0

package/hooks/ftm-drafts-gate.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+# ftm-drafts-gate.sh
+# PreToolUse hook for Slack/Gmail send tools.
+#
+# Before allowing a message to be sent via Slack or Gmail, checks that
+# a corresponding draft exists in .ftm-drafts/ (project root) or
+# ~/.claude/ftm-drafts/ (global fallback).
+#
+# If no draft exists, blocks the send and tells Claude to save the draft first.
+#
+# Hook: PreToolUse (matcher: mcp__slack__slack_post_message|mcp__slack__slack_reply_to_thread|mcp__gmail__send_email)
+
+set -euo pipefail
+
+INPUT=$(cat)
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // ""')
+
+# Only gate send tools (not reads/searches)
+case "$TOOL_NAME" in
+  *slack_post_message*|*slack_reply_to_thread*|*send_email*)
+    ;;
+  *)
+    exit 0  # Not a send tool, allow
+    ;;
+esac
+
+# Check for drafts in project .ftm-drafts/ or global ~/.claude/ftm-drafts/
+CWD=$(echo "$INPUT" | jq -r '.cwd // ""')
+PROJECT_DRAFTS="${CWD}/.ftm-drafts"
+GLOBAL_DRAFTS="$HOME/.claude/ftm-drafts"
+
+HAS_RECENT_DRAFT=false
+
+# Check both locations for any draft file modified in the last 30 minutes
+for DRAFTS_DIR in "$PROJECT_DRAFTS" "$GLOBAL_DRAFTS"; do
+  if [[ -d "$DRAFTS_DIR" ]]; then
+    # Find draft files modified in the last 30 minutes
+    RECENT=$(find "$DRAFTS_DIR" -name "*.md" -mmin -30 2>/dev/null | head -1)
+    if [[ -n "$RECENT" ]]; then
+      HAS_RECENT_DRAFT=true
+      break
+    fi
+  fi
+done
+
+if [[ "$HAS_RECENT_DRAFT" == "true" ]]; then
+  # Draft exists, allow the send (the external-action-guard will still prompt for approval)
+  exit 0
+fi
+
+# No draft found — block and tell Claude to save one first
+cat <<JSON
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "permissionDecision": "deny",
+    "permissionDecisionReason": "[ftm-drafts-gate] No draft found in .ftm-drafts/ before sending. Save the message to .ftm-drafts/ first (using the draft-before-send protocol from ftm-mind section 3.5), then retry the send. This creates an audit trail and lets the user review before sending."
+  }
+}
+JSON
+exit 0