feed-the-machine 1.4.0 → 1.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/README.md +82 -180
  2. package/ftm-executor/SKILL.md +21 -8
  3. package/ftm-verify.yml +2 -0
  4. package/package.json +1 -1
package/README.md CHANGED
@@ -1,158 +1,56 @@
1
1
  # Feed The Machine
2
2
 
3
- Models get smarter every quarter. Your workflow shouldn't have to start over every time.
4
-
5
- FTM is a cognitive architecture for Claude Code — not a prompt library, not a wrapper, not scaffolding that dies on the next model drop. It's a persistent intelligence layer that learns how *you* work and gets better every time you use it. The OODA (Observe, Orient, Decide, Act) reasoning loop, the blackboard memory, the multi-model deliberation, the event mesh — these are design patterns that become *more* valuable as models improve, not less.
6
-
7
- Drop in anything. A support ticket, a feature spec, a bug report, a half-formed idea, a meeting transcript, a "figure this out." The machine reads everything, proposes a plan, waits for your approval, then executes end-to-end. Every successful execution becomes a playbook. Every playbook makes the next similar task faster.
8
-
9
- The machine hungers. You feed it. It takes care of you.
10
-
11
- ---
12
-
13
- ## Plain English
3
+ **Make Claude Code actually remember things and do entire jobs, not just answer questions.**
14
4
 
15
5
  You know how every time you start a new chat with an AI, it has no idea who you are, what you're working on, or what you tried last time? You end up repeating yourself constantly. And when you ask it to do something complex, you have to hold its hand through every single step.
16
6
 
17
7
  FTM fixes that.
18
8
 
19
- It's a brain upgrade for Claude Code (Anthropic's AI coding tool). You install it once, and from that point on:
20
-
21
- - **It remembers.** Not just within one conversation — across all of them. It builds a memory of your projects, your preferences, what worked before, and what didn't. The more you use it, the less you have to explain.
22
-
23
- - **It plans before it acts.** You throw a task at it — could be a bug, a feature request, a vague idea, whatever — and instead of immediately doing something dumb, it reads your context, makes a plan, and shows you the plan first. You approve it, tweak it, or tell it to rethink. Then it goes.
24
-
25
- - **It does the whole thing, not just one step.** Most AI tools help you write a function or answer a question. FTM coordinates entire workflows — it can read a support ticket, look up the customer's history, draft a response, update the ticket, and notify your team. All from one input.
26
-
27
- - **It gets a second opinion.** For hard decisions, it doesn't just trust one AI. It asks Claude, GPT, and Gemini independently, then picks the answer where at least two agree. Like calling three contractors instead of trusting the first quote.
28
-
29
- - **It gets better over time.** Every task it completes becomes a playbook. See the same type of bug three times? It already knows the pattern. Similar support ticket? It remembers what worked last time. It's not just a tool — it's a tool that sharpens itself.
30
-
31
- Think of it like this: regular AI is a blank whiteboard every time you walk into the room. FTM is an assistant who was in yesterday's meeting, read the doc you shared last week, and already has a draft ready when you walk in.
32
-
33
9
  ---
34
10
 
35
- ## Why This Exists
36
-
37
- Most AI tooling is disposable by design. You write prompts, the model gets better, your prompts become unnecessary. That's the scaffolding thesis — and it's true for most of what people are building.
38
-
39
- FTM is built on the opposite bet: **the orchestration layer survives model drops.** Three things in this system are structurally hard for any single model provider to absorb:
40
-
41
- **Persistent memory that compounds.** Claude's native memory is conversation-scoped. FTM's blackboard is a three-tier knowledge store — context, experiences, patterns — that persists across every session. By your twentieth task, it knows your stack, your team's conventions, the quirks of your external services, and what kinds of plans you tend to push back on. It's not remembering facts. It's building judgment.
42
-
43
- **Multi-model deliberation.** FTM's council sends hard decisions to Claude, Codex, and Gemini as equal peers, then loops through rounds of debate until 2-of-3 agree. No model provider will ever natively ship "ask our competitors for a second opinion." That's permanently outside their incentive structure.
11
+ ## What It Actually Does
44
12
 
