gm-oc 2.0.394 → 2.0.395

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-oc",
-  "version": "2.0.394",
+  "version": "2.0.395",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",

package/skills/browser/SKILL.md

@@ -10,10 +10,20 @@ allowed-tools: Bash(browser:*), Bash(exec:browser*)
 
 **Session commands** (`browser:` prefix) — manage multi-step sessions via playwriter CLI. Each `browser:` block runs its commands sequentially.
 
-**JS execution** (`exec:browser`) — run JavaScript directly against `page`. State persists across calls.
+**JS execution** (`exec:browser`) — run JavaScript directly against `page`. State persists across calls via `state` global.
 
 **CRITICAL**: Never mix these two pathways. Each `browser:` block is a separate Bash call. Each `exec:browser` block is a separate Bash call.
 
+## 15-Second Ceiling — How It Works
+
+Every `exec:browser` call has a 15s live window. During that window, all stdout/stderr is streamed to you in real time. After 15s the task backgrounds and you receive:
+- All output produced so far (live drain)
+- A task ID with `plugkit sleep/status/close` instructions
+
+**The task keeps running.** Every subsequent plugkit interaction automatically drains all running browser tasks — you will see new output without asking.
+
+**Never use `await new Promise(r => setTimeout(r, N))` with N > 10000.** Use short poll loops instead (see patterns below).
+
 ## Session Pathway (`browser:`)
 
 Create a session first, use `--direct` for CDP mode (requires Chrome with remote debugging):
@@ -83,14 +93,55 @@ Never add shell quoting — write plain JavaScript directly.
 
 ## Core Workflow
 
-1. **Create session**: `browser:\nplaywriter session new --direct`
-2. **Navigate** (one call per command): `browser:\nplaywriter -s 1 -e 'await page.goto("url")'`
-3. **Snapshot**: `browser:\nplaywriter -s 1 -e 'await snapshot({ page })'`
-4. **Interact**: click, fill, type — each as a separate browser: call
-5. **Extract data**: use `exec:browser` for JS queries
+1. **Navigate**: `exec:browser\nawait page.goto('url')` — session auto-created on first call
+2. **Snapshot**: `exec:browser\nawait snapshot({ page })`
+3. **Interact**: click, fill, type in subsequent `exec:browser` calls
+4. **Extract data**: `exec:browser\nconsole.log(await page.evaluate(() => document.title))`
+
+## Long-Running Operations — Poll Pattern
+
+For operations that take >10s (model loading, network fetches, animations):
+
+**Step 1** — set up listener and kick off the operation:
+```
+exec:browser
+state.done = false
+state.result = null
+page.on('console', msg => {
+  const t = msg.text()
+  if (t.includes('loaded') || t.includes('ready')) { state.done = true; state.result = t }
+})
+await page.click('#start-button')
+console.log('started, waiting...')
+```
+
+**Step 2** — poll in short bursts (this will background after 15s and keep draining):
+```
+exec:browser
+const start = Date.now()
+while (!state.done && Date.now() - start < 12000) {
+  await new Promise(r => setTimeout(r, 500))
+}
+console.log('done:', state.done, 'result:', state.result)
+```
+
+If step 2 backgrounds (takes >15s), every subsequent plugkit call will drain its output automatically. When you see the result in the drain log, close the task:
+```
+exec:close
+task_N
+```
 
 ## Common Patterns
 
+### Navigate and check current URL/status
+
+```
+exec:browser
+await page.goto('https://example.com')
+console.log('URL:', page.url())
+console.log('title:', await page.title())
+```
+
 ### Screenshot
 
 ```
@@ -98,7 +149,7 @@ browser:
 playwriter -s 1 -e 'await screenshotWithAccessibilityLabels({ page })'
 ```
 
-### Data Extraction (use exec:browser)
+### Data Extraction
 
 ```
 exec:browser
@@ -106,35 +157,24 @@ const items = await page.$$eval('.product-title', els => els.map(e => e.textCont
 console.log(JSON.stringify(items))
 ```
 
-### Console Monitoring (exec:browser)
+### Console Monitoring — set up listener first, then poll
 
 ```
 exec:browser
-state.consoleMsgs = []
-page.on('console', msg => state.consoleMsgs.push({ type: msg.type(), text: msg.text() }))
-page.on('pageerror', e => state.consoleMsgs.push({ type: 'error', text: e.message }))
+state.logs = []
+state.errors = []
+page.on('console', msg => state.logs.push({ type: msg.type(), text: msg.text() }))
+page.on('pageerror', e => state.errors.push(e.message))
+console.log('listeners attached')
 ```
 
 ```
 exec:browser
-console.log(JSON.stringify(state.consoleMsgs))
+console.log('logs so far:', JSON.stringify(state.logs.slice(-20)))
+console.log('errors:', JSON.stringify(state.errors))
 ```
 
-### Web Worker Console Monitoring
-
-```
-exec:browser
-state.workerMsgs = []
-for (const w of page.workers()) {
-  w.evaluate(() => {
-    const o = console.log.bind(console)
-    console.log = (...a) => { o(...a) }
-  }).catch(() => {})
-}
-page.on('worker', w => {
-  state.workerMsgs.push('[worker] ' + w.url())
-})
-```
+### Web Worker Access
 
 ```
 exec:browser
@@ -150,7 +190,7 @@ if (page.workers().length > 0) {
 }
 ```
 
-### Access window.debug globals
+### Access window globals
 
 ```
 exec:browser
@@ -161,10 +201,24 @@ const result = await page.evaluate(() => JSON.stringify({
 console.log(result)
 ```
 
+### Wait for element with short poll
+
+```
+exec:browser
+const start = Date.now()
+while (Date.now() - start < 12000) {
+  const el = await page.$('#status')
+  if (el) { console.log('found:', await el.textContent()); break }
+  await new Promise(r => setTimeout(r, 300))
+}
+```
+
 ## Key Rules
 
 - `browser:` prefix → playwriter session management (one command per block)
-- `exec:browser` → JS in page context (multi-line JS allowed)
+- `exec:browser` → JS in page context (multi-line JS allowed, 15s live window)
 - Never mix pathways in the same Bash call
 - `-e` argument: single quotes on outside, double quotes inside for JS strings
 - One `playwriter` command per `browser:` block
+- Never `await setTimeout(N)` with N > 10000 — use short poll loops instead
+- All running browser tasks drain automatically on every plugkit interaction