feed-the-machine 1.7.0 → 1.7.1

package/README.md

@@ -52,6 +52,18 @@ Describe something you're trying to figure out. It researches the web and GitHub
 ```
 Paste an error or describe weird behavior. It attacks the problem from multiple angles at once — way faster than stepping through it manually.
 
+**Get a second opinion:**
+```
+/ftm-council
+```
+Not sure about an architecture choice or debugging approach? This sends the problem to Claude, GPT, and Gemini independently. They debate in rounds until at least two agree. Like calling three contractors instead of trusting the first quote.
+
+**Open the chatroom:**
+```
+/ftm-council-chat
+```
+An AIM-styled browser chatroom where you, Claude, Codex, and Gemini all talk in real time. You're a full participant, not just watching.
+
 ---
 
 ## Before / After
@@ -98,26 +110,74 @@ Every task makes it smarter. Fix a bug? It remembers the root cause. Ship a feat
 
 ## What's Included
 
-FTM comes with 20+ specialized skills. You don't need to memorize them — just use `/ftm` and it picks the right ones automatically. But here's what's under the hood:
+FTM ships with 26 skills and 15 automation hooks. You don't need to memorize them — just use `/ftm` and it picks the right ones automatically. But here's what's under the hood:
+
+### Core
+
+| Skill | Plain English |
+|-------|--------------|
+| **ftm-mind** | The brain. Reads your input, pulls memory, sizes complexity, picks the right approach |
+| **ftm-executor** | The hands. Takes the plan and does the work with parallel agents in isolated worktrees |
+| **ftm-ops** | Your ops dashboard. Task management, capacity tracking, stakeholder comms, meeting intel, burnout detection |
+| **ftm-config** | Settings. Choose which AI models handle planning vs execution vs review |
+
+### Thinking & Research
 
 | Skill | Plain English |
 |-------|--------------|
-| **ftm-mind** | The brain. Reads your input, pulls memory, picks the right approach, makes a plan |
-| **ftm-executor** | The hands. Takes the plan and actually does the work with parallel agents |
-| **ftm-debug** | Bug detective. Attacks problems from multiple angles simultaneously |
-| **ftm-brainstorm** | Thinking partner. Researches, challenges assumptions, surfaces options |
-| **ftm-council** | Second opinions. Asks Claude, GPT, and Gemini, then goes with the majority |
-| **ftm-browse** | Web automation. Opens browsers, fills forms, takes screenshots |
+| **ftm-brainstorm** | Thinking partner. Researches the web and GitHub in parallel, challenges assumptions, surfaces options |
+| **ftm-researcher** | Deep research engine. 7 specialized finder agents search in parallel, then adversarially review each other's findings |
+| **ftm-council** | Second opinions. Sends the problem to Claude, GPT, and Gemini — goes with the majority |
+| **ftm-council-chat** | AIM-styled chatroom. You, Claude, Codex, and Gemini all talking in a browser window |
+
+### Building & Debugging
+
+| Skill | Plain English |
+|-------|--------------|
+| **ftm-debug** | Bug war room. Attacks problems from multiple angles simultaneously |
+| **ftm-audit** | Wiring check. Makes sure all code is actually connected and working — static analysis + LLM audit |
+| **ftm-codex-gate** | Code validation gate. Sends your code to GPT for adversarial review before it ships |
+| **ftm-browse** | Web automation. Opens browsers, fills forms, takes screenshots, inspects pages |
 | **ftm-git** | Safety net. Scans for leaked passwords/keys before you push code |
-| **ftm-audit** | Quality check. Makes sure all the code is actually connected and working |
-| **ftm-map** | Codebase intelligence. Knows which files matter most and what breaks if you change something |
-| **ftm-intent** | Living docs. Keeps documentation updated automatically when code changes |
-| **ftm-diagram** | Architecture diagrams. Auto-generated and auto-updated |
-| **ftm-retro** | Self-improvement. Reviews its own work and learns from it |
-| **ftm-pause / resume** | Save and restore. Pick up exactly where you left off |
-| **ftm-config** | Settings. Choose which AI models to use for what |
+
+### Codebase Intelligence
+
+| Skill | Plain English |
+|-------|--------------|
+| **ftm-map** | Code knowledge graph. Knows what depends on what and what breaks if you change something |
+| **ftm-intent** | Living docs. Keeps function-level documentation updated automatically when code changes |
+| **ftm-diagram** | Architecture diagrams. Auto-generated mermaid diagrams that stay current |
+
+### Quality & Learning
+
+| Skill | Plain English |
+|-------|--------------|
+| **ftm-verify** | Post-execution verification. Two independent AI models audit the completed work, then auto-fix anything they find |
+| **ftm-retro** | Self-assessment. Reviews its own execution and scores it across 5 dimensions |
+| **ftm-capture** | Knowledge extraction. Turns what you just did into reusable routines and playbooks |
+| **ftm-dashboard** | Analytics. Shows which skills you use, approval rates, and session stats |
+
+### Workflow & Session
+
+| Skill | Plain English |
+|-------|--------------|
+| **ftm-routine** | Recurring workflows. Define multi-step routines in YAML and run them by name |
+| **ftm-pause / resume** | Save and restore. Pick up exactly where you left off in a new conversation |
 | **ftm-upgrade** | Self-update. Stay current with one command |
 
+### Hooks (15 automations)
+
+These run automatically in the background — no slash commands needed:
+
+- **Auto-logging** — every tool call gets logged to events.log
+- **Learning capture** — extracts lessons from completed tasks
+- **Session snapshots** — saves state for crash recovery
+- **Secret scanning** — blocks commits containing credentials
+- **Task loading** — hydrates tasks from plans on session start
+- **Plan gates** — enforces plan approval before execution
+- **Compaction handlers** — preserves critical state when context compresses
+- And 8 more for blackboard enforcement, map auto-detection, drafts gating, etc.
+
 ---
 
 ## The Secret Sauce
@@ -140,15 +200,33 @@ Three things make FTM different from "just using Claude Code":
 profile: balanced    # quality | balanced | budget
 
 profiles:
-  balanced:
+  quality:
     planning: opus      # the deep thinker
-    execution: sonnet   # the fast worker
+    execution: opus     # thorough but slower
     review: sonnet      # the checker
+
+  balanced:
+    planning: opus
+    execution: sonnet   # fast worker
+    review: sonnet
+
+  budget:
+    planning: sonnet
+    execution: sonnet
+    review: haiku       # cheapest
+```
+
+**Execution settings:**
+
+```yaml
+execution:
+  agent_mode: bypassPermissions   # how much autonomy agents get
+  max_parallel_agents: 5          # simultaneous agent workers
 ```
 
 **Optional extras** for the full experience:
 