45
- **Event-driven skill composition.** 18 typed events wire skills together automatically — a commit triggers documentation updates and architecture diagrams, a completed task triggers micro-reflection, a wave boundary triggers adversarial validation. This is workflow orchestration that sits above any single model's capability. It's closer to what Temporal does than what a model improvement would replace.
13
+ You install it once. From that point on, Claude Code gets three superpowers:
46
14
 
47
- The ideas are portable. The architecture is model-agnostic. The skills format is just the current packaging.
15
+ **It remembers across conversations.** Not just within one chat — across all of them. It builds up knowledge about your projects, your preferences, what worked before, and what didn't. The more you use it, the less you have to explain.
48
16
 
49
- ---
50
-
51
- ## The Loop
52
-
53
- Every task, every time:
54
-
55
- ```
56
- FEED --> PLAN --> APPROVE --> EXECUTE --> LEARN
57
- ^ |
58
- +------------- (next task) --------------+
59
- ```
17
+ **It plans before it acts.** Throw a task at it — a bug, a feature request, a vague idea, whatever. Instead of immediately doing something dumb, it reads your context, makes a plan, and shows you the plan first. You approve it, tweak it, or tell it to rethink. Then it goes.
60
18
 
61
- **FEED** — Paste anything. A ticket URL. A spec doc. An error stack trace. A Slack thread. Plain English. The machine reads it all.
19
+ **It does the whole thing, not just one step.** Most AI tools help you write a function or answer a question. FTM coordinates entire workflows — it can read a ticket, look up history, write the code, run the tests, update the docs, and validate everything. All from one input.
62
20
 
63
- **PLAN** — ftm-mind runs the OODA loop (Observe what you gave it, Orient using blackboard memory, Decide on an approach, Act by assembling the right skills) and proposes a concrete plan with numbered steps.
64
-
65
- **APPROVE** — You review the plan. Modify it, ask questions, or just say "go."
66
-
67
- **EXECUTE** — Parallel agent teams work through the plan. Each wave completes, validates, and checks in before the next begins. Browser automation, git ops, test runs, API calls — all coordinated.
68
-
69
- **LEARN** — Every outcome writes back to the blackboard: what worked, what failed, what pattern to remember. Next time you bring a similar task, the machine already knows the shape of it.
70
-
71
- ---
72
-
73
- ## Architecture
74
-
75
- ```mermaid
76
- graph TD
77
- User["User Input\n(ticket / spec / idea / error)"] --> Mind
78
-
79
- subgraph Core["FTM Core"]
80
- Mind["ftm-mind\n(OODA Cognitive Loop)"]
81
- BB["Blackboard\ncontext.json\nexperiences/\npatterns.json"]
82
- Mesh["Event Mesh\n18 typed events"]
83
- end
84
-
85
- Mind <-->|read / write| BB
86
- Mind -->|route| Mesh
87
-
88
- subgraph Skills["Skill Layer"]
89
- Storm["ftm-brainstorm\nSocratic ideation\n+ parallel research"]
90
- Debug["ftm-debug\nMulti-vector\ndebugging war room"]
91
- Exec["ftm-executor\nAutonomous plan\nexecution"]
92
- Council["ftm-council\nClaude + Codex + Gemini\n2-of-3 consensus"]
93
- Browse["ftm-browse\nHeadless browser\n+ accessibility inspection"]
94
- Git["ftm-git\nSecret scanning\n+ credential gate"]
95
- Audit["ftm-audit\nKnip + adversarial\nLLM wiring check"]
96
- end
97
-
98
- Mesh --> Storm
99
- Mesh --> Debug
100
- Mesh --> Exec
101
- Mesh --> Council
102
- Mesh --> Browse
103
- Mesh --> Git
104
- Mesh --> Audit
105
-
106
- subgraph Integrations["External Integrations (via MCP)"]
107
- Jira["Jira"]
108
- FS["Freshservice"]
109
- Slack["Slack"]
110
- Gmail["Gmail"]
111
- end
112
-
113
- Browse --> Jira
114
- Browse --> FS
115
- Mind --> Slack
116
- Mind --> Gmail
117
-
118
- Exec -->|code_committed| Intent["ftm-intent\nINTENT.md layer"]
119
- Exec -->|code_committed| Diagram["ftm-diagram\nARCHITECTURE.mmd"]
120
- Exec -->|task_completed| Retro["ftm-retro\nmicro-reflection"]
121
- Exec -->|wave boundary| Gate["ftm-codex-gate\nadversarial validation"]
122
- Gate --> Exec
123
- ```
21
+ Think of it like this: regular AI is a blank whiteboard every time you walk into the room. FTM is an assistant who was in yesterday's meeting, read the doc you shared last week, and already has a draft ready when you walk in.
124
22
 
