gm-copilot-cli 2.0.239 → 2.0.241

package/copilot-profile.md

@@ -1,6 +1,6 @@
 ---
 name: gm
-version: 2.0.239
+version: 2.0.241
 description: State machine agent with hooks, skills, and automated git enforcement
 author: AnEntrypoint
 repository: https://github.com/AnEntrypoint/gm-copilot-cli

package/hooks/pre-tool-use-hook.js

@@ -225,15 +225,88 @@ const run = () => {
       const command = (tool_input?.command || '').trim();
       const stripFooter = (s) => s.replace(/\n\[Running tools\][\s\S]*$/, '').trimEnd();
 
-      if (/^exec:pm2list\s*$/.test(command)) {
-        const r = runGmExec(['pm2list']);
-        return allowWithNoop(`exec:pm2list output:\n\n${stripFooter((r.stdout || '') + (r.stderr || ''))}`);
-      }
-      if (/^exec:pm2logs(\s|$)/.test(command)) {
-        const args = command.replace(/^exec:pm2logs\s*/, '').trim();
-        const pmArgs = args ? ['logs', '--nostream', '--lines', '50', args] : ['logs', '--nostream', '--lines', '50'];
-        const r = spawnSync('pm2', pmArgs, { encoding: 'utf-8', timeout: 15000, windowsHide: true });
-        return allowWithNoop(`exec:pm2logs output:\n\n${stripFooter((r.stdout || '') + (r.stderr || '')) || '(no logs)'}`);
+      // ─── agent-browser: CLI commands ──────────────────────────────────────────
+      const abCliMatch = command.match(/^agent-browser:\n([\s\S]+)$/);
+      if (abCliMatch) {
+        const abCode = abCliMatch[1];
+        const abNative = (() => {
+          const abDir = path.join(TOOLS_DIR, 'node_modules', 'agent-browser', 'bin');
+          const ext = IS_WIN ? '.exe' : '';
+          const archMap = { x64: 'x64', arm64: 'arm64', ia32: 'x64' };
+          const osMap = { win32: 'win32', darwin: 'darwin', linux: 'linux' };
+          const candidate = path.join(abDir, `agent-browser-${osMap[process.platform] || process.platform}-${archMap[process.arch] || process.arch}${ext}`);
+          return fs.existsSync(candidate) ? candidate : null;
+        })();
+        const abBin = abNative || (fs.existsSync(localBin('agent-browser')) ? localBin('agent-browser') : 'agent-browser');
+        const AB_CMDS = new Set(['open','goto','navigate','close','quit','exit','back','forward','reload','click','dblclick','type','fill','press','check','uncheck','select','drag','upload','hover','focus','scroll','scrollintoview','wait','screenshot','pdf','snapshot','get','is','find','eval','connect','tab','frame','dialog','state','session','network','cookies','storage','set','trace','profiler','record','console','errors','highlight','inspect','diff','keyboard','mouse','install','upgrade','confirm','deny','auth','device','window']);
+        const AB_GLOBAL_FLAGS = new Set(['--cdp','--headed','--headless','--session','--session-name','--auto-connect','--profile','--allow-file-access','--color-scheme','-p','--platform','--device']);
+        const AB_GLOBAL_FLAGS_WITH_VALUE = new Set(['--cdp','--session','--session-name','--profile','--color-scheme','-p','--platform','--device']);
+        const AB_SESSION_STATE = path.join(os.tmpdir(), 'gm-ab-sessions.json');
+        function readAbSessions() { try { return JSON.parse(fs.readFileSync(AB_SESSION_STATE, 'utf8')); } catch { return {}; } }
+        function writeAbSessions(s) { try { fs.writeFileSync(AB_SESSION_STATE, JSON.stringify(s)); } catch {} }
+        function parseAbLine(line) {
+          const tokens = line.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
+          const globalArgs = [], rest = [];
+          let i = 0;
+          while (i < tokens.length) {
+            if (AB_GLOBAL_FLAGS.has(tokens[i])) {
+              globalArgs.push(tokens[i]);
+              if (AB_GLOBAL_FLAGS_WITH_VALUE.has(tokens[i]) && i + 1 < tokens.length && !tokens[i+1].startsWith('--')) globalArgs.push(tokens[++i]);
+              i++;
+            } else { rest.push(...tokens.slice(i)); break; }
+          }
+          return { globalArgs, rest };
+        }
+        const spawnAb = (bin, args, stdin) => {
+          const opts = { encoding: 'utf-8', timeout: 60000, windowsHide: true, ...(IS_WIN && { shell: true }), cwd: process.cwd(), ...(stdin !== undefined && { input: stdin }) };
+          const r = spawnSync(bin, args, opts);
+          if (!r.stdout && !r.stderr && r.error) return `[spawn error: ${r.error.message}]`;
+          const out = (r.stdout || '').trimEnd(), err = stripFooter(r.stderr || '').trimEnd();
+          return out && err ? out + '\n[stderr]\n' + err : stripFooter(out || err);
+        };
+        try {
+          const safeAb = abCode.trim();
+          const firstParsed = parseAbLine(safeAb.split('\n')[0].trim());
+          const firstWord = (firstParsed.rest[0] || '').toLowerCase();
+          const sessionName = (() => { const si = firstParsed.globalArgs.indexOf('--session'); return si >= 0 ? firstParsed.globalArgs[si+1] : 'default'; })();
+          const sessions = readAbSessions();
+          if (['open','goto','navigate'].includes(firstWord)) sessions[sessionName] = { url: firstParsed.rest[1] || '?', ts: Date.now() };
+          if (['close','quit','exit'].includes(firstWord)) delete sessions[sessionName];
+          writeAbSessions(sessions);
+          const openSessions = Object.entries(sessions);
+          let result;
+          if (AB_CMDS.has(firstWord)) {
+            const lines = safeAb.split('\n').map(l => l.trim()).filter(Boolean);
+            if (lines.length === 1) {
+              const { globalArgs, rest } = parseAbLine(lines[0]);
+              result = spawnAb(abBin, [...globalArgs, ...rest]);
+            } else {
+              const hasClose = lines.some(l => { const w = (parseAbLine(l).rest[0]||'').toLowerCase(); return ['close','quit','exit'].includes(w); });
+              const batchGlobals = firstParsed.globalArgs;
+              const cmds = lines.map(l => {
+                const { globalArgs, rest } = parseAbLine(l);
+                const mergedGlobals = [...batchGlobals.filter(f => !globalArgs.includes(f)), ...globalArgs];
+                const w = (rest[0]||'').toLowerCase();
+                if (['open','goto','navigate'].includes(w)) sessions[sessionName] = { url: rest[1]||'?', ts: Date.now() };
+                if (['close','quit','exit'].includes(w)) delete sessions[sessionName];
+                if (!AB_CMDS.has(w)) return [...mergedGlobals, 'eval', l.trim()];
+                return [...mergedGlobals, ...rest];
+              });
+              writeAbSessions(sessions);
+              result = spawnAb(abBin, ['batch'], JSON.stringify(cmds));
+              if (!hasClose && openSessions.length > 0) result += `\n\n[tab] Browser session "${sessionName}" still open. Close when done:\n  agent-browser:\n  close`;
+            }
+          } else {
+            result = spawnAb(abBin, ['eval', '--stdin'], safeAb);
+          }
+          if (openSessions.length > 1) {
+            const stale = openSessions.filter(([n]) => n !== sessionName).map(([n,v]) => `  "${n}" → ${v.url} (${Math.round((Date.now()-v.ts)/60000)}min ago)`).join('\n');
+            result = (result || '') + `\n\n[tab] ${openSessions.length - 1} other session(s) still open:\n${stale}\n  Close with: agent-browser:\\nclose  (or --session <name> close)`;
+          }
+          return allowWithNoop(`agent-browser output:\n\n${result || '(no output)'}`);
+        } catch(e) {
+          return allowWithNoop(`agent-browser error:\n\n${e.message || '(exec failed)'}`);
+        }
       }
 
       const execMatch = command.match(/^exec(?::(\S+))?\n([\s\S]+)$/);
@@ -241,13 +314,13 @@ const run = () => {
         const rawLang = (execMatch[1] || '').toLowerCase();
         const code = execMatch[2];
         if (/^\s*agent-browser\s/.test(code)) {
-          return deny(`Do not call agent-browser via exec:bash. Use exec:agent-browser instead:\n\nexec:agent-browser\nopen http://example.com\n\nMultiple commands in one block:\n\nexec:agent-browser\nopen http://localhost:3001\nwait 2000\nsnapshot -i\n\nFor JS eval (DOM inspection, custom logic):\n\nexec:agent-browser\ndocument.title\n\nCLI commands (open, click, screenshot, snapshot, wait, console, tab, etc.) run directly.\nAnything that is not a CLI command goes through eval --stdin.\nClose tabs when done: exec:agent-browser\\nclose`);
+          return deny(`Do not call agent-browser via exec:bash. Use agent-browser: for CLI commands:\n\nagent-browser:\nopen http://example.com\n\nMultiple commands:\n\nagent-browser:\nopen http://localhost:3001\nwait 2000\nsnapshot -i\n\nFor headed mode:\n\nagent-browser:\n--headed open http://localhost:3001\nwait --load networkidle\nsnapshot -i\n\nFor JS eval in browser:\n\nexec:agent-browser\ndocument.title`);
         }
         const cwd = tool_input?.cwd;
 
         // ─── Lang plugin dispatch ─────────────────────────────────────────────
         if (rawLang) {
-          const builtins = new Set(['js','javascript','ts','typescript','node','nodejs','py','python','sh','bash','shell','zsh','powershell','ps1','go','rust','c','cpp','java','deno','cmd','browser','ab','agent-browser','codesearch','search','status','sleep','close','runner','type','pm2list']);
+          const builtins = new Set(['js','javascript','ts','typescript','node','nodejs','py','python','sh','bash','shell','zsh','powershell','ps1','go','rust','c','cpp','java','deno','cmd','browser','ab','agent-browser','codesearch','search','status','sleep','close','runner','type']);
           if (!builtins.has(rawLang)) {
             const plugins = loadLangPlugins(projectDir);
             const plugin = plugins.find(p => p.exec.match.test(`exec:${rawLang}\n${code}`));
@@ -274,7 +347,7 @@ const run = () => {
           return 'nodejs';
         };
         // Note: 'cmd' is NOT aliased to 'bash' — it has its own handler below
-        const aliases = { js: 'nodejs', javascript: 'nodejs', ts: 'typescript', node: 'nodejs', py: 'python', sh: 'bash', shell: 'bash', zsh: 'bash', powershell: 'powershell', ps1: 'powershell', browser: 'agent-browser', ab: 'agent-browser', codesearch: 'codesearch', search: 'search', status: 'status', sleep: 'sleep', close: 'close', runner: 'runner', type: 'type', pm2list: 'pm2list' };
+        const aliases = { js: 'nodejs', javascript: 'nodejs', ts: 'typescript', node: 'nodejs', py: 'python', sh: 'bash', shell: 'bash', zsh: 'bash', powershell: 'powershell', ps1: 'powershell', browser: 'agent-browser', ab: 'agent-browser', codesearch: 'codesearch', search: 'search', status: 'status', sleep: 'sleep', close: 'close', runner: 'runner', type: 'type' };
         const lang = aliases[rawLang] || rawLang || detectLang(code);
         const langExts = { nodejs: 'mjs', typescript: 'ts', deno: 'ts', python: 'py', bash: 'sh', powershell: 'ps1', go: 'go', rust: 'rs', c: 'c', cpp: 'cpp', java: 'java' };
 
@@ -343,11 +416,6 @@ const run = () => {
           const r = runGmExec(['type', taskId, inputData], { timeout: 15000 });
           return allowWithNoop(`exec:type output:\n\n${stripFooter((r.stdout || '') + (r.stderr || ''))}`);
         }
-        if (lang === 'pm2list') {
-          const r = runGmExec(['pm2list'], { timeout: 15000 });
-          return allowWithNoop(`exec:pm2list output:\n\n${stripFooter((r.stdout || '') + (r.stderr || ''))}`);
-        }
-
         try {
           let result;
           if (lang === 'bash') {
@@ -368,8 +436,8 @@ const run = () => {
             const wrapped = `const __result = await (async () => {\n${safeCode}\n})();\nif (__result !== undefined) { if (typeof __result === 'object') { console.log(JSON.stringify(__result, null, 2)); } else { console.log(__result); } }`;
             result = runWithFile(lang || 'nodejs', wrapped);
           } else if (lang === 'agent-browser') {
-            // agent-browser reads agent-browser.json from cwd automatically (headed, profile, session, etc.)
-            // Just run with shell:true so .cmd wrappers resolve, and use process.cwd() so config is picked up
+            // exec:agent-browser = JS eval in browser page context only.
+            // Browser CLI commands (open, click, snapshot, headed mode, etc.) use agent-browser: prefix.
             const abNative = (() => {
               const abDir = path.join(TOOLS_DIR, 'node_modules', 'agent-browser', 'bin');
               const ext = IS_WIN ? '.exe' : '';
@@ -379,63 +447,7 @@ const run = () => {
               return fs.existsSync(candidate) ? candidate : null;
             })();
             const abBin = abNative || (fs.existsSync(localBin('agent-browser')) ? localBin('agent-browser') : 'agent-browser');
-            const AB_CMDS = new Set(['open','goto','navigate','close','quit','exit','back','forward','reload','click','dblclick','type','fill','press','check','uncheck','select','drag','upload','hover','focus','scroll','scrollintoview','wait','screenshot','pdf','snapshot','get','is','find','eval','connect','tab','frame','dialog','state','session','network','cookies','storage','set','trace','profiler','record','console','errors','highlight','inspect','diff','keyboard','mouse','install','upgrade','confirm','deny','auth','device','window']);
-            const AB_GLOBAL_FLAGS = new Set(['--cdp','--headed','--headless','--session','--session-name','--auto-connect','--profile','--allow-file-access','--color-scheme','-p','--platform','--device']);
-            const AB_GLOBAL_FLAGS_WITH_VALUE = new Set(['--cdp','--session','--session-name','--profile','--color-scheme','-p','--platform','--device']);
-            const AB_SESSION_STATE = path.join(os.tmpdir(), 'gm-ab-sessions.json');
-            function readAbSessions() { try { return JSON.parse(fs.readFileSync(AB_SESSION_STATE, 'utf8')); } catch { return {}; } }
-            function writeAbSessions(s) { try { fs.writeFileSync(AB_SESSION_STATE, JSON.stringify(s)); } catch {} }
-            function parseAbLine(line) {
-              const tokens = line.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
-              const globalArgs = [], rest = [];
-              let i = 0;
-              while (i < tokens.length) {
-                if (AB_GLOBAL_FLAGS.has(tokens[i])) {
-                  globalArgs.push(tokens[i]);
-                  if (AB_GLOBAL_FLAGS_WITH_VALUE.has(tokens[i]) && i + 1 < tokens.length && !tokens[i+1].startsWith('--')) {
-                    globalArgs.push(tokens[++i]);
-                  }
-                  i++;
-                } else { rest.push(...tokens.slice(i)); break; }
-              }
-              return { globalArgs, rest };
-            }
-            const firstLineParsed = parseAbLine(safeCode.trim().split('\n')[0].trim());
-            const firstWord = (firstLineParsed.rest[0] || '').toLowerCase();
-            const sessionName = (() => { const si = firstLineParsed.globalArgs.indexOf('--session'); return si >= 0 ? firstLineParsed.globalArgs[si+1] : 'default'; })();
-            const isOpen = ['open','goto','navigate'].includes(firstWord);
-            const isClose = ['close','quit','exit'].includes(firstWord);
-            const sessions = readAbSessions();
-            if (isOpen) sessions[sessionName] = { url: (firstLineParsed.rest[1] || '?'), ts: Date.now() };
-            if (isClose) delete sessions[sessionName];
-            writeAbSessions(sessions);
-            const openSessions = Object.entries(sessions);
-            if (AB_CMDS.has(firstWord)) {
-              const lines = safeCode.split('\n').map(l => l.trim()).filter(Boolean);
-              if (lines.length === 1) {
-                const { globalArgs, rest } = parseAbLine(lines[0]);
-                result = spawnDirect(abBin, [...globalArgs, ...rest]);
-              } else {
-                const hasClose = lines.some(l => { const w = (parseAbLine(l).rest[0]||'').toLowerCase(); return ['close','quit','exit'].includes(w); });
-                const cmds = lines.map(l => {
-                  const { globalArgs, rest } = parseAbLine(l);
-                  const w = (rest[0]||'').toLowerCase();
-                  if (['open','goto','navigate'].includes(w)) sessions[sessionName] = { url: rest[1]||'?', ts: Date.now() };
-                  if (['close','quit','exit'].includes(w)) delete sessions[sessionName];
-                  if (!AB_CMDS.has(w)) return [...globalArgs, 'eval', l.trim()];
-                  return [...globalArgs, ...rest];
-                });
-                writeAbSessions(sessions);
-                result = spawnDirect(abBin, ['batch'], JSON.stringify(cmds));
-                if (!hasClose && openSessions.length > 0) result += `\n\n[tab] Browser session "${sessionName}" still open. Close when done:\n  exec:agent-browser\n  close`;
-              }
-            } else {
-              result = spawnDirect(abBin, ['eval', '--stdin'], safeCode);
-            }
-            if (openSessions.length > 1) {
-              const stale = openSessions.filter(([n]) => n !== sessionName).map(([n,v]) => `  "${n}" → ${v.url} (${Math.round((Date.now()-v.ts)/60000)}min ago)`).join('\n');
-              result = (result || '') + `\n\n[tab] ${openSessions.length - 1} other session(s) still open:\n${stale}\n  Close with: exec:agent-browser\\nclose  (or --session <name> close)`;
-            }
+            result = spawnDirect(abBin, ['eval', '--stdin'], safeCode);
           } else {
             result = runWithFile(lang, safeCode);
           }
@@ -449,8 +461,8 @@ const run = () => {
         return deny(`Do not call ${command.match(/^bun\s+x\s+(\S+)/)[1]} directly. Use exec:<lang> syntax instead.\n\nExamples:\n  exec:nodejs\n  console.log("hello")\n\n  exec:codesearch\n  find all database queries\n\n  exec:bash\n  ls -la\n\nThe exec: prefix routes through the hook dispatcher which handles language detection, background tasks, and tool management automatically.`);
       }
 
-      if (!/^exec(\s|:)/.test(command) && !/^git /.test(command) && !/(\bclaude\b)/.test(command) && !/^npm install .* \/config\/.gmweb/.test(command) && !/^bun install --cwd \/config\/.gmweb/.test(command)) {
-        return deny(`Bash is restricted to exec:<lang> and git.\n\nexec:<lang> syntax (lang auto-detected if omitted):\n  exec:nodejs / exec:python / exec:bash / exec:typescript\n  exec:go / exec:rust / exec:java / exec:c / exec:cpp\n  exec:cmd            ← runs cmd.exe /c on Windows\n  exec:agent-browser  ← browser CLI (open, click, snapshot, wait, tab, console...)\n                        OR JS eval when body is not a CLI command\n  exec               ← auto-detects language\n\nexec:agent-browser examples:\n  open http://localhost:3001     ← navigate\n  snapshot -i                    ← get element refs\n  wait 2000                      ← wait ms\n  console                        ← read browser console\n  close                          ← ALWAYS close when done\n  document.title                 ← JS eval (not a CLI command)\n\nMultiple CLI commands in one block run as batch:\n  exec:agent-browser\n  open http://localhost:3001\n  wait 2000\n  snapshot -i\n\nTask management shortcuts (body = args):\n  exec:status\n  <task_id>\n\n  exec:sleep\n  <task_id> [seconds] [--next-output]\n\n  exec:type\n  <task_id>\n  <input to send to stdin>\n\n  exec:close\n  <task_id>\n\n  exec:runner\n  start|stop|status\n\nCode search shortcut:\n  exec:codesearch\n  <natural language query>\n\nAll other Bash commands are blocked.`);
+      if (!/^exec(\s|:)/.test(command) && !/^agent-browser:/.test(command) && !/^git /.test(command) && !/(\bclaude\b)/.test(command) && !/^npm install .* \/config\/.gmweb/.test(command) && !/^bun install --cwd \/config\/.gmweb/.test(command)) {
+        return deny(`Bash is restricted to exec:<lang>, agent-browser:, and git.\n\nexec:<lang> syntax (lang auto-detected if omitted):\n  exec:nodejs / exec:python / exec:bash / exec:typescript\n  exec:go / exec:rust / exec:java / exec:c / exec:cpp\n  exec:cmd            ← runs cmd.exe /c on Windows\n  exec:agent-browser  ← JS eval in browser page context (document.title, DOM queries, etc.)\n  exec               ← auto-detects language\n\nexec:agent-browser — JS eval in browser page context:\n  exec:agent-browser\n  document.title\n\n  exec:agent-browser\n  JSON.stringify([...document.querySelectorAll('h1')].map(h => h.textContent))\n\nagent-browser: — browser CLI commands (open, click, snapshot, headed mode, etc.):\n  agent-browser:\n  open http://localhost:3001\n\n  agent-browser:\n  --headed open http://localhost:3001\n  wait --load networkidle\n  snapshot -i\n\n  agent-browser:\n  close\n\nTask management shortcuts (body = args):\n  exec:status\n  <task_id>\n\n  exec:sleep\n  <task_id> [seconds] [--next-output]\n\n  exec:type\n  <task_id>\n  <input to send to stdin>\n\n  exec:close\n  <task_id>\n\n  exec:runner\n  start|stop|status\n\nCode search shortcut:\n  exec:codesearch\n  <natural language query>\n\nAll other Bash commands are blocked.`);
       }
     }
 

package/index.html

@@ -18,7 +18,7 @@
 <script type="module">
 import { createElement as h, applyDiff, Fragment } from "webjsx";
 const PLATFORM_NAME="Copilot CLI",PLATFORM_TYPE="CLI Tool",PLATFORM_TYPE_COLOR="#3b82f6";
-const DESCRIPTION="State machine agent with hooks, skills, and automated git enforcement",VERSION="2.0.239";
+const DESCRIPTION="State machine agent with hooks, skills, and automated git enforcement",VERSION="2.0.241";
 const GITHUB_URL="https://github.com/AnEntrypoint/gm-copilot-cli",BADGE_LABEL="copilot-cli";
 const FEATURES=[{"title":"State Machine","desc":"Immutable PLAN→EXECUTE→EMIT→VERIFY→COMPLETE phases with full mutable tracking"},{"title":"Semantic Search","desc":"Natural language codebase exploration via codesearch skill — no grep needed"},{"title":"Hooks","desc":"Pre-tool, session-start, prompt-submit, and stop hooks for full lifecycle control"},{"title":"Agents","desc":"gm, codesearch, and websearch agents pre-configured and ready to use"},{"title":"MCP Integration","desc":"Model Context Protocol server support built in"},{"title":"Auto-Recovery","desc":"Supervisor hierarchy ensures the system never crashes"}],INSTALL_STEPS=[{"desc":"Install via GitHub CLI","cmd":"gh extension install AnEntrypoint/gm-copilot-cli"},{"desc":"Restart your terminal — activates automatically"}];
 const CURRENT_PLATFORM="gm-copilot-cli";

package/manifest.yml

@@ -1,5 +1,5 @@
 name: gm
-version: 2.0.239
+version: 2.0.241
 description: State machine agent with hooks, skills, and automated git enforcement
 author: AnEntrypoint
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-copilot-cli",
-  "version": "2.0.239",
+  "version": "2.0.241",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",

package/skills/agent-browser/SKILL.md

@@ -1,32 +1,47 @@
 ---
 name: agent-browser
 description: Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction.
-allowed-tools: agent-browser, Bash(exec:agent-browser*)
+allowed-tools: agent-browser, Bash(agent-browser:*), Bash(exec:agent-browser*)
 ---
 
 # Browser Automation with agent-browser
 
 ## Two Pathways
 
-**Page control** — use the `agent-browser` tool directly for all browser interaction: navigating, clicking, filling forms, taking screenshots, reading snapshots. This is the primary pathway for driving the browser.
+**Browser CLI commands** — use `agent-browser:` prefix via Bash for all browser control: navigating, clicking, filling forms, taking screenshots, reading snapshots.
 
-**Code execution** — use `exec:agent-browser` via Bash when you need to run JavaScript in the page context. The body is piped to `eval --stdin`. Use this for DOM inspection, custom extraction logic, or anything requiring programmatic page access.
+```
+agent-browser:
+open http://localhost:3001
+wait 2000
+snapshot -i
+```
+
+Single commands:
+
+```
+agent-browser:
+open http://example.com
+```
+
+```
+agent-browser:
+close
+```
+
+**JS eval in browser** — use `exec:agent-browser` via Bash when you need to run JavaScript in the page context. The body is piped to `eval --stdin`. Use this for DOM inspection, custom extraction logic, or anything requiring programmatic page access.
 
 ```
 exec:agent-browser
 document.title
 ```
 
-Multi-line `exec:agent-browser` blocks where lines are recognized CLI commands run as a batch instead of eval — useful for sequencing page control steps when the `agent-browser` tool isn't available:
-
 ```
 exec:agent-browser
-open http://localhost:3001
-wait 2000
-snapshot -i
+JSON.stringify([...document.querySelectorAll('h1')].map(h => h.textContent))
 ```
 
-**Always close tabs when done**: every `open` is tracked. Use `exec:agent-browser\nclose` (or `--session <name> close`) when finished. Leaving sessions open accumulates stale tabs — the hook will warn you when other sessions are still open.
+**Always close tabs when done**: every `open` is tracked. Use `agent-browser:\nclose` (or `--session <name> close`) when finished. Leaving sessions open accumulates stale tabs — the hook will warn you when other sessions are still open.
 
 ## Core Workflow
 
@@ -155,12 +170,22 @@ agent-browser --auto-connect snapshot
 agent-browser --cdp 9222 snapshot
 ```
 
-### Visual Browser (Debugging)
+### Visual Browser (Headed Mode)
 
-```bash
-agent-browser --headed open https://example.com
-agent-browser highlight @e1          # Highlight element
-agent-browser record start demo.webm # Record session
+Use `--headed` as the first flag on the first line — it propagates to all commands in the block:
+
+```
+agent-browser:
+--headed open https://example.com
+wait --load networkidle
+snapshot -i
+```
+
+```
+agent-browser:
+--headed open https://example.com
+highlight @e1
+record start demo.webm
 ```
 
 ### Local Files (PDFs, HTML)
@@ -451,10 +476,14 @@ agent-browser profiler stop [path]   # Stop and save .json profile
 ```
 
 ### Visual Debugging
-```bash
-agent-browser --headed open <url>     # Headless=false, show visual browser
-agent-browser record start <file.webm> # Record session
-agent-browser record stop             # Stop recording
+```
+agent-browser:
+--headed open <url>
+record start <file.webm>
+```
+```
+agent-browser:
+record stop
 ```
 
 ### Comparisons & Diffs
@@ -543,6 +572,6 @@ exec:agent-browser
 document.title
 ```
 
-**Debugging complex interactions**: Use `agent-browser --headed open <url>` to see visual browser, then `agent-browser highlight @e1` to verify element targeting.
+**Debugging complex interactions**: Use headed mode — put `--headed` as the first flag on the first line of an `agent-browser:` block. It propagates to all subsequent commands in the block.
 
 **Ground truth verification**: Use the ordinary pathway (`agent-browser screenshot`) for visual confirmation; use the exec pathway for JavaScript-level inspection.

package/skills/gm/SKILL.md

@@ -67,14 +67,12 @@ exec:close
 <task_id>
 ```
 
-**Runner management** (the runner itself is a PM2 process named `gm-exec-runner`):
+**Runner management**:
 ```
 exec:runner
 start|stop|status
 ```
 
-`exec:runner start` launches the `gm-exec-runner` PM2 process. Each `exec:<lang>` call creates its own `gm-exec-task-{id}` PM2 process — all appear in `pm2 list`. Use `exec:runner status` to check the runner. Use `exec:pm2list` to see all processes including exec tasks.
-
 ## CODEBASE EXPLORATION
 
 ```
@@ -101,6 +99,15 @@ Invoke `agent-browser` skill. Escalation — exhaust each before advancing:
 **`update-docs`** — Refresh README, CLAUDE.md, and docs to reflect session changes. Invoked by `gm-complete`.
 **`agent-browser`** — Browser automation. Invoke inside EXECUTE for all browser/UI work.
 
+## DO NOT STOP
+
+**You may not respond to the user or stop working while any of these are true:**
+- .prd file exists and has items
+- git has uncommitted changes
+- git has unpushed commits
+
+Completing a phase is NOT stopping. After every phase: read .prd, check git, invoke next skill. Only when .prd is deleted AND git is clean AND all commits are pushed may you return a final response to the user.
+
 ## CONSTRAINTS
 
 **Tier 0**: no_crash, no_exit, ground_truth_only, real_execution
@@ -108,6 +115,6 @@ Invoke `agent-browser` skill. Escalation — exhaust each before advancing:
 **Tier 2**: no_duplication, no_hardcoded_values, modularity
 **Tier 3**: no_comments, convention_over_code
 
-**Never**: `Bash(node/npm/npx/bun)` | skip planning | sequential independent items | screenshot before JS exhausted | narrate past unresolved mutables
+**Never**: `Bash(node/npm/npx/bun)` | skip planning | sequential independent items | screenshot before JS exhausted | narrate past unresolved mutables | stop while .prd has items | ask the user what to do next while work remains
 
-**Always**: invoke named skill at every transition | snake to planning on any new unknown | witnessed execution only | keep going until .prd empty and git clean
+**Always**: invoke named skill at every transition | snake to planning on any new unknown | witnessed execution only | keep going until .prd deleted and git clean

package/skills/gm-complete/SKILL.md

@@ -55,7 +55,7 @@ For browser/UI: invoke `agent-browser` skill with real workflows. Server + clien
 
 `exec:nodejs` (default) | `exec:bash` | `exec:python` | `exec:typescript` | `exec:go` | `exec:rust` | `exec:java` | `exec:deno` | `exec:cmd`
 
-Only git in bash directly. Background tasks: `exec:sleep\n<id>`, `exec:status\n<id>`, `exec:close\n<id>`. Runner: `exec:runner\nstart|stop|status`. All activity visible in `pm2 list` and `pm2 monit` in user terminal.
+Only git in bash directly. Background tasks: `exec:sleep\n<id>`, `exec:status\n<id>`, `exec:close\n<id>`. Runner: `exec:runner\nstart|stop|status`.
 
 ## CODEBASE EXPLORATION
 
@@ -82,16 +82,20 @@ Must return 0. If not: stage → commit → push → re-verify. Local commit wit
 
 All of: witnessed end-to-end output | all failure paths exercised | .prd empty | git clean and pushed | `user_steps_remaining=0`
 
+## DO NOT STOP
+
+After end-to-end verification passes: read .prd from disk. If any items remain, immediately invoke `gm-execute` skill — do not respond to the user. Only respond when .prd is deleted AND git is clean AND all commits are pushed.
+
 ## CONSTRAINTS
 
-**Never**: claim done without witnessed output | uncommitted changes | unpushed commits | .prd items remaining | stop at first green | absorb surprises silently
+**Never**: claim done without witnessed output | uncommitted changes | unpushed commits | .prd items remaining | stop at first green | absorb surprises silently | respond to user while .prd has items
 
-**Always**: triage failure before snaking | witness end-to-end | snake to planning on any new unknown | enumerate remaining after every success
+**Always**: triage failure before snaking | witness end-to-end | snake to planning on any new unknown | enumerate remaining after every success | check .prd after every verification pass
 
 ---
 
-**→ FORWARD**: .prd items remain → invoke `gm-execute` skill.
-**→ FORWARD**: .prd empty + feature work pushed → invoke `update-docs` skill.
+**→ FORWARD**: .prd items remain → invoke `gm-execute` skill (keep going, do not stop).
+**→ FORWARD**: .prd deleted + feature work pushed → invoke `update-docs` skill.
 **↩ SNAKE to EMIT**: file output wrong → invoke `gm-emit` skill.
 **↩ SNAKE to EXECUTE**: logic wrong → invoke `gm-execute` skill.
 **↩ SNAKE to PLAN**: new unknown or wrong requirements → invoke `planning` skill, restart chain.

package/skills/gm-emit/SKILL.md

@@ -87,15 +87,19 @@ Invoke `agent-browser` skill. Escalation: (1) `exec:agent-browser\n<js>` → (2)
 
 File ≤200 lines | No duplication | Pre-emit passed | No mocks | No comments | Docs match | All spotted issues fixed
 
+## DO NOT STOP
+
+Never respond to the user from this phase. When all gate conditions pass, immediately invoke `gm-complete` skill. Do not pause, summarize, or ask questions.
+
 ## CONSTRAINTS
 
-**Never**: write before pre-emit passes | advance with post-emit variance | absorb surprises silently | comments | hardcoded values | defer spotted issues
+**Never**: write before pre-emit passes | advance with post-emit variance | absorb surprises silently | comments | hardcoded values | defer spotted issues | respond to user or pause for input
 
-**Always**: pre-emit debug before writing | post-emit verify from disk | snake to planning on any new unknown | fix immediately
+**Always**: pre-emit debug before writing | post-emit verify from disk | snake to planning on any new unknown | fix immediately | invoke next skill immediately when gates pass
 
 ---
 
-**→ FORWARD**: All gates pass → invoke `gm-complete` skill.
+**→ FORWARD**: All gates pass → invoke `gm-complete` skill immediately.
 **↺ SELF-LOOP**: Known post-emit variance → fix, re-verify.
 **↩ SNAKE to EXECUTE**: Known logic error → invoke `gm-execute` skill.
 **↩ SNAKE to PLAN**: Any new unknown → invoke `planning` skill, restart chain.

package/skills/gm-execute/SKILL.md

@@ -47,7 +47,7 @@ exec:close
 <task_id>
 ```
 
-**Runner** (PM2-backed — all activity visible in `pm2 list` and `pm2 monit` in user terminal):
+**Runner**:
 ```
 exec:runner
 start|stop|status
@@ -108,14 +108,18 @@ window.__gm = { captures: [], log: (...a) => window.__gm.captures.push({t:Date.n
 
 Real services, real data, real timing. Mocks/fakes/stubs = delete immediately. No .test.js/.spec.js. Delete on discovery.
 
+## DO NOT STOP
+
+Never respond to the user from this phase. When all mutables are KNOWN, immediately invoke `gm-emit` skill. The chain continues until .prd is deleted and git is clean — that happens in `gm-complete`, not here.
+
 ## CONSTRAINTS
 
-**Never**: `Bash(node/npm/npx/bun)` | fake data | mock files | Glob/Grep/Explore | sequential independent items | absorb surprises silently
+**Never**: `Bash(node/npm/npx/bun)` | fake data | mock files | Glob/Grep/Explore | sequential independent items | absorb surprises silently | respond to user or pause for input
 
-**Always**: witness every hypothesis | import real modules | snake to planning on any new unknown | fix immediately on discovery
+**Always**: witness every hypothesis | import real modules | snake to planning on any new unknown | fix immediately on discovery | invoke next skill immediately when done
 
 ---
 
-**→ FORWARD**: All mutables KNOWN → invoke `gm-emit` skill.
+**→ FORWARD**: All mutables KNOWN → invoke `gm-emit` skill immediately.
 **↺ SELF-LOOP**: Still UNKNOWN → re-run (max 2 passes).
 **↩ SNAKE to PLAN**: Any new unknown → invoke `planning` skill, restart chain.

package/skills/planning/SKILL.md

@@ -83,8 +83,12 @@ Independent items (empty `blockedBy`) run in parallel waves of ≤3 subagents.
 
 **Skip planning entirely** if: task is single-step, trivially bounded, zero unknowns, under 5 minutes.
 
+## DO NOT STOP
+
+Never respond to the user from this phase. When .prd is complete (zero new items in last pass), immediately invoke `gm-execute` skill. Do not pause, summarize, or ask for confirmation.
+
 ---
 
-**→ FORWARD**: No new mutables → invoke `gm-execute` skill.
+**→ FORWARD**: No new mutables → invoke `gm-execute` skill immediately.
 **↺ SELF-LOOP**: New items discovered → add to .prd → plan again.
 **↩ SNAKE here**: New unknown surfaces in any later phase → add it, re-plan, re-advance.

package/tools.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.239",
+  "version": "2.0.241",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "tools": [
     {