@only1btayy/g2w 1.0.31 → 1.0.33

package/README.md

@@ -4,18 +4,6 @@
 
 </div>
 
-# G2W
-
-The best relationships are built on trust. Trust comes from honesty, and honesty breeds clarity and understanding.
-
-I got tired of going in circles with Claude and others because the systems I was using were not set up in a way that builds trust between the user and the model. Some of the top CEOs and big business people who use AI are not concerned with the question — "can it build?" Instead they are focused on — "can we trust what it builds and can we ship it?"
-
-This is not just a workflow system. Not just a task runner. This is a protocol for building trust between you and your AI so what gets built is actually what you envisioned. No more back and forth and all the other bullshit that gets in the way.
-
-**G2W is a relationship protocol.**
-
----
-
 [![npm version](https://img.shields.io/npm/v/%40only1btayy%2Fg2w?style=for-the-badge&logo=npm&logoColor=white&color=CB3837&label=npm)](https://www.npmjs.com/package/@only1btayy/g2w)
 [![license](https://img.shields.io/badge/license-MIT-6e7681?style=for-the-badge)](LICENSE)
 [![platform](https://img.shields.io/badge/platform-Claude%20Code-8957e5?style=for-the-badge)](https://claude.ai/code)
@@ -31,13 +19,27 @@ npm install -g @only1btayy/g2w && g2w
 
 ---
 
-[The Name](#the-name) · [The Problem](#the-problem) · [How It Works](#how-it-works) · [The Commands](#the-commands) · [How 2 Install](#how-2-install) · [Who It's For](#who-its-for) · [Philosophy](#the-philosophy)
+[The Name](#the-name) · [The Problem](#the-problem) · [How It Works](#how-it-works) · [Resource Limits](#resource-limits) · [The Commands](#the-commands) · [How 2 Install](#how-2-install)
+
+---
+
+# G2W
+
+The best relationships are built on trust. Trust comes from honesty, and honesty breeds clarity and understanding.
+
+I got tired of going in circles with Claude because the systems I was using weren't set up to build genuine trust between the user and the model. The top CEOs and business leaders using AI aren't asking "can it build?" They're asking "can we trust what it builds, and can we ship it?"
+
+This is not just a workflow system. Not just a task runner. This is a protocol for building trust between you and your AI so what gets built is actually what you envisioned. No more back and forth, no more bullshit getting in the way.
+
+**G2W is a relationship protocol.**
+
+If you've ever felt like your AI was working against you instead of with you, G2W is for you.
 
 ---
 
 ## The Name
 
-I named G2W after my motto in life — "It's going to work or it's going to work." This is a perspective shift I had that allows me to view even the apparent losses in life as wins because the gems are in the data. Every loss, every mistake, every doubt and fear we have is data that is filled with gems. We just have to choose to look at it that way. The people who change the world are often considered crazy and delusional until they actually change it. Then the "crazy" becomes genius and the "delusional" becomes relentless. I want you to dare to be relentless in your approach to the challenges in life and remember — it's going to work or it's going to work — ain't no other options.
+I named G2W after my motto in life: "It's going to work or it's going to work." This is a perspective shift I had that allows me to view even the apparent losses in life as wins because the gems are in the data. Every loss, every mistake, every doubt and fear we have is data that is filled with gems. We just have to choose to look at it that way. The people who change the world are often considered crazy and delusional until they actually change it. Then the "crazy" becomes genius and the "delusional" becomes relentless. I want you to dare to be relentless in your approach to the challenges in life and remember, it's going to work or it's going to work. Ain't no other options.
 
 No in-between. No failure as an option. Two paths and both lead to success.
 
@@ -45,11 +47,28 @@ No in-between. No failure as an option. Two paths and both lead to success.
 
 ## The Problem
 
-You've worked with AI before. You know how it goes.
+I want to preface this by saying I'm a vibe-coder. I have the utmost respect for actual devs and feel genuinely grateful to live in a time where tools like Claude and Codex let people like me get ideas out without needing to know how to code or have a big budget. I felt like I finally found my thing.
+
+As many of you may have noticed, Claude seemed to take a noticeable dip in performance quality around February 2026. Some people swear it's just a matter of not knowing how to use it properly, and hey, great for you, but if you experienced the dip, you know exactly what I'm talking about.
+
+He simply became unable to handle even simple tasks or edits. He'd go completely off the rails, then turn around and say "yeah you're right" over and over which drove me near insanity. I followed every recommended protocol, watched and read tutorial after tutorial, and even used the exact claude.md template that Boris Cherny shared on his X account. So you can miss me with the "oh you're just not using it right" talk. Claude worked great until he didn't. A lot of you can relate.
+
+I'd say "make this button this size" and get back "I've already decided the current size is optimal." WTF.
+
+Sound familiar?
+
+- Spending an hour in a planning session, then having to repeat everything when it's time to execute
+- Watching it make changes that break three other things it never bothered to check, then admit it after the fact
+- Seeing it commit code you never approved
+- Having it guess instead of just asking
 
-You say "make this button this size" and it does something else and explains why it was right. You spend an hour in a discussion session and then have to repeat everything again when it's time to plan. It makes a change that breaks three other things it never bothered to check. It commits code you didn't approve. It guesses instead of asking.
+I did try other systems along the way, like GSD 1 & 2 (Get Shit Done) by TACHES. It's great if you want AI to build everything out while you step away, but I wanted more control and involvement. I wanted to learn as I went, steer the ship, and understand how what I was building actually worked. GSD felt clunky and slow to me at times. No shade to what TACHES built though, it's wildly popular for a reason and he deserves every bit of the success he's seeing. It just wasn't the fit for me.
 
-G2W fixes all of that. Not by adding more rules but by building a system that genuinely earns trust.
+Deep down I knew there had to be something I could do to get Claude back on track. Even 80% of what he was when I started, I could live with that. Just not the full-blown-idiot-Claude days.
+
+After collecting data from Reddit and Facebook posts, the lightbulb went off. That was the birth of G2W.
+
+G2W was created for those of us who just want the AI to do what we ask. Simple. Nothing more, nothing less. Not by piling on more rules but by building a system that genuinely earns trust.
 
 The problem was never intelligence. The problem was process.
 
@@ -61,27 +80,47 @@ The problem was never intelligence. The problem was process.
 
 ### The Modular Doc System
 
-Every project gets a full set of living documents — `ARCHITECTURE.md`, `CONVENTIONS.md`, `ERRORS.md`, `CHANGELOG.md`, and more. The rule is simple: when you change code that any doc describes, update that doc in the same session. No separate documentation pass. No stale docs. The knowledge base stays current automatically.
+Every project gets a full set of living documents auto-generated by `/g2w:bring2life`. The rule is simple: when you change code that any doc describes, update that doc in the same session. No separate documentation pass. No stale docs. The knowledge base stays current automatically.
+
+All docs live in `~/.g2w/projects/[your-project]/`, zero footprint inside your actual repo.
+
+| Document | What It Does |
+|---|---|
+| `ARCHITECTURE.md` | System design, modules, data flow, how components connect |
+| `CONVENTIONS.md` | Code style, naming patterns, project idioms, and a Context Budget that tells the AI which files to read selectively vs. fully |
+| `FEATURES.md` | Complete list of what the project does and feature status |
+| `ERRORS.md` | Bugs, dead code, anti-patterns, and security issues found during automatic code audit |
+| `TESTING.md` | How to test, coverage gaps, and Golden Cases: critical scenarios that must never break regardless of what task is running |
+| `TRAPS.md` | Project-specific pitfalls, things that look right but break things in this codebase |
+| `SECURITY.md` | Auth, data protection, threat analysis |
+| `SCALING.md` | Performance limits, bottlenecks, growth paths |
+| `CHANGELOG.md` | Version history and significant changes |
+| `CURRENT.md` | Active session state: what's in progress, what's next, declared scope |
+| `PLAN.md` | The locked task plan, populated by The Visionary, approved by The Challenger |
+| `CLAUDE.md` | Project-specific instructions that load into every Claude session automatically |
+| `RESEARCH.md` | Background research on frameworks, libraries, and best practices (optional, generated during planning) |
+
+Every doc is a draft seeded from your actual code. Gaps are marked with `❓ [UNKNOWN]` so you know exactly what needs filling in.
 
 ---
 
 ### Talk Once. Plan Once. Build.
 
-You start a conversation. You describe your vision. G2W listens, asks smart questions, and runs research silently in the background — tech stack, existing solutions, the ecosystem. By the time you're done talking, the plan is already written and locked.
+You start a conversation. You describe your vision. G2W listens, asks smart questions, and runs research silently in the background: tech stack, existing solutions, the ecosystem. By the time you're done talking, the plan is already written and locked.
 
 No separate phases. No repeating yourself. Just a conversation that ends with something ready to build.
 
-Research isn't just a web search. G2W uses Context7 for live library docs, Exa for semantic search across similar projects, Firecrawl to crawl repos and docs sites, and Repomix to pack reference codebases so The Visionary can read how a production-quality version of what you're building actually works. Everything saves to `RESEARCH.md` and persists — future sessions don't re-run research from scratch.
+Research isn't just a web search. G2W uses Context7 for live library docs, Exa for semantic search across similar projects, Firecrawl to crawl repos and docs sites, and Repomix to pack reference codebases so The Visionary can read how a production-quality version of what you're building actually works. Everything saves to `RESEARCH.md` and persists, so future sessions don't re-run research from scratch.
 
 ---
 
 ### What Ships With G2W
 
-These install automatically — no setup, no API keys, no extra steps:
+These install automatically, no setup, no API keys, no extra steps:
 
 | Tool | What It Does |
 |---|---|
-| [Context7](https://context7.com) | Live library docs in every research and planning phase — no stale training data |
+| [Context7](https://context7.com) | Live library docs in every research and planning phase, no stale training data |
 | [Shadcn/UI MCP](https://www.shadcn.io/mcp) | Real React component implementations with TypeScript props |
 | [Tailwind CSS MCP](https://github.com/CarbonoDev/tailwindcss-mcp-server) | Utility classes, color palettes, CSS-to-Tailwind conversion |
 | [A11y MCP](https://github.com/priyankark/a11y-mcp) | Accessibility audits and WCAG compliance checks |
@@ -95,28 +134,19 @@ Claude reaches for these automatically when they're relevant. You don't have to
 Optional tools that make G2W stronger. Run `g2w power-ups` to set these up anytime.
 
 **Free (just needs a key):**
-
-| Tool | What It Adds | Get Your Key |
-|---|---|---|
-| [21st.dev](https://21st.dev) | AI-powered UI component generation — like v0 in your IDE | [21st.dev/magic/console](https://21st.dev/magic/console) |
-| [Motion](https://motion.dev) | Production-grade animations with AI Kit | [plus.motion.dev/personal-token](https://plus.motion.dev/personal-token) |
-| [Figma MCP](https://help.figma.com/hc/en-us/articles/32132100833559) | Design-to-code from Figma frames (free during beta) | [figma.com](https://figma.com) |
-| [Marketing Skills](https://github.com/coreyhaines31/marketingskills) | 40+ skills for copywriting, SEO, conversion, growth | No key needed |
+- [21st.dev](https://21st.dev), AI-powered UI component generation
+- [Motion](https://motion.dev), Production-grade animations with AI Kit
+- [Figma MCP](https://help.figma.com/hc/en-us/articles/32132100833559), Design-to-code from Figma frames (free during beta)
+- [Marketing Skills](https://github.com/coreyhaines31/marketingskills), 40+ skills for copywriting, SEO, conversion, growth (no key needed)
 
 **Research (paid):**
-
-| Tool | What It Adds |
-|---|---|
-| [Exa](https://exa.ai) | Semantic search for similar projects and best practices |
-| [Firecrawl](https://firecrawl.dev) | Deep crawling of repos and docs sites during research |
+- [Exa](https://exa.ai), Semantic search for similar projects and best practices
+- [Firecrawl](https://firecrawl.dev), Deep crawling of repos and docs sites during research
 
 **Workflow:**
-
-| Tool | What It Adds |
-|---|---|
-| [Repomix](https://github.com/yamadashy/repomix) | Packs entire codebases into one AI-optimized file — `bring2life` uses this |
-| [MemPalace](https://github.com/milla-jovovich/mempalace) | Persistent memory across sessions — decisions survive context clears |
-| [Superpowers](https://github.com/supermemoryai/superpowers-claude) | Enhanced planning and review capabilities for Claude users |
+- [Repomix](https://github.com/yamadashy/repomix), Packs entire codebases into one AI-optimized file
+- [MemPalace](https://github.com/milla-jovovich/mempalace), Persistent memory across sessions
+- [Superpowers](https://github.com/supermemoryai/superpowers-claude), Enhanced planning and review capabilities
 
 G2W uses what's available and falls back gracefully when something isn't there.
 
@@ -129,7 +159,7 @@ Once the plan locks, The Foundation takes over. Five roles. One mission. Get it
 | Agent | Role |
 |---|---|
 | The Visionary | Writes a complete plan with real decisions and no placeholders |
-| The Challenger | Adversarial review — finds every way the plan could fail before coding starts |
+| The Challenger | Adversarial review, finds every way the plan could fail before coding starts |
 | The Builder | Builds exactly what the locked plan says, nothing extra |
 | The Inspector | Verifies everything against the plan and loops until it's clean |
 | The Leader | Manages the team and keeps everything on track |
@@ -140,15 +170,15 @@ The plan is the contract. By the time The Builder touches a single line of code,
 
 ### Optional Methods
 
-Each Foundation agent is also a direct slash command. The normal flow runs through `/g2w:build2gether` and `/g2w:get2work` — but if you know what you're doing, you can jump straight into any stage of the pipeline.
+Each Foundation agent is also a direct slash command. The normal flow runs through `/g2w:build2gether` and `/g2w:get2work`, but if you know what you're doing, you can jump straight into any stage of the pipeline.
 
 | Command | When to use it directly |
 |---|---|
-| `/g2w:the-visionary` | You have a half-written plan and just want it finished — skip the full build2gether flow |
+| `/g2w:the-visionary` | You have a half-written plan and just want it finished, skip the full build2gether flow |
 | `/g2w:the-challenger` | You wrote your own plan outside G2W and want it stress-tested before building |
-| `/g2w:the-builder` | Plan is already locked — skip straight to building |
-| `/g2w:the-inspector` | Code is already written — just verify it against a plan |
-| `/g2w:the-leader` | Kick off the full pipeline — includes automatic code audit before Challenger reviews |
+| `/g2w:the-builder` | Plan is already locked, skip straight to building |
+| `/g2w:the-inspector` | Code is already written, just verify it against a plan |
+| `/g2w:the-leader` | Kick off the full pipeline, includes automatic code audit before Challenger reviews |
 
 These are escape hatches for engineers who don't need the ceremony. G2W has no ceiling.
 
@@ -156,13 +186,13 @@ These are escape hatches for engineers who don't need the ceremony. G2W has no c
 
 ### The Trust Layer
 
-Delivered via hook so it runs every single session, not just when the AI remembers.
+Delivered via CLAUDE.md so it loads into every session automatically as project instructions.
 
 - Your explicit instruction is a direct order. No agent may override it, rationalize it away, or route around it.
-- The AI answers your question first and then asks to proceed — never just acts.
+- The AI answers your question first and then asks to proceed, never just acts.
 - No edits outside the declared scope.
 - No commits without your approval.
-- "I don't know" instead of guessing — always.
+- "I don't know" instead of guessing, always.
 - Uncertainty is labeled, not hidden. `[Inference]` and `[Unverified]` are used so you always know what's confirmed and what isn't.
 - If scope creeps, it stops and flags it before touching anything.
 
@@ -181,9 +211,27 @@ Only after working through those questions does execution begin. Taking more tim
 
 ---
 
-### Git Without The Friction
+### Resource Limits
+
+AI agents don't slow down on their own. They keep running, keep calling models, and keep charging your account until you step in and control it. G2W has a built-in safety layer that tracks usage per session and stops runaway behavior before it burns through your budget.
+
+**What it tracks:**
 
-Safe git operations — add, commit, push, status, log — run without approval prompts. One command handles the whole thing. Add, commit, push. Done. No multi-step back and forth, no unnecessary interruptions. You stay in flow.
+| Metric | Default Limit | What Happens |
+|---|---|---|
+| Total tool calls per session | 200 | Hard stop, wrap up and hand off |
+| PLAN.md revisions | 5 | Hard stop, Visionary/Challenger loop is stuck, escalate to user |
+| Unique files touched | 25 | Hard stop, scope creep detected |
+| Edits to the same file | 8 | Warning, possible fix loop |
+| Tool call usage at 80% | N/A | Warning, start wrapping up |
+
+**Session logging:** Every completed session gets logged to `~/.g2w/session-log.jsonl`: project name, tool call breakdown, duration. You can see exactly which tasks are driving spend.
+
+**Configurable:** All limits live in `~/.g2w/resource-limits.json`. Edit any number. Per-project overrides go in `~/.g2w/projects/[project]/resource-limits.json`.
+
+**Kill switch:** Set `"enabled": false` in the config to bypass all limits. Delete `~/.g2w/session-limits.json` to reset counters mid-session.
+
+The resource limits hook runs first in the chain, before scope guard, before A-Game, before anything else. If the session is over limit, nothing else fires.
 
 ---
 
@@ -191,15 +239,15 @@ Safe git operations — add, commit, push, status, log — run without approval
 
 | Command | What It Does |
 |---|---|
-| `/g2w:bring2life` | Onboard an existing codebase — scans it, generates your doc files, flags gaps |
-| `/g2w:build2gether` | Start a new project — brainstorm, research, and locked plan in one conversation |
+| `/g2w:bring2life` | Onboard an existing codebase, scans it, generates your doc files, flags gaps |
+| `/g2w:build2gether` | Start a new project, brainstorm, research, and locked plan in one conversation |
 | `/g2w:back2it` | Pick up right where you left off |
 | `/g2w:get2work` | Execute the current task |
-| `/g2w:cut2it` | Fast mode — small tasks, no ceremony |
+| `/g2w:cut2it` | Fast mode, small tasks, no ceremony |
 | `/g2w:back2basics` | Strip context and start clean |
 | `/g2w:true2plan` | Verify that what was built actually matches the plan |
 | `/g2w:true2dagame` | Full system health check |
-| `/g2w:ready2save` | Wrap up the session — update CURRENT.md, capture key decisions and the reasoning behind them, hand off cleanly |
+| `/g2w:ready2save` | Wrap up the session, update CURRENT.md, capture key decisions and the reasoning behind them, hand off cleanly |
 
 ---
 
@@ -209,7 +257,7 @@ Safe git operations — add, commit, push, status, log — run without approval
 npm install -g @only1btayy/g2w && g2w
 ```
 
-That's it. G2W installs globally into `~/.claude/` automatically — skills, hooks, and design tools ready in every project, everywhere.
+That's it. G2W installs globally into `~/.claude/` automatically, skills, hooks, and design tools ready in every project, everywhere.
 
 To update:
 
@@ -235,32 +283,30 @@ Skills, hooks, and MCP servers are removed from `~/.claude/` automatically.
 
 ---
 
-## Who It's For
-
-Everyone tired of the bullshit. Vibe coders who just want to ship. Senior engineers who want control. Solo builders with no team and no co-founder.
+## Contributing
 
-If you've ever felt like your AI was working against you instead of with you, G2W is for you.
+G2W is open source and contributions are welcome.
 
-G2W works in other models — the Modular Doc System and commands are model-agnostic. But Claude Code is where it's fully alive. The Trust Layer, A-Game Hook, and context warnings are all hook-delivered, which means they run every single session without relying on the AI to remember. Other models get the workflow. Claude Code gets the guarantees.
-
----
-
-## The Philosophy
-
-Speed comes from simplicity. Control comes from clarity. If you need a system to manage your system, it's already broken. G2W is not a factory. It's a studio.
-
----
+**How to get started:**
+1. Fork the repo
+2. Clone it and run `npm install`
+3. Make your changes in a feature branch
+4. Run `node test/hooks-and-skills.test.js` to make sure nothing breaks
+5. Open a PR with a clear description of what you changed and why
 
-## Status
+**Where help is needed:**
+- Mac and Linux testing, G2W was built on Windows and needs cross-platform validation
+- New hook ideas, if you've hit a pattern where AI goes off the rails, it might be a hook
+- Bug reports, if something doesn't work, open an issue
 
-Under active development. First real-world test case is Blackhole VST running through `/g2w:bring2life`.
+No contribution is too small. If you found a typo, fix it. If you have an idea, open an issue and let's talk about it.
 
 ---
 
 ## Acknowledgements
 
-- **[johnkf5-ops/the-dev-squad](https://github.com/johnkf5-ops/the-dev-squad)** — inspired The Foundation's multi-agent pipeline
-- **John Knopf** — modular doc system approach. His words: *"Take it, run with it, use it, modify it, make it better. That's the whole point."*
+- **[johnkf5-ops/the-dev-squad](https://github.com/johnkf5-ops/the-dev-squad)**, inspired The Foundation's multi-agent pipeline
+- **John Knopf**, modular doc system approach. His words: *"Take it, run with it, use it, modify it, make it better. That's the whole point."*
 
 ---
 

package/hooks/g2w-resource-limits.js

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+// G2W Resource Limits — PreToolUse hook
+// Tracks tool calls, plan revisions, and file edits per session.
+// Warns at thresholds, hard blocks at limits. Logs session summaries.
+// Config: ~/.g2w/resource-limits.json | State: ~/.g2w/session-limits.json
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const G2W_DIR = path.join(os.homedir(), '.g2w');
+const CONFIG_FILE = path.join(G2W_DIR, 'resource-limits.json');
+const STATE_FILE = path.join(G2W_DIR, 'session-limits.json');
+const LOG_FILE = path.join(G2W_DIR, 'session-log.jsonl');
+const CURRENT_MD = path.join(G2W_DIR, 'CURRENT.md');
+
+const DEFAULTS = {
+  enabled: true,
+  maxToolCalls: 200,
+  warnAtToolCallPercent: 80,
+  maxPlanRevisions: 5,
+  maxFileEdits: 8,
+  maxUniqueFiles: 25,
+  sessionTimeoutHours: 4
+};
+
+function loadJSON(filePath, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function saveJSON(filePath, data) {
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  } catch {}
+}
+
+function appendLog(line) {
+  try {
+    fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
+    fs.appendFileSync(LOG_FILE, JSON.stringify(line) + '\n');
+  } catch {}
+}
+
+function getActiveProject() {
+  try {
+    const content = fs.readFileSync(CURRENT_MD, 'utf8');
+    const match = content.match(/^active:\s*(.+)/m);
+    return match ? match[1].trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+function loadConfig() {
+  const global = loadJSON(CONFIG_FILE, {});
+  const project = getActiveProject();
+  let projectConfig = {};
+  if (project) {
+    const projectConfigPath = path.join(G2W_DIR, 'projects', project, 'resource-limits.json');
+    projectConfig = loadJSON(projectConfigPath, {});
+  }
+  return { ...DEFAULTS, ...global, ...projectConfig };
+}
+
+function freshState(project) {
+  return {
+    startedAt: new Date().toISOString(),
+    project: project || 'unknown',
+    counters: {
+      totalToolCalls: 0,
+      writes: 0,
+      edits: 0,
+      bashCalls: 0,
+      uniqueFilesTouched: [],
+      planRevisions: 0,
+      fileEditCounts: {}
+    },
+    warnings: {
+      toolCallWarningFired: false,
+      planLoopWarningFired: false
+    }
+  };
+}
+
+function logSession(state) {
+  if (!state || state.counters.totalToolCalls === 0) return;
+  const start = new Date(state.startedAt);
+  const now = new Date();
+  const durationMinutes = Math.round((now - start) / 60000);
+  appendLog({
+    project: state.project,
+    startedAt: state.startedAt,
+    endedAt: now.toISOString(),
+    totalToolCalls: state.counters.totalToolCalls,
+    writes: state.counters.writes,
+    edits: state.counters.edits,
+    bashCalls: state.counters.bashCalls,
+    uniqueFiles: state.counters.uniqueFilesTouched.length,
+    planRevisions: state.counters.planRevisions,
+    durationMinutes
+  });
+}
+
+function isSessionExpired(state, timeoutHours) {
+  if (!state || !state.startedAt) return true;
+  const elapsed = (Date.now() - new Date(state.startedAt).getTime()) / 3600000;
+  return elapsed > timeoutHours;
+}
+
+function output(message) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      additionalContext: message
+    }
+  }));
+}
+
+let input = '';
+const stdinTimeout = setTimeout(() => process.exit(0), 3000);
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => (input += chunk));
+process.stdin.on('end', () => {
+  clearTimeout(stdinTimeout);
+  try {
+    const data = JSON.parse(input);
+    const toolName = data.tool_name;
+
+    // Only track Write, Edit, Bash
+    if (toolName !== 'Write' && toolName !== 'Edit' && toolName !== 'Bash') {
+      process.exit(0);
+    }
+
+    const config = loadConfig();
+
+    // Kill switch
+    if (!config.enabled) {
+      process.exit(0);
+    }
+
+    const project = getActiveProject();
+    let state = loadJSON(STATE_FILE, null);
+
+    // Reset if expired or missing
+    if (!state || isSessionExpired(state, config.sessionTimeoutHours)) {
+      logSession(state);
+      state = freshState(project);
+    }
+
+    const c = state.counters;
+    const filePath = data.tool_input?.file_path || '';
+    const normalizedPath = filePath ? path.normalize(filePath) : '';
+
+    // Increment counters
+    c.totalToolCalls++;
+    if (toolName === 'Write') c.writes++;
+    if (toolName === 'Edit') c.edits++;
+    if (toolName === 'Bash') c.bashCalls++;
+
+    // Track unique files and per-file edits (Write/Edit only)
+    if ((toolName === 'Write' || toolName === 'Edit') && normalizedPath) {
+      if (!c.uniqueFilesTouched.includes(normalizedPath)) {
+        c.uniqueFilesTouched.push(normalizedPath);
+      }
+      c.fileEditCounts[normalizedPath] = (c.fileEditCounts[normalizedPath] || 0) + 1;
+
+      // Track PLAN.md revisions
+      if (path.basename(filePath).toUpperCase() === 'PLAN.MD') {
+        c.planRevisions++;
+      }
+    }
+
+    // Save state before checking limits (so counters persist even on block)
+    saveJSON(STATE_FILE, state);
+
+    // --- Check limits (severity order: hard blocks first, then warnings) ---
+
+    // Hard block: total tool calls
+    if (c.totalToolCalls >= config.maxToolCalls) {
+      output(
+        `🛑 G2W RESOURCE LIMIT: Session hit ${c.totalToolCalls} tool calls (limit: ${config.maxToolCalls}). ` +
+        'Stop and wrap up. Run /g2w:ready2save to hand off cleanly. ' +
+        'To reset: delete ~/.g2w/session-limits.json'
+      );
+      process.exit(1);
+    }
+
+    // Hard block: plan revision loop
+    if (c.planRevisions >= config.maxPlanRevisions) {
+      output(
+        `🛑 G2W LOOP DETECTED: PLAN.md has been revised ${c.planRevisions} times (limit: ${config.maxPlanRevisions}). ` +
+        'The Visionary/Challenger loop is stuck. Stop iterating and escalate to the user. ' +
+        'Ask: "The plan has been revised ' + c.planRevisions + ' times. Should we lock it as-is, break the task smaller, or take a different approach?"'
+      );
+      process.exit(1);
+    }
+
+    // Hard block: too many unique files (scope creep)
+    if (c.uniqueFilesTouched.length >= config.maxUniqueFiles) {
+      output(
+        `🛑 G2W SCOPE CREEP: ${c.uniqueFilesTouched.length} unique files touched (limit: ${config.maxUniqueFiles}). ` +
+        'This session is touching too many files. Stop and re-scope with the user.'
+      );
+      process.exit(1);
+    }
+
+    // Warning: file edit loop (specific file edited too many times)
+    if (normalizedPath && c.fileEditCounts[normalizedPath] >= config.maxFileEdits && !state.warnings[`fileLoop_${normalizedPath}`]) {
+      state.warnings[`fileLoop_${normalizedPath}`] = true;
+      saveJSON(STATE_FILE, state);
+      output(
+        `⚠️ G2W FIX LOOP WARNING: "${path.basename(filePath)}" has been edited ${c.fileEditCounts[normalizedPath]} times this session. ` +
+        'Possible Inspector/Builder fix loop. Consider whether the approach needs to change.'
+      );
+      process.exit(0);
+    }
+
+    // Warning: approaching tool call limit
+    const warnThreshold = Math.floor(config.maxToolCalls * config.warnAtToolCallPercent / 100);
+    if (c.totalToolCalls >= warnThreshold && !state.warnings.toolCallWarningFired) {
+      state.warnings.toolCallWarningFired = true;
+      saveJSON(STATE_FILE, state);
+      output(
+        `⚠️ G2W RESOURCE WARNING: ${c.totalToolCalls}/${config.maxToolCalls} tool calls used (${config.warnAtToolCallPercent}%). ` +
+        'Start wrapping up. Consider running /g2w:ready2save soon.'
+      );
+      process.exit(0);
+    }
+
+    process.exit(0);
+  } catch {
+    process.exit(0); // never block on error
+  }
+});

package/lib/install.js

@@ -21,6 +21,16 @@ const HOOKS_SRC = path.join(__dirname, '../hooks');
 
 const G2W_HOOKS = {
   PreToolUse: [
+    {
+      matcher: 'Write|Edit|Bash',
+      hooks: [
+        {
+          type: 'command',
+          command: 'node "{{HOOKS_DIR}}/g2w-resource-limits.js"',
+          timeout: 5
+        }
+      ]
+    },
     {
       matcher: 'Write|Edit',
       hooks: [
@@ -115,9 +125,10 @@ function mergeMcpServers(targetBase) {
 
 // Unique identifiers for each G2W hook — used for merge and removal
 const HOOK_SIGNATURES = {
-  scopeGuard:  h => h.hooks?.some(hh => hh.command?.includes('g2w-scope-guard')),
-  aGame:       h => h.hooks?.some(hh => hh.command?.includes('g2w-agame')),
-  commitGuard: h => h.hooks?.some(hh => hh.command?.includes('g2w-commit-guard')),
+  resourceLimits: h => h.hooks?.some(hh => hh.command?.includes('g2w-resource-limits')),
+  scopeGuard:     h => h.hooks?.some(hh => hh.command?.includes('g2w-scope-guard')),
+  aGame:          h => h.hooks?.some(hh => hh.command?.includes('g2w-agame')),
+  commitGuard:    h => h.hooks?.some(hh => hh.command?.includes('g2w-commit-guard')),
 };
 
 function mergeHooks(targetBase) {
@@ -168,10 +179,12 @@ function mergeHooks(targetBase) {
 
   if (!existing.hooks.PreToolUse) existing.hooks.PreToolUse = [];
   for (const hook of resolvedHooks.PreToolUse) {
+    const isResourceLimits = HOOK_SIGNATURES.resourceLimits(hook);
     const isScopeGuard = HOOK_SIGNATURES.scopeGuard(hook);
     const isAGame = HOOK_SIGNATURES.aGame(hook);
     const isCommitGuard = HOOK_SIGNATURES.commitGuard(hook);
     const alreadyExists = existing.hooks.PreToolUse.some(h =>
+      (isResourceLimits && HOOK_SIGNATURES.resourceLimits(h)) ||
       (isScopeGuard && HOOK_SIGNATURES.scopeGuard(h)) ||
       (isAGame && HOOK_SIGNATURES.aGame(h)) ||
       (isCommitGuard && HOOK_SIGNATURES.commitGuard(h))
@@ -212,7 +225,7 @@ function removeHooks(targetBase) {
   const hooksDir = path.join(targetBase, '.claude', 'hooks');
 
   // Remove hook scripts
-  ['g2w-scope-guard.js', 'g2w-agame.js', 'g2w-commit-guard.js'].forEach(file => {
+  ['g2w-resource-limits.js', 'g2w-scope-guard.js', 'g2w-agame.js', 'g2w-commit-guard.js'].forEach(file => {
     const p = path.join(hooksDir, file);
     if (fs.existsSync(p)) fs.rmSync(p);
   });
@@ -225,6 +238,7 @@ function removeHooks(targetBase) {
     // Remove all G2W PreToolUse hooks (scope-guard, a-game, commit-guard, old Trust Layer prompt)
     if (existing.hooks.PreToolUse) {
       existing.hooks.PreToolUse = existing.hooks.PreToolUse.filter(h =>
+        !HOOK_SIGNATURES.resourceLimits(h) &&
         !HOOK_SIGNATURES.scopeGuard(h) &&
         !HOOK_SIGNATURES.aGame(h) &&
         !HOOK_SIGNATURES.commitGuard(h) &&
@@ -257,12 +271,29 @@ function getTarget() {
   return { base: os.homedir(), label: '~/.claude/' };
 }
 
+function createDefaultResourceLimits() {
+  const configPath = path.join(os.homedir(), '.g2w', 'resource-limits.json');
+  if (fs.existsSync(configPath)) return; // don't overwrite user config
+  const defaults = {
+    enabled: true,
+    maxToolCalls: 200,
+    warnAtToolCallPercent: 80,
+    maxPlanRevisions: 5,
+    maxFileEdits: 8,
+    maxUniqueFiles: 25,
+    sessionTimeoutHours: 4
+  };
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(defaults, null, 2));
+}
+
 async function run() {
   const { base, label } = getTarget();
   const { dest, count } = copySkills(base);
   copyHooks(base);
   const settingsPath = mergeHooks(base);
   const mcpAdded = mergeMcpServers(base);
+  createDefaultResourceLimits();
 
   writeTTY(`${LOGO}
 \x1b[32m✅ G2W installed at ${label}\x1b[0m

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@only1btayy/g2w",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "publishConfig": {
     "access": "public"
   },

package/skills/back2it.md

@@ -26,6 +26,8 @@ You are resuming a G2W session. Get back up to speed fast. No fluff.
 
 4. **Doc integrity check:** Does the doc you read still match the current state? If something looks stale, flag it before touching anything else.
 
+4b. **Health score check:** If the last session notes in CURRENT.md include a health score (e.g., "Health: 3.2/5") and it's below 3.5, suggest running `/g2w:true2dagame` before starting work.
+
 5. **Output a 4-line summary** (no more):
    ```
    Project: [active-project]

package/skills/bring2life.md

@@ -80,13 +80,13 @@ Do not announce what you're reading. Just read.
 
 ## Phase 2 — Generate Draft Docs
 
-Write first-draft versions of all 11 G2W docs based on what you found.
+Write first-draft versions of all 12 G2W docs based on what you found.
 
 For every field you're confident about: fill it in.
 For every field you're uncertain about: write `❓ [UNKNOWN — needs your input]`
 For every field that clearly doesn't apply: write `N/A`
 
-Generate all 11:
+Generate all 12:
 - `CLAUDE.md`
 - `ARCHITECTURE.md`
 - `CONVENTIONS.md`
@@ -98,6 +98,41 @@ Generate all 11:
 - `SECURITY.md`
 - `CURRENT.md`
 - `PLAN.md` (leave empty — written by The Visionary when a task begins)
+- `TRAPS.md`
+
+**CONVENTIONS.md must include a Context Budget section** at the end. Auto-generate this from the scan:
+
+```
+## Context Budget
+
+### Project Size
+- Total files: [count]
+- Estimated total lines: [count]
+
+### Heavy Files (read strategically, not whole)
+| File | Lines | What to read | What to skip |
+|------|-------|-------------|-------------|
+| [large file] | [count] | [relevant sections] | [boilerplate, generated, vendor code] |
+
+### Read Order by Task Type
+| Task | Read first | Read if needed | Never read whole |
+|------|-----------|----------------|-----------------|
+| Bug fix | ERRORS.md, the specific file | ARCHITECTURE.md | [large generated files] |
+| New feature | ARCHITECTURE.md, CONVENTIONS.md | FEATURES.md | [vendor/generated] |
+| Refactor | CONVENTIONS.md, the specific file | ARCHITECTURE.md | [test fixtures, assets] |
+```
+
+**TESTING.md must include a Golden Cases section.** These are scenarios that must ALWAYS pass, regardless of what the current task is. Seed initial cases from the core functionality discovered during the scan — the things that would be catastrophic if they broke.
+
+```
+## Golden Cases
+
+Scenarios that must pass before ANY task is marked complete. If a golden case breaks, the build fails — regardless of what the current task was.
+
+| # | Scenario | Steps | Expected Result | Last Verified |
+|---|----------|-------|----------------|---------------|
+| GC-01 | [core scenario] | [exact steps] | [exact expected outcome] | [date] |
+```
 
 ## Phase 2b — Code Audit
 
@@ -161,6 +196,27 @@ Generated by bring2life: [date]
 
 Be specific. File paths, line numbers, what's actually broken and why. No vague "consider improving" — either it's a real issue or don't list it.
 
+## Phase 2c — Seed TRAPS.md
+
+From the code audit, extract any anti-patterns that represent project-specific pitfalls — things that look right but break things in this codebase. Write them to `TRAPS.md`:
+
+```
+# TRAPS.md — [project-name]
+
+Project-specific pitfalls. Things that look right but break things.
+Different from CONVENTIONS.md (what TO do) — this is what NOT to do and WHY.
+
+---
+
+## TRAP-01 — [short title]
+**Pattern:** [what the bad code/approach looks like]
+**Why it breaks:** [specific failure mode — not "might cause issues"]
+**What to do instead:** [the correct approach]
+**Learned:** [date]
+```
+
+If the code audit found no anti-patterns, create TRAPS.md with the header and no entries — it will grow over time as sessions discover new pitfalls.
+
 ## Phase 3 — Gap Interview
 
 After generating drafts, ask the questions you couldn't answer from the code alone. Ask them conversationally — no more than 3 at a time. Cover:
@@ -189,7 +245,7 @@ Fill in the `❓ [UNKNOWN]` gaps based on their answers.
 
 **Determine the project name** from the folder name or package.json name field.
 
-**Write all 11 docs to `~/.g2w/projects/[project-name]/`** — NOT inside the project codebase. Zero footprint on the actual project.
+**Write all 12 docs to `~/.g2w/projects/[project-name]/`** — NOT inside the project codebase. Zero footprint on the actual project.
 
 **Update `~/.g2w/CURRENT.md`** to set this project as active:
 ```
@@ -206,7 +262,7 @@ bring2life complete.
 Project: [project-name]
 Docs written to: ~/.g2w/projects/[project-name]/
 
-Docs generated: 11
+Docs generated: 12
 Auto-filled from code: [X fields]
 Filled from your answers: [X fields]
 Still needs input: [list any remaining ❓ items]

package/skills/cut2it.md

@@ -5,6 +5,15 @@ description: Fast mode — for clearly scoped, low-risk changes. Skip planning c
 
 # /g2w:cut2it
 
+## Prerequisites
+
+- `~/.g2w/projects/[active-project]/` exists (if not → tell user to run `/g2w:bring2life` first)
+- No locked plan currently active (if a locked plan exists, use `/g2w:get2work` instead — cut2it skips planning)
+
+**Check these first. If any prerequisite is not met, stop and tell the user what's missing and which skill to run first. Do not proceed.**
+
+---
+
 No ceremony. You know what you're doing, it's small, and it's low-risk. Get it done.
 
 ## When to Use This

package/skills/get2work.md

@@ -5,6 +5,16 @@ description: Execute the locked plan — declare scope, build exactly what was p
 
 # /g2w:get2work
 
+## Prerequisites
+
+- `~/.g2w/projects/[active-project]/` exists (if not → tell user to run `/g2w:bring2life` first)
+- `PLAN.md` exists and is locked, OR `PLAN.md` is empty (triggers existing codebase flow)
+- `CONVENTIONS.md` exists (cannot build without knowing the rules)
+
+**Check these first. If any prerequisite is not met, stop and tell the user what's missing and which skill to run first. Do not proceed.**
+
+---
+
 You are executing a G2W task. Read `~/.g2w/CURRENT.md` first to confirm the active project. All docs are at `~/.g2w/projects/[active-project]/`.
 
 ## Detect: New Project or Existing Codebase?

package/skills/ready2save.md

@@ -16,6 +16,12 @@ You are closing out this session. Leave the project in a state where any future
 
    Do NOT ask the user what was done, what to save, or what decisions were made. You witnessed the entire session — extract it yourself and present it. The user confirms or corrects your summary. Never ask them to recall.
 
+1b. **Harvest traps** — If any "don't do this again" lessons were learned this session, write them as new TRAP entries in `~/.g2w/projects/[active-project]/TRAPS.md`. Use the next available TRAP number. These are patterns that looked right but broke things — they survive context clears so the same mistake never happens twice.
+
+1c. **Update golden cases** — If any golden cases in `TESTING.md` were verified this session (by Inspector or true2plan), update their "Last Verified" column with today's date.
+
+1d. **Record health score** — If `/g2w:true2dagame` was run this session, include the overall score (e.g., "Health: 4.2/5") in the session notes so `back2it` can reference it next session.
+
 2. **Identify the active project** — Read `~/.g2w/CURRENT.md` (Windows: `C:/Users/[username]/.g2w/CURRENT.md`). If it has an `active:` line, that's the project. Use it. Do NOT ask.
    - Only if the file doesn't exist or has no `active:` line: list folders in `~/.g2w/projects/` and ask which one. This is the ONLY scenario where you ask.
 

package/skills/the-builder.md

@@ -5,6 +5,16 @@ description: Use when executing a G2W locked plan. Triggered by The Leader at Ph
 
 # /g2w:the-builder
 
+## Prerequisites
+
+- `PLAN.md` exists and is locked (look for "Challenger approved" marker — if missing, Challenger hasn't signed off yet)
+- `CONVENTIONS.md` exists (cannot build without knowing the rules)
+- Scope declaration approved by user (do not build without it)
+
+**Check these first. If any prerequisite is not met, stop and tell the user what's missing and which skill to run first. Do not proceed.**
+
+---
+
 You are The Builder. You build exactly what the locked plan says. Nothing more. Nothing less.
 
 ## Prime Directive
@@ -46,7 +56,7 @@ Do not improvise. Do not make a judgment call and note it as "should be fine." S
 
 1. **Read the locked `PLAN.md`** — this is your only instruction set
 
-2. **Read `CONVENTIONS.md`** — follow existing code patterns
+2. **Read `CONVENTIONS.md`** — follow existing code patterns. Check the Context Budget section: for any file listed as "heavy," read only the sections the plan specifies. Do not read whole files unless the plan says to.
 
 3. **Confirm scope with The Leader before writing a single line**:
    ```

package/skills/the-challenger.md

@@ -5,6 +5,15 @@ description: Use when a G2W plan needs adversarial review before Builder touches
 
 # /g2w:the-challenger
 
+## Prerequisites
+
+- `PLAN.md` exists in `~/.g2w/projects/[active-project]/` and contains no TBD, TODO, or ❓ markers (Visionary must finish first)
+- `ERRORS.md` exists (code audit must have run — if missing, note it as a finding)
+
+**Check these first. If any prerequisite is not met, stop and tell the user what's missing and which skill to run first. Do not proceed.**
+
+---
+
 You are The Challenger. Your job is not to help. Your job is to break the plan before the code does.
 
 ## Prime Directive
@@ -38,6 +47,8 @@ Attack every dimension:
 
 **Edge cases in the test matrix** — Are the manual tests exhaustive, or do they only cover the happy path?
 
+**Known traps** — Read `TRAPS.md` from `~/.g2w/projects/[active-project]/`. Does the plan use any pattern that has already been identified as a project-specific pitfall? If TRAPS.md doesn't exist, note it as a finding.
+
 ## Process
 
 1. **Read `PLAN.md`** from `~/.g2w/projects/[active-project]/`

package/skills/the-inspector.md

@@ -5,6 +5,16 @@ description: Use when verifying a G2W build against the locked plan. Triggered b
 
 # /g2w:the-inspector
 
+## Prerequisites
+
+- Build is complete (Builder has handed off)
+- `PLAN.md` exists and is locked in `~/.g2w/projects/[active-project]/`
+- `TESTING.md` exists (cannot verify without test criteria)
+
+**Check these first. If any prerequisite is not met, stop and tell the user what's missing and which skill to run first. Do not proceed.**
+
+---
+
 You are The Inspector. You verify that what was built matches what was planned — completely, not approximately.
 
 ## Prime Directive
@@ -37,6 +47,8 @@ Not done means:
 
 4. **Error handling** — every error case specified in the plan must be verified. "It probably handles it" is not verification.
 
+4b. **Golden Cases** — read the Golden Cases section of `TESTING.md`. Run every golden case, regardless of whether the current task touched that area. A golden case failure is an automatic FAIL — the build broke something fundamental.
+
 5. **Conventions** — read `CONVENTIONS.md`. Does the code follow existing patterns? If not, flag it.
 
 ## Hard Stop Conditions
@@ -44,6 +56,7 @@ Not done means:
 Do not pass anything to The Leader until:
 - All plan items are verified
 - All edge cases from the test matrix pass
+- All golden cases pass (not just the ones "related" to this change)
 - The user has confirmed behavior in their actual environment
 
 If the user says "I trust it" — that's not verification. Ask them to run the specific scenarios.

package/skills/the-visionary.md

@@ -5,6 +5,16 @@ description: Use when a G2W task needs a complete, locked implementation plan wr
 
 # /g2w:the-visionary
 
+## Prerequisites
+
+- `ARCHITECTURE.md` exists in `~/.g2w/projects/[active-project]/` (cannot plan without knowing the system)
+- `CONVENTIONS.md` exists (cannot plan without knowing the rules)
+- Task defined in one sentence by user or Leader
+
+**Check these first. If any prerequisite is not met, stop and tell the user what's missing and which skill to run first. Do not proceed.**
+
+---
+
 You are The Visionary. Your only job: write a complete plan. Not a starting point. Not a skeleton. A contract.
 
 ## Prime Directive
@@ -33,7 +43,7 @@ Every decision made. Nothing left to the Builder's judgment:
 
 ## Process
 
-1. **Read the project docs first** — `ARCHITECTURE.md`, `CONVENTIONS.md`, `FEATURES.md` from `~/.g2w/projects/[active-project]/`. Know the codebase before you write a single line of the plan.
+1. **Read the project docs first** — `ARCHITECTURE.md`, `CONVENTIONS.md`, `FEATURES.md`, and `TRAPS.md` from `~/.g2w/projects/[active-project]/`. Know the codebase — and what NOT to do — before you write a single line of the plan.
 
 2. **Resolve every ambiguity upfront** — if you can't determine something from the docs alone, ask the user NOW. Do not leave it as a question in the plan.
 
@@ -44,6 +54,7 @@ Every decision made. Nothing left to the Builder's judgment:
    - Files to create (with full paths)
    - Files to modify (with full paths)
    - For each file: exact changes, exact function signatures, exact logic
+   - For heavy files (check Context Budget in CONVENTIONS.md): specify which sections the Builder should read — not "read PluginProcessor.cpp" but "read lines 800-900 of PluginProcessor.cpp (the processBlock grain loop)"
    - Test matrix: every scenario the Builder must verify manually
 
 4. **Self-audit before handing off:**

package/skills/true2dagame.md

@@ -5,6 +5,14 @@ description: Full G2W system health check — are docs in sync, is the plan lock
 
 # /g2w:true2dagame
 
+## Prerequisites
+
+- `~/.g2w/projects/[active-project]/` exists (at least `/g2w:bring2life` has been run)
+
+**Check this first. If the project docs don't exist, tell the user to run `/g2w:bring2life` first. Do not proceed.**
+
+---
+
 You are auditing the project's G2W health. No rubber-stamping. Find what's broken before it breaks you.
 
 ## Checks
@@ -58,44 +66,99 @@ Flag any doc that looks stale or inconsistent with what you can observe.
 
 ---
 
+## Scoring Rubric
+
+After running each check, score it 1-5. Use the criteria below — no vibes, no rounding up.
+
+### Docs (1-5)
+- **5** — All docs match code, updated this session or last
+- **4** — All docs match code, updated within last 3 sessions
+- **3** — 1 doc stale or missing a section
+- **2** — 2+ docs stale or contradicting the code
+- **1** — Docs are fiction — major drift from reality
+
+### Plan (1-5)
+- **5** — Locked plan exists, all files accurate, clear definition of done
+- **4** — Locked plan exists, minor file renames since lock
+- **3** — Plan exists but is a draft (not locked)
+- **2** — Plan exists but has TBD/TODO markers
+- **1** — No plan, or plan references files/functions that don't exist
+
+### Errors (1-5)
+- **5** — No unresolved critical/high bugs, golden cases all passing
+- **4** — Unresolved bugs exist but all are medium/low
+- **3** — 1 high-severity bug unresolved
+- **2** — 1 critical bug unresolved
+- **1** — Multiple critical bugs unresolved or ERRORS.md doesn't exist
+
+### Freshness (1-5)
+- **5** — CURRENT.md updated this session, all sections accurate
+- **4** — Updated last session, still accurate
+- **3** — "In Progress" is stale but "Next" is correct
+- **2** — Both "In Progress" and "Next" are wrong
+- **1** — CURRENT.md is from a different phase of the project entirely
+
+### Git (1-5)
+- **5** — Clean tree, last commit follows G2W format
+- **4** — Clean tree, last commit message is informal
+- **3** — Uncommitted changes exist but they're small
+- **2** — Large uncommitted changes or untracked files
+- **1** — Uncommitted verified work sitting for 2+ sessions
+
+---
+
+## Action Map
+
+| Score | Action |
+|-------|--------|
+| 1 in any dimension | **HARD STOP** — fix this before any other work |
+| 2 in Docs | Run through each stale doc, update from code |
+| 2 in Plan | Send plan back to Visionary for completion |
+| 2 in Errors | Triage with user — which critical bugs to fix first |
+| 2 in Freshness | Rewrite CURRENT.md from scratch based on actual state |
+| 2 in Git | Commit or stash — decide now |
+| 3 in any dimension | **WARNING** — surface to user, ask if they want to address now |
+| 4-5 in all dimensions | "System is healthy. Ready to build." |
+
+---
+
 ## Output Format
 
 ```
 G2W Health Check — [date]
 
-Docs:
-✅ ARCHITECTURE.md — in sync
-✅ FEATURES.md — in sync
-⚠️  ERRORS.md — ERR-01 marked critical, no activity in 3 sessions
-❌ CONVENTIONS.md — missing (not created yet)
+Docs:       ████████████████░░░░ 4/5
+Plan:       ████████████████████ 5/5
+Errors:     ████████████░░░░░░░░ 3/5
+Freshness:  ████████████████████ 5/5
+Git:        ████████████████░░░░ 4/5
 
-Plan:
-✅ Plan locked
-✅ Definition of done present
-⚠️  2 declared files may have been renamed since lock
-
-Errors:
-⚠️  ERR-01 — CRITICAL, unresolved
-✅ No stale "in progress" errors
+Overall: 4.2/5
+```
 
-CURRENT.md:
-✅ Looks fresh
+Then below the scores, show the detail for anything scoring 3 or below:
 
-Git:
-✅ No uncommitted verified changes
-✅ Last commit follows G2W format
+```
+⚠️  Errors: 3/5 — ERR-01 marked HIGH, unresolved, no activity in 3 sessions
+   → Action: Triage with user — fix or downgrade severity
 
-Overall: ⚠️  WARNINGS FOUND — review before building
+⚠️  Docs: ... (if applicable)
 ```
 
+If overall is 4.0+ with no dimension below 3: "System is healthy. Ready to build."
+
+---
+
 ## After the Report
 
-- If ❌ FAIL items exist → fix them before any other work proceeds
-- If ⚠️ WARNING items exist → surface them to the user, ask if they want to address now or log for later
-- If all ✅ → "System is healthy. Ready to build."
+- If any dimension scores **1** → hard stop, fix before any other work
+- If any dimension scores **2** → fix now, use the action map
+- If any dimension scores **3** → surface to user, ask if they want to address now or later
+- If all dimensions score **4-5** → "System is healthy. Ready to build."
 
 ## Rules
 
 - Don't just check if files exist — read enough to assess if they're accurate
 - A doc that exists but is 6 months stale is worse than no doc (false confidence)
-- If you can't check something (no access, build required), say so — don't guess ✅
+- If you can't check something (no access, build required), say so — don't guess a 5
+- Score honestly. A 4 that should be a 2 is worse than the bug it hides.

package/skills/true2plan.md

@@ -5,6 +5,14 @@ description: Verify that what was built matches what the plan declared — PASS/
 
 # /g2w:true2plan
 
+## Prerequisites
+
+- `PLAN.md` exists and is locked in `~/.g2w/projects/[active-project]/` (cannot verify against a plan that doesn't exist)
+
+**Check this first. If no locked plan exists, tell the user there's nothing to verify against. Do not proceed.**
+
+---
+
 You are the verifier. Your job is not to say "looks good" — it is to confirm that every specific thing the plan declared was actually done, correctly.
 
 ## Steps
@@ -26,10 +34,13 @@ You are the verifier. Your job is not to say "looks good" — it is to confirm t
 
    Run each verification step from the plan. Record actual result vs expected.
 
-5. **Regression check:**
+5. **Regression check (Golden Cases):**
 
-   - What was working before this change (pull from TESTING.md)?
-   - Is that list still intact? → PASS / FAIL
+   - Read the Golden Cases section of `TESTING.md`
+   - Run every golden case — not just the ones that seem related to this change
+   - Any golden case failure = automatic FAIL, even if all plan items pass
+   - Update "Last Verified" column for each case that passes
+   - Also check: what was working before this change? Is that list still intact? → PASS / FAIL
 
 6. **Output the report:**
    ```