125
23
  ---
126
24
 
127
- ## First 5 Minutes
128
-
129
- Install:
25
+ ## Install
130
26
 
131
27
  ```bash
132
28
  npx feed-the-machine@latest
133
29
  ```
134
30
 
135
- Symlinks all 16+ skills into `~/.claude/skills/` where Claude Code discovers them automatically. That's it.
31
+ That's it. Takes 30 seconds. Works with any existing Claude Code setup.
136
32
 
137
- **Three things to try right now:**
33
+ ---
34
+
35
+ ## Try It Right Now
138
36
 
139
- **1. Feed it a task:**
37
+ **Just talk to it:**
140
38
  ```
141
39
  /ftm
142
40
  ```
143
- Paste anything — a Jira ticket, a Freshservice request, a Slack message, or just describe what you need done. FTM reads it, pulls relevant context from your blackboard, proposes a plan, and waits for your go.
41
+ Paste anything — a ticket, an error, a feature idea, or just describe what you need. FTM figures out what to do, shows you a plan, and waits for your OK before doing anything.
144
42
 
145
- **2. Think something through:**
43
+ **Think something through:**
146
44
  ```
147
45
  /ftm-brainstorm
148
46
  ```
149
- Describe something you're trying to figure out. It runs parallel web and GitHub research agents, challenges your assumptions Socratically, and surfaces options you hadn't considered.
47
+ Describe something you're trying to figure out. It researches the web and GitHub in parallel, challenges your thinking, and surfaces options you hadn't considered.
150
48
 
151
- **3. Kill a bug:**
49
+ **Kill a bug:**
152
50
  ```
153
51
  /ftm-debug
154
52
  ```
155
- Paste an error message, stack trace, or just describe unexpected behavior. It opens a multi-vector war room — static analysis, runtime hypothesis testing, dependency auditing — running in parallel.
53
+ Paste an error or describe weird behavior. It attacks the problem from multiple angles at once — way faster than stepping through it manually.
156
54
 
157
55
  ---
158
56
 
@@ -160,106 +58,110 @@ Paste an error message, stack trace, or just describe unexpected behavior. It op
160
58
 
161
59
  ### Triaging a support ticket
162
60
 
163
- **Without FTM** — Open the ticket. Read it. Check Slack for context. Look up the customer's history. Figure out who should handle it. Draft a response. Copy-paste between four tabs. 30 minutes of context-gathering before any real work starts.
61
+ **Before** — Open the ticket. Read it. Check Slack for context. Look up the customer. Figure out who handles it. Draft a response. Copy-paste between four tabs. 30 minutes of context-gathering before any real work.
164
62
 
165
- **With FTM** — Paste the ticket URL. FTM reads the ticket, pulls the Slack thread, checks your blackboard for similar past issues, proposes a triage plan (categorize, assign, draft response, update ticket), and waits. You say "go." Done in 3 minutes.
63
+ **After** — Paste the ticket URL. FTM reads it, pulls context, checks for similar past issues, makes a plan, and waits. You say "go." Done in 3 minutes.
166
64
 
