@only1btayy/g2w 1.0.32 → 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.
 
@@ -159,10 +189,10 @@ These are escape hatches for engineers who don't need the ceremony. G2W has no c
 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 lives in CLAUDE.md so it loads as project instructions every session. The A-Game Hook and context warnings are hook-delivered, running automatically 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.32",
+  "version": "1.0.33",
   "publishConfig": {
     "access": "public"
   },