-- [Codex CLI](https://github.com/openai/codex) — Powers the second-opinion council and code validation
+- [Codex CLI](https://github.com/openai/codex) — Powers the council, code validation, and adversarial review
 - [Gemini CLI](https://github.com/google/gemini-cli) — Third voice in the council
 - Playwright MCP server (`npx @playwright/mcp@latest`) — Powers browser automation
 
@@ -165,6 +243,20 @@ cd ~/feed-the-machine && ./install.sh
 
 ---
 
+## Current Version
+
+**v1.7.0** (April 2026) — [Full changelog](CHANGELOG.md)
+
+Recent highlights:
+- **ftm-ops**: Personal operations intelligence (task management, capacity tracking, burnout detection, stakeholder comms)
+- **ftm-mind slimmed from 87KB to 10KB** via progressive disclosure
+- **ftm-verify**: Dual-model adversarial verification (Codex + Gemini audit your completed work independently)
+- **ftm-council-chat**: AIM-styled browser chatroom for multi-AI conversations
+- **15 automation hooks** for event logging, learning capture, secret scanning, and session management
+- **Configurable agent permissions** and parallel agent limits
+
+---
+
 ## License
 
 MIT

package/ftm-audit/SKILL.md

@@ -194,6 +194,51 @@ Append a row to the root INTENT.md module map table:
 
 ---
 
+## Layer 1.75: Filesystem Path Resolution Check
+
+**Purpose:** Verify that all file paths and CLI commands referenced in SKILL.md and reference files actually resolve from the installed skill location. This catches the most dangerous class of wiring bug — code that passes every static check but fails at runtime because a path doesn't exist where the skill expects it.
+
+**When to run:** After Layer 1.5, before Layer 2. Runs on ANY project that has `.md` files with path references (not just code projects). This is especially critical after tasks that change path references, move files, or update directory structures.
+
+**Scope:** Scan all `.md` files in the changed diff for path references.
+
+**Check protocol:**
+
+1. **Find changed markdown files:** `git diff HEAD~1 --name-only -- '*.md' '*.yml'`
+2. **For each changed file, extract path references** matching these patterns:
+   - Absolute paths: `~/.claude/`, `/Users/`, `/home/`
+   - CLI commands: `python3 <path>`, `bash <path>`, `node <path>`
+   - Skill-relative paths: `bin/`, `references/`, `scripts/`
+   - Config-referenced paths: any path that appears after a `paths.` config key
+3. **Resolve each path from the installed location:**
+   - For skill files (in `~/.claude/skills/<name>/`): resolve relative to the skill's install directory
+   - For absolute paths (`~/.claude/...`): resolve directly
+   - For CLI commands: extract the path argument, resolve it, then verify execution with `--help` or `--version`
+4. **Verify existence:** `test -e <resolved-path>` for each
+5. **For CLI commands:** additionally verify `python3 <path> --help 2>&1` exits without "No such file or directory"
+
+**Finding types:**
+
+| Finding | Severity | Auto-fixable? |
+|---------|----------|---------------|
+| `BROKEN_PATH` — path in .md file doesn't resolve from installed location | HARD FAIL | No — requires human decision on correct path |
+| `BROKEN_CLI` — CLI command path doesn't exist or errors on execution | HARD FAIL | No — requires fixing the path or creating a symlink |
+| `HARDCODED_USER_PATH` — absolute path contains a specific username (e.g., `/Users/kioja.kudumu/`) | WARN | Yes — replace with `~/` or `$HOME/` equivalent |
+| `STALE_PATH_REFERENCE` — path references a directory/file that was moved or renamed in this diff | HARD FAIL | Yes — update to new path |
+
+**Output format:**
+```
+Layer 1.75 findings:
+- [BROKEN_PATH] ftm-ops/SKILL.md:53 — `~/.claude/skills/ftm/bin/brain.py` does not exist (ftm/ points to router subdirectory, not repo root)
+- [BROKEN_CLI] ftm-mind/references/orient-protocol.md:210 — `python3 ~/.claude/skills/eng-buddy/bin/brain.py` → file not found
+- [HARDCODED_USER_PATH] ftm-mind/references/ops-routing.md:44 — `/Users/kioja.kudumu/.claude/eng-buddy/drafts/` contains hardcoded username
+- [STALE_PATH_REFERENCE] ftm-ops/references/task-management.md:15 — `~/.claude/eng-buddy/active-tasks.md` was moved to `~/.claude/ftm-ops/active-tasks.md`
+```
+
+**Why this layer exists:** In the v1.7.0 merge, 160+ path references were updated across 23 files. Every static check passed. The integration test verified brain.py worked from the repo path. But when a user invoked `/ftm-ops`, it called `python3 ~/.claude/skills/ftm/bin/brain.py` — which didn't exist because the `ftm` skill symlink pointed to the `ftm/` subdirectory (the router), not the repo root. A 2-second `test -e` would have caught this. This layer ensures it always does.
+
+---
+
 ## Layer 2: LLM Adversarial Audit
 
 **Mindset:** You are an adversary trying to PROVE code is dead. Not "confirm it works" — PROVE it's dead. Every new/modified export is guilty until proven innocent. You must find a complete chain from app entry point to the code in question, or it's flagged.
@@ -508,7 +553,8 @@ When invoked (manually via `/ftm-audit` or automatically post-task):
 1. Run Phase 0 (detect project patterns — framework, router, state, API layer)
 2. Run Layer 1 (knip static analysis)
 3. Run Layer 1.5 (documentation coverage check — INTENT.md entries for changed functions)
-4. Run Layer 2 (LLM adversarial audit, calibrated to detected patterns)
+4. Run Layer 1.75 (filesystem path resolution — verify all referenced paths exist from installed location)
+5. Run Layer 2 (LLM adversarial audit, calibrated to detected patterns)
 5. Combine findings, deduplicate
 6. Run Layer 3 (auto-fix) for each finding (including missing INTENT.md entries)
 7. Re-verify (re-run Layers 1+1.5+2)
@@ -540,6 +586,10 @@ After completing, update the blackboard:
 - Findings: [N]
 - [list each finding — missing entries, stale entries, missing module docs]
 
+### Layer 1.75: Path Resolution
+- Findings: [N]
+- [list each finding — broken paths, broken CLI commands, hardcoded user paths]
+
 ### Layer 2: Adversarial Audit
 - Findings: [N]
 - [list each finding with file:line and evidence]

package/ftm-council-chat.yml

@@ -0,0 +1,2 @@
+name: ftm-council-chat
+description: AIM-styled browser chatroom where Claude, Codex, and Gemini hold real-time conversations with the user as a full participant. Use when user says "chatroom", "aim chat", "council chat", "live debate", "open the chatroom", or "council-chat".

package/ftm-executor/references/phases/PHASE-4-5-AUDIT.md

@@ -19,7 +19,16 @@ Before running ftm-audit, verify these four checks for every task:
 
    **Graceful degradation**: If ftm-browse binary is not installed, skip visual checks with a note: "Visual smoke test skipped — ftm-browse not installed." Do not fail the task.
 
-A task is NOT marked complete until checks 1–4 pass (check 5 is optional).
+6. **Path resolution check** — If the task changed any file/CLI path references in SKILL.md or reference files:
+   - Extract all paths matching patterns: `~/.claude/`, `bin/`, `python3 `, `bash `
+   - Resolve each path from the installed skill location (`~/.claude/skills/<skill-name>/`)
+   - Verify the target exists: `test -e <resolved-path>`
+   - For CLI commands (`python3 <path>`), verify execution: `python3 <path> --help` exits 0
+   - Flag any path that doesn't resolve as a BLOCKER — the skill will fail at runtime
+
+   **Why this exists**: In the v1.7.0 eng-buddy merge, all brain.py references were updated from `~/.claude/skills/eng-buddy/bin/brain.py` to `~/.claude/skills/ftm/bin/brain.py`. The path existed in the repo but `~/.claude/skills/ftm/` pointed to the `ftm/` subdirectory (the router skill), not the repo root — so the path didn't resolve at runtime. This was caught by a user, not by the audit. A 2-second `test -e` check would have caught it.
+
+A task is NOT marked complete until checks 1–4 pass (checks 5-6 are conditional).
 
 **Failure handling:**
 - Test failures → agent must fix before task completes

package/hooks/ftm-task-loader.sh

@@ -0,0 +1,100 @@
+#!/usr/bin/env bash
+# ftm-task-loader.sh
+# PostToolUse hook that fires after the Skill tool is invoked.
+# When ftm-ops or ftm is the invoked skill, loads tasks from brain.py
+# and injects TaskCreate instructions as additionalContext.
+#
+# This is deterministic — brain.py runs in the hook (fast), and the
+# model receives pre-parsed TaskCreate calls it must execute.
+#
+# Hook: PostToolUse (matcher: Skill)
+
+set -euo pipefail
+
+INPUT=$(cat)
+
+# Extract the tool name and check it's the Skill tool
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // ""')
+if [[ "$TOOL_NAME" != "Skill" ]]; then
+  exit 0
+fi
+
+# Extract which skill was invoked from the tool input
+SKILL_NAME=$(echo "$INPUT" | jq -r '.tool_input.skill // ""' 2>/dev/null)
+
+# Only fire for ftm-ops, ftm, or ftm-mind (which routes to ftm-ops for task requests)
+case "$SKILL_NAME" in
+  ftm-ops|ftm|ftm-mind|eng-buddy) ;;
+  *) exit 0 ;;
+esac
+
+# Find brain.py — check multiple locations
+BRAIN_PY=""
+for candidate in \
+  "$HOME/.claude/skills/ftm/bin/brain.py" \
+  "$HOME/.claude/skills/ftm-ops/../bin/brain.py" \
+  "$HOME/Documents/Code/feed-the-machine/bin/brain.py"; do
+  if [[ -f "$candidate" ]]; then
+    BRAIN_PY="$candidate"
+    break
+  fi
+done
+
+if [[ -z "$BRAIN_PY" ]]; then
+  # brain.py not found — skip silently
+  exit 0
+fi
+
+# Run brain.py and capture task JSON
+TASKS_JSON=$(python3 "$BRAIN_PY" --tasks --task-json 2>/dev/null) || exit 0
+
+# Count active tasks
+TASK_COUNT=$(echo "$TASKS_JSON" | python3 -c "
+import sys, json
+try:
+    tasks = json.load(sys.stdin)
+    active = [t for t in tasks if t.get('status') in ('pending', 'in_progress')]
+    print(len(active))
+except:
+    print(0)
+" 2>/dev/null)
+
+if [[ "$TASK_COUNT" == "0" ]]; then
+  exit 0
+fi
+
+# Generate TaskCreate instructions from the task data
+TASK_INSTRUCTIONS=$(echo "$TASKS_JSON" | python3 -c "
+import sys, json
+try:
+    tasks = json.load(sys.stdin)
+    active = [t for t in tasks if t.get('status') in ('pending', 'in_progress')]
+    lines = []
+    for t in active:
+        tid = t.get('id', t.get('legacy_number', '?'))
+        title = t.get('title', 'Untitled')
+        status = t.get('status', 'pending')
+        priority = t.get('priority', 'medium')
+        jira = t.get('jira_key', '')
+        desc_parts = [status, priority]
+        if jira:
+            desc_parts.append(jira)
+        desc = ' | '.join(desc_parts)
+        lines.append(f'TaskCreate(subject: \"#{tid} {title}\", description: \"{desc}\")')
+    print('\n'.join(lines))
+except:
+    pass
+" 2>/dev/null)
+
+if [[ -z "$TASK_INSTRUCTIONS" ]]; then
+  exit 0
+fi
+
+# Output as additionalContext — the model MUST process this
+cat <<EOF
+[ftm-task-loader] Loaded $TASK_COUNT active tasks from tasks.db. You MUST now call TaskCreate for each one so they appear in Claude Code's sidebar task list. Do NOT skip this — rendering a table is not enough. Call each one:
+
+$TASK_INSTRUCTIONS
+
+Call all of these TaskCreate invocations NOW, before doing anything else. This is non-negotiable.
+EOF

package/hooks/settings-template.json

@@ -55,6 +55,16 @@
           }
         ]
       },
+      {
+        "matcher": "Skill",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/ftm-task-loader.sh",
+            "timeout": 10
+          }
+        ]
+      },
       {
         "matcher": "Bash|mcp__git__git_commit",
         "hooks": [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "feed-the-machine",
-  "version": "1.7.0",
-  "description": "A unified intelligence layer for Claude Code — 22 skills with OODA-based reasoning, persistent memory, multi-model deliberation, and optional operator cockpit inbox",
+  "version": "1.7.1",
+  "description": "A brain upgrade for Claude Code — 26 skills that teach it how to think before acting, remember across conversations, debug like a war room, run plans on autopilot with agent teams, and get second opinions from GPT & Gemini. Plus 15 hooks that automate the boring stuff.",
   "license": "MIT",
   "author": "kkudumu",
   "type": "module",