167
65
  ---
168
66
 
169
- ### Building a feature from a spec
67
+ ### Building a feature
170
68
 
171
- **Without FTM** — You open five files, context-switch between the spec and the codebase, write the route, realize the middleware pattern is different from what you remembered, check another file, write tests separately, forget to update the docs, ship it and wonder why the audit is failing.
69
+ **Before** — Open five files, switch between spec and codebase, write the code, realize the patterns are different from what you remembered, check another file, write tests separately, forget the docs, ship it and wonder why things are failing.
172
70
 
173
- **With FTM** — You paste the spec. FTM reads the existing patterns in your codebase (blackboard knows your stack), proposes a plan: route, handler, validation, tests, INTENT update, audit check. Parallel agents handle the implementation waves. ftm-codex-gate validates at each boundary. Documentation updates automatically on commit. The whole thing is coherent from the start.
71
+ **After** — Paste the spec. FTM already knows your codebase patterns, proposes a plan: code, tests, docs, validation. Parallel agents handle the work. Documentation updates automatically. Everything stays consistent.
174
72
 
175
73
  ---
176
74
 
177
- ### Configuring an admin console
75
+ ### Configuring something in an admin panel
178
76
 
179
- **Without FTM** — 45 minutes. Find the vendor docs. Navigate the admin panel manually. Cross-reference settings. Copy-paste values without fat-fingering them. Update the ticket. Hope you didn't miss a field.
77
+ **Before** — 45 minutes. Find the vendor docs. Navigate the panel manually. Cross-reference settings. Hope you didn't miss a field.
180
78
 
181
- **With FTM** — 5 minutes. Paste the ticket. FTM reads the config docs, opens a headless browser, navigates the admin panel, fills fields from the ticket spec, screenshots the result for verification, and drafts the ticket update. You review and approve each step.
79
+ **After** — 5 minutes. Paste the ticket. FTM reads the docs, opens a browser, navigates the panel, fills the fields, screenshots the result. You review and approve each step.
182
80
 
183
81
  ---
184
82
 
185
- ## Skill Inventory
186
-
187
- | Skill | What It Does |
188
- |-------|-------------|
189
- | **ftm-mind** | Observe-Orient-Decide-Act cognitive loop — the universal entry point; reads context, sizes tasks, routes everything |
190
- | **ftm-executor** | Autonomous plan execution with dynamically assembled agent teams and wave-by-wave progress |
191
- | **ftm-debug** | Multi-vector debugging war room — parallel hypothesis testing, static + runtime + dependency analysis |
192
- | **ftm-brainstorm** | Socratic ideation with parallel web and GitHub research agents; challenges assumptions, surfaces options |
193
- | **ftm-audit** | Wiring verification — knip static analysis plus adversarial LLM audit of skill connections |
194
- | **ftm-council** | Multi-model deliberation — Claude, Codex, and Gemini debate to 2-of-3 consensus on hard decisions |
195
- | **ftm-codex-gate** | Adversarial Codex validation at executor wave boundaries before proceeding |
196
- | **ftm-retro** | Post-execution retrospectives and continuous micro-reflections after every task |
197
- | **ftm-intent** | INTENT.md documentation layer — function-level contracts, auto-updated on every commit |
198
- | **ftm-diagram** | ARCHITECTURE.mmd mermaid diagrams — auto-regenerated after commits |
199
- | **ftm-browse** | Headless browser — screenshots, accessibility tree inspection, form automation, visual verification |
200
- | **ftm-git** | Secret scanning and credential safety gate for all git operations |
201
- | **ftm-pause** | Save current session state to the blackboard mid-task |
202
- | **ftm-resume** | Restore a paused session and continue exactly where you left off |
203
- | **ftm-upgrade** | Self-upgrade from GitHub releases |
204
- | **ftm-config** | Configure model profiles and execution preferences |
205
- | **ftm** | Bare invocation — equivalent to `/ftm-mind` with plain-language input |
83
+ ## How It Gets Smarter
206
84
 
207
- ---
85
+ FTM keeps a memory (called the "blackboard") that persists across every conversation:
208
86
 
209
- ## How It Learns
87
+ | Layer | What It Remembers | Example |
88
+ |-------|------------------|---------|
89
+ | **Context** | What you're working on right now, recent decisions | "Currently building auth system, chose JWT over sessions" |
90
+ | **Experiences** | What happened on past tasks — what worked, what didn't | "Last time we hit this error, the fix was in the middleware config" |
91
+ | **Patterns** | Lessons that keep coming up — gets promoted after 3+ confirmations | "This team's API always needs CORS headers added manually" |
210
92
 
211
- The blackboard is a three-tier knowledge store that persists across every session:
93
+ **Cold start is fine.** The first few conversations build up context fast. By your 10th-20th session, FTM knows your stack, your conventions, and what kinds of plans you tend to push back on.
212
94
 
213
- | Tier | What's Stored | When It's Read |
214
- |------|--------------|----------------|
215
- | `context.json` | Current task, recent decisions, your stated preferences | Every single request |
216
- | `experiences/*.json` | Per-task learnings — one file per completed task, tagged by type | Orient phase, filtered by similarity to current task |
217
- | `patterns.json` | Insights promoted after 3+ confirming experiences — durable heuristics | Orient phase, matched to the current situation |
95
+ Every task makes it smarter. Fix a bug? It remembers the root cause. Ship a feature? It remembers the patterns. See the same issue three times? It already knows what to do.
218
96
 
219
- Cold start is fine. The blackboard bootstraps aggressively in the first ten interactions and reaches useful density fast. By session twenty, FTM knows your stack, your team's conventions, the quirks of your external services, and what kinds of plans you tend to push back on.
97
+ ---
220
98
 
221
- Every skill writes back. ftm-executor writes task outcomes. ftm-debug writes what the root cause turned out to be. ftm-retro promotes patterns when it sees the same learning three times. The machine gets better with every task you feed it.
99
+ ## What's Included
100
+
101
+ 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:
102
+
103
+ | Skill | Plain English |
104
+ |-------|--------------|
105
+ | **ftm-mind** | The brain. Reads your input, pulls memory, picks the right approach, makes a plan |
106
+ | **ftm-executor** | The hands. Takes the plan and actually does the work with parallel agents |
107
+ | **ftm-debug** | Bug detective. Attacks problems from multiple angles simultaneously |
108
+ | **ftm-brainstorm** | Thinking partner. Researches, challenges assumptions, surfaces options |
109
+ | **ftm-council** | Second opinions. Asks Claude, GPT, and Gemini, then goes with the majority |
110
+ | **ftm-browse** | Web automation. Opens browsers, fills forms, takes screenshots |
111
+ | **ftm-git** | Safety net. Scans for leaked passwords/keys before you push code |
112
+ | **ftm-audit** | Quality check. Makes sure all the code is actually connected and working |
113
+ | **ftm-map** | Codebase intelligence. Knows which files matter most and what breaks if you change something |
114
+ | **ftm-intent** | Living docs. Keeps documentation updated automatically when code changes |
115
+ | **ftm-diagram** | Architecture diagrams. Auto-generated and auto-updated |
116
+ | **ftm-retro** | Self-improvement. Reviews its own work and learns from it |
117
+ | **ftm-pause / resume** | Save and restore. Pick up exactly where you left off |
118
+ | **ftm-config** | Settings. Choose which AI models to use for what |
119
+ | **ftm-upgrade** | Self-update. Stay current with one command |
222
120
 
223
121
  ---
224
122
 
225
- ## Install & Config
123
+ ## The Secret Sauce
226
124
 
227
- **Quick start:** See [docs/QUICKSTART.md](docs/QUICKSTART.md)
125
+ Three things make FTM different from "just using Claude Code":
228
126
 
229
- **Configuration reference:** See [docs/CONFIGURATION.md](docs/CONFIGURATION.md)
127
+ **1. Memory that compounds.** Claude normally forgets everything between conversations. FTM's memory persists forever and gets smarter over time. By your 20th task, it knows things about your project that would take a new developer weeks to learn.
230
128
 
231
- **Development install:**
129
+ **2. Second opinions from multiple AIs.** For hard decisions, FTM asks Claude, GPT, and Gemini independently, then goes with the answer where at least two agree. Like calling three contractors instead of trusting the first quote.
232
130
 
233
- ```bash
234
- git clone https://github.com/kkudumu/feed-the-machine.git ~/feed-the-machine
235
- cd ~/feed-the-machine
236
- ./install.sh
237
- ```
131
+ **3. Workflow orchestration.** FTM doesn't just answer questions — it coordinates multi-step workflows with parallel agents, automated testing, and validation gates. It's closer to having a junior dev on your team than having a chatbot.
238
132
 
239
- Pull updates anytime: `git pull && ./install.sh`
133
+ ---
240
134
 
241
- Remove: `./uninstall.sh` (removes symlinks only, keeps your blackboard data)
135
+ ## Advanced Setup
242
136
 
243
- **Model profiles** — edit `~/.claude/ftm-config.yml`:
137
+ **Model profiles** — Control which AI models handle what (edit `~/.claude/ftm-config.yml`):
244
138
 
245
139
  ```yaml
246
140
  profile: balanced # quality | balanced | budget
247
141
 
248
142
  profiles:
249
143
  balanced:
250
- planning: opus # brainstorm, research
251
- execution: sonnet # agent task implementation
252
- review: sonnet # audit, debug review
144
+ planning: opus # the deep thinker
145
+ execution: sonnet # the fast worker
146
+ review: sonnet # the checker
253
147
  ```
254
148
 
255
- **Optional dependencies** for the full stack:
149
+ **Optional extras** for the full experience:
150
+
151
+ - [Codex CLI](https://github.com/openai/codex) — Powers the second-opinion council and code validation
152
+ - [Gemini CLI](https://github.com/google/gemini-cli) — Third voice in the council
153
+ - Playwright MCP server (`npx @playwright/mcp@latest`) — Powers browser automation
256
154
 
257
- - [Codex CLI](https://github.com/openai/codex) — required for `ftm-council` and `ftm-codex-gate`
258
- - [Gemini CLI](https://github.com/google/gemini-cli) — required for `ftm-council`
259
- - Playwright MCP server (`npx @playwright/mcp@latest`) — required for `ftm-browse`
260
- *(MCP = Model Context Protocol — the standard way AI tools connect to external services)*
155
+ Everything else runs on Claude Code alone.
156
+
157
+ **Dev install** (if you want to contribute):
158
+
159
+ ```bash
160
+ git clone https://github.com/kkudumu/feed-the-machine.git ~/feed-the-machine
161
+ cd ~/feed-the-machine && ./install.sh
162
+ ```
261
163
 
262
- All other skills run on Claude Code alone.
164
+ **Uninstall:** `./uninstall.sh` (removes skills, keeps your memory data)
263
165
 
264
166
  ---
265
167
 
package/ftm-executor/SKILL.md CHANGED
@@ -174,22 +174,35 @@ Parallel waves:
174
174
  Final: Task [N] (integration/cleanup)
175
175
  ```
176
176
 
177
- ### Phase 1.5: Documentation Layer Bootstrap
177
+ ### Phase 1.5: Documentation Layer Bootstrap (MANDATORY)
178
178
 
179
- Before dispatching any agents, check if the project has the required documentation layer. If any of these files are missing, create them.
179
+ **This phase is non-skippable.** The documentation layer is required for ftm-verify to assess plan completion, for ftm-codex-gate to detect intent conflicts, and for agents to update docs as they work. Without it, every downstream verification step is degraded.
180
180
 
181
- **Check for and create if missing:**
182
- 1. **INTENT.md** (project root) — If missing, bootstrap from the plan's Vision and Architecture Decisions sections. Use the ftm-intent skill's root template format.
183
- 2. **ARCHITECTURE.mmd** (project root) — If missing, bootstrap by scanning the codebase for modules and their import relationships. Use the ftm-diagram skill's root template format.
184
- 3. **STYLE.md** (project root) — If missing, copy from `~/.claude/skills/ftm-executor/references/STYLE-TEMPLATE.md` into the project root.
185
- 4. **DEBUG.md** (project root) — If missing, create with a header:
181
+ Before dispatching any agents, check if the project has the required documentation layer. If any of these files are missing, create them. If they already exist, verify they're non-empty and well-formed.
182
+
183
+ **Required documentation files — create if missing:**
184
+ 1. **INTENT.md** (project root) — Bootstrap from the plan's Vision and Architecture Decisions sections. Use the ftm-intent skill's root template format. Must include: Vision, Architecture Decisions table, Module Map.
185
+ 2. **ARCHITECTURE.mmd** (project root) — Bootstrap by scanning the codebase for modules and their import relationships. Use the ftm-diagram skill's root template format. Must have at least one node and one edge.
186
+ 3. **STYLE.md** (project root) — Copy from `~/.claude/skills/ftm-executor/references/STYLE-TEMPLATE.md` into the project root.
187
+ 4. **DEBUG.md** (project root) — Create with a header:
186
188
  ```markdown
187
189
  # Debug Log
188
190
 
189
191
  Failed approaches and their outcomes. Codex and Claude append here — never retry what's already logged.
190
192
  ```
191
193
 
192
- This bootstrap runs once at the start of execution. If the files already exist, skip this phase entirely.
194
+ **Phase 1.5 Gate:** After creating any missing files, verify all 4 exist:
195
+ ```bash
196
+ for f in INTENT.md ARCHITECTURE.mmd STYLE.md DEBUG.md; do
197
+ [ -f "$f" ] || echo "MISSING: $f"
198
+ done
199
+ ```
200
+ If any file is still missing after the bootstrap attempt, STOP and report:
201
+ ```
202
+ Documentation bootstrap failed — missing: [list]
203
+ Cannot proceed without documentation layer. Fix manually or re-run.
204
+ ```
205
+ Do NOT proceed to Phase 2 with missing documentation files.
193
206
 
194
207
  ---
195
208
 
package/ftm-verify.yml ADDED
@@ -0,0 +1,2 @@
1
+ name: ftm-verify
2
+ description: Comprehensive post-execution verification and auto-remediation engine using dual-model adversarial analysis. Replaces ftm-retro. After ftm-executor completes a plan, this skill runs two independent verification passes in parallel — Codex (OpenAI) and Gemini (Google) — each reading the entire codebase to check plan fulfillment, documentation fidelity, build health, test quality, and wiring integrity. Falls back to Claude subagents if either CLI is unavailable. Reconciles findings from both models, auto-remediates with parallel fix agents, and reports what was found, disagreed on, and fixed. Use when user says "verify", "is the plan done", "check everything", "verify plan", "ftm-verify", "did we miss anything", "is it complete", "validate the build", "check the plan", "verify execution", "post-execution check", or after any ftm-executor run completes. Also triggers on "retro", "retrospective", "how did that go", "execution review" since this skill supersedes ftm-retro. Even if the user just says "are we good?" after a plan execution — this is the skill.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "feed-the-machine",
3
- "version": "1.4.0",
3
+ "version": "1.5.0",
4
4
  "description": "A unified intelligence layer for Claude Code — 22 skills with OODA-based reasoning, persistent memory, multi-model deliberation, and optional operator cockpit inbox",
5
5
  "license": "MIT",
6
6
  "author": "kkudumu",