@monoes/monomindcli 1.10.29 → 1.10.30

package/.claude/helpers/utils/telemetry.cjs

@@ -0,0 +1,144 @@
+'use strict';
+// Extracted from hook-handler.cjs — session-scoped telemetry helpers.
+// All functions are stateless and read/write .monomind/metrics/*.json files.
+
+const path = require('path');
+const fs = require('fs');
+
+const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+function _recordRecentEdit(filePath) {
+  if (!filePath) return;
+  try {
+    var f = path.join(CWD, '.monomind', 'metrics', 'recent-edits.json');
+    fs.mkdirSync(path.dirname(f), { recursive: true });
+    var d = { edits: [] };
+    try { d = JSON.parse(fs.readFileSync(f, 'utf-8')); } catch (_) {}
+    if (!Array.isArray(d.edits)) d.edits = [];
+    d.edits = d.edits.filter(function(e) { return e.file !== filePath; });
+    d.edits.unshift({ file: filePath, editedAt: Date.now() });
+    if (d.edits.length > 10) d.edits = d.edits.slice(0, 10);
+    fs.writeFileSync(f, JSON.stringify(d));
+  } catch (e) { /* non-fatal */ }
+}
+
+function _getRecentEdits() {
+  try {
+    var f = path.join(CWD, '.monomind', 'metrics', 'recent-edits.json');
+    if (!fs.existsSync(f)) return [];
+    var d = JSON.parse(fs.readFileSync(f, 'utf-8'));
+    if (!Array.isArray(d.edits)) return [];
+    var cutoff = Date.now() - 2 * 60 * 60 * 1000;
+    return d.edits.filter(function(e) { return e.editedAt > cutoff; });
+  } catch (e) { return []; }
+}
+
+function _recordToolCall(signature) {
+  try {
+    var f = path.join(CWD, '.monomind', 'metrics', 'tool-calls.json');
+    fs.mkdirSync(path.dirname(f), { recursive: true });
+    var d = {};
+    try { d = JSON.parse(fs.readFileSync(f, 'utf-8')); } catch (_) {}
+    if (typeof d !== 'object' || d === null) d = {};
+    if (!d.startedAt || (Date.now() - d.startedAt) > 4 * 60 * 60 * 1000) {
+      d = { startedAt: Date.now(), calls: {} };
+    }
+    d.calls[signature] = (d.calls[signature] || 0) + 1;
+    fs.writeFileSync(f, JSON.stringify(d));
+    return d.calls[signature];
+  } catch (e) { return 0; }
+}
+
+function _getBudgetStatus() {
+  try {
+    var budgetFile = path.join(CWD, '.monomind', 'budget.json');
+    var summaryFile = path.join(CWD, '.monomind', 'metrics', 'token-summary.json');
+    if (!fs.existsSync(summaryFile)) return null;
+    var summary = JSON.parse(fs.readFileSync(summaryFile, 'utf-8'));
+    var todayCost = summary.todayCost || (summary.today && summary.today.cost) || 0;
+    var monthCost = summary.monthCost || (summary.month && summary.month.cost) || 0;
+
+    var dailyLimit, monthlyLimit, autoTuned = false;
+    if (fs.existsSync(budgetFile)) {
+      try {
+        var b = JSON.parse(fs.readFileSync(budgetFile, 'utf-8'));
+        dailyLimit = b.dailyLimit;
+        monthlyLimit = b.monthlyLimit;
+      } catch (_) {}
+    }
+
+    if (!dailyLimit || !monthlyLimit) {
+      var now = new Date();
+      var daysIntoMonth = now.getUTCDate();
+      var dailyAvg = daysIntoMonth >= 1 ? monthCost / daysIntoMonth : 0;
+      if (dailyAvg > 5 && daysIntoMonth >= 7) {
+        dailyLimit  = Math.max(dailyLimit  || 0, Math.ceil(dailyAvg * 1.5));
+        monthlyLimit = Math.max(monthlyLimit || 0, Math.ceil(dailyAvg * 1.5 * 30));
+        autoTuned = true;
+        try {
+          fs.mkdirSync(path.dirname(budgetFile), { recursive: true });
+          fs.writeFileSync(budgetFile, JSON.stringify({
+            dailyLimit: dailyLimit, monthlyLimit: monthlyLimit,
+            autoTuned: true, tunedAt: now.toISOString(),
+            basis: 'rolling avg $' + dailyAvg.toFixed(2) + '/day × 1.5',
+            note: 'Edit these values to set a hard ceiling. Delete the file to re-tune.',
+          }, null, 2));
+        } catch (_) {}
+      } else {
+        dailyLimit = dailyLimit || 50;
+        monthlyLimit = monthlyLimit || 1500;
+      }
+    }
+
+    var dailyPct = Math.round((todayCost / dailyLimit) * 100);
+    var monthlyPct = Math.round((monthCost / monthlyLimit) * 100);
+    var rollingDaily = (new Date()).getUTCDate() >= 1 ? monthCost / (new Date()).getUTCDate() : 0;
+    var spike = rollingDaily > 0 && todayCost > rollingDaily * 2.0 && todayCost > 5;
+
+    return {
+      todayCost, monthCost, dailyLimit, monthlyLimit,
+      dailyPct, monthlyPct, autoTuned, spike,
+      alert: dailyPct >= 80 || monthlyPct >= 80 || spike,
+      breached: dailyPct >= 100 || monthlyPct >= 100,
+    };
+  } catch (e) { return null; }
+}
+
+function _recordHookLatency(handlerName, durationMs) {
+  try {
+    var f = path.join(CWD, '.monomind', 'metrics', 'hook-latency.json');
+    fs.mkdirSync(path.dirname(f), { recursive: true });
+    var d = {};
+    try { d = JSON.parse(fs.readFileSync(f, 'utf-8')); } catch (_) {}
+    if (typeof d !== 'object' || d === null) d = {};
+    var entry = d[handlerName] || { count: 0, total: 0, max: 0 };
+    entry.count++;
+    entry.total += durationMs;
+    entry.max = Math.max(entry.max, durationMs);
+    entry.mean = Math.round(entry.total / entry.count);
+    d[handlerName] = entry;
+    d.lastUpdated = Date.now();
+    fs.writeFileSync(f, JSON.stringify(d));
+  } catch (e) {}
+}
+
+function _recordDecisionMarkers(promptText) {
+  if (!promptText || typeof promptText !== 'string') return;
+  var markers = /\b(let's go with|we (?:chose|decided|picked|will go with)|decision[:\s]|choosing|going with|prefer to|let's use)\b[^\.\n]{0,200}/gi;
+  var matches = promptText.match(markers);
+  if (!matches || matches.length === 0) return;
+  try {
+    var f = path.join(CWD, '.monomind', 'decisions.jsonl');
+    var entry = JSON.stringify({ ts: Date.now(), excerpts: matches.slice(0, 3), prompt: promptText.slice(0, 400) });
+    fs.appendFileSync(f, entry + '\n');
+  } catch (e) {}
+}
+
+module.exports = {
+  _recordRecentEdit,
+  _getRecentEdits,
+  _recordToolCall,
+  _getBudgetStatus,
+  _recordHookLatency,
+  _recordDecisionMarkers,
+};

package/.claude/skills/agent-browser-testing/SKILL.md

@@ -1,7 +1,8 @@
 ---
 name: agent-browser-testing
-description: UI testing and task walkthrough using agent-browser — install, navigate, test golden paths, report issues, and help users accomplish tasks through any web UI
-version: 1.0.0
+description: UI testing and task walkthrough using agent-browser — install, navigate, test golden paths, report issues, and help users accomplish tasks through any web UI. Delegates to monomind:browse for full feature coverage.
+version: 2.0.0
+delegates_to: monomind:browse
 triggers:
   - /ui-test
   - /browse

package/.claude/skills/monomind/browse-agentcore.md

@@ -0,0 +1,116 @@
+---
+name: monomind:browse-agentcore
+description: Run browser automation on AWS Bedrock AgentCore cloud browser sessions. Use when the user wants to run browser automation on AWS, use a cloud browser with AWS credentials, or needs a managed browser session backed by AWS infrastructure. Triggers include "use agentcore", "run on AWS", "cloud browser with AWS", "bedrock browser", or any task requiring AWS-hosted browser automation.
+version: 1.0.0
+triggers:
+  - agentcore browser
+  - aws cloud browser
+  - bedrock browser
+  - run browser on aws
+  - browser automation aws
+tools:
+  - Bash
+requires:
+  - agent-browser >= 0.25.4
+---
+
+<!-- Pattern adapted from agent-browser — rebranded for monomind -->
+
+# AWS Bedrock AgentCore Browser (monomind:browse-agentcore)
+
+Run browser automation on cloud browser sessions hosted by AWS Bedrock AgentCore. All standard browser commands work identically — the only difference is where the browser runs.
+
+See `monomind:browse` for the full browser automation reference.
+
+## Setup
+
+Credentials are resolved automatically (in order):
+1. Environment variables (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, optionally `AWS_SESSION_TOKEN`)
+2. AWS CLI fallback (`aws configure export-credentials`) — supports SSO, IAM roles, named profiles
+
+No additional setup needed if AWS credentials are already configured.
+
+## Core Workflow
+
+```bash
+# Open a page on an AgentCore cloud browser
+agent-browser -p agentcore open https://example.com
+
+# Everything else is identical to local Chrome
+agent-browser snapshot -i
+agent-browser click @e1
+agent-browser screenshot page.png
+agent-browser close
+```
+
+## Environment Variables
+
+| Variable | Description | Default |
+|---|---|---|
+| `AGENTCORE_REGION` | AWS region | `us-east-1` |
+| `AGENTCORE_BROWSER_ID` | Browser identifier | `aws.browser.v1` |
+| `AGENTCORE_PROFILE_ID` | Persistent browser profile (cookies, localStorage) | none |
+| `AGENTCORE_SESSION_TIMEOUT` | Session timeout in seconds | `3600` |
+| `AWS_PROFILE` | AWS CLI profile for credential resolution | `default` |
+
+## Set Provider Globally
+
+```bash
+export AGENT_BROWSER_PROVIDER=agentcore
+export AGENTCORE_REGION=us-east-2
+
+agent-browser open https://example.com
+agent-browser snapshot -i
+agent-browser click @e1
+agent-browser close
+```
+
+## Persistent Profiles
+
+Reuse login state across sessions:
+
+```bash
+# First run — log in
+AGENTCORE_PROFILE_ID=my-app agent-browser -p agentcore open https://app.example.com/login
+agent-browser snapshot -i
+agent-browser fill @e1 "user@example.com"
+agent-browser fill @e2 "password"
+agent-browser click @e3
+agent-browser close
+
+# Future runs — already authenticated
+AGENTCORE_PROFILE_ID=my-app agent-browser -p agentcore open https://app.example.com/dashboard
+```
+
+## Credential Patterns
+
+```bash
+# Explicit (CI/CD)
+export AWS_ACCESS_KEY_ID=AKIA...
+export AWS_SECRET_ACCESS_KEY=...
+agent-browser -p agentcore open https://example.com
+
+# SSO
+aws sso login --profile my-profile
+AWS_PROFILE=my-profile agent-browser -p agentcore open https://example.com
+
+# Default credential chain (IAM role, etc.)
+agent-browser -p agentcore open https://example.com
+```
+
+## Live View
+
+When a session starts, AgentCore prints a Live View URL to stderr — open it in the AWS Console to watch in real time:
+
+```
+Session: abc123-def456
+Live View: https://us-east-1.console.aws.amazon.com/bedrock-agentcore/browser/aws.browser.v1/session/abc123-def456#
+```
+
+## Troubleshooting
+
+| Error | Fix |
+|-------|-----|
+| "Failed to run aws CLI" | Install AWS CLI or set `AWS_ACCESS_KEY_ID`/`AWS_SECRET_ACCESS_KEY` directly |
+| "Run 'aws sso login'" | SSO credentials expired — run `aws sso login` |
+| Session timeout | Increase with `AGENTCORE_SESSION_TIMEOUT=7200` |

package/.claude/skills/monomind/browse-electron.md

@@ -0,0 +1,189 @@
+---
+name: monomind:browse-electron
+description: Automate Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify, etc.) using browser automation via Chrome DevTools Protocol. Use when the user needs to interact with an Electron app, automate a desktop app, connect to a running app, or test an Electron application.
+version: 1.0.0
+triggers:
+  - automate electron
+  - control vscode
+  - interact with discord app
+  - test electron app
+  - connect to desktop app
+  - electron desktop automation
+  - automate slack desktop
+tools:
+  - Bash
+requires:
+  - agent-browser >= 0.25.4
+---
+
+<!-- Pattern adapted from agent-browser — rebranded for monomind -->
+
+# Electron App Automation (monomind:browse-electron)
+
+Automate any Electron desktop app using agent-browser via Chrome DevTools Protocol (CDP). Electron apps are built on Chromium and expose a CDP port, enabling the same snapshot-interact workflow used for web pages.
+
+See `monomind:browse` for the full browser automation reference.
+
+## Core Workflow
+
+1. **Launch** the Electron app with remote debugging enabled
+2. **Connect** agent-browser to the CDP port
+3. **Snapshot** to discover interactive elements
+4. **Interact** using element refs
+5. **Re-snapshot** after navigation or state changes
+
+```bash
+# Launch an Electron app with remote debugging
+open -a "Slack" --args --remote-debugging-port=9222
+
+# Connect agent-browser to the app
+agent-browser connect 9222
+
+# Standard workflow from here
+agent-browser snapshot -i
+agent-browser click @e5
+agent-browser screenshot slack-desktop.png
+```
+
+## Launching with CDP
+
+Every Electron app supports `--remote-debugging-port` since it's built into Chromium.
+
+### macOS
+
+```bash
+open -a "Slack" --args --remote-debugging-port=9222
+open -a "Visual Studio Code" --args --remote-debugging-port=9223
+open -a "Discord" --args --remote-debugging-port=9224
+open -a "Figma" --args --remote-debugging-port=9225
+open -a "Notion" --args --remote-debugging-port=9226
+open -a "Spotify" --args --remote-debugging-port=9227
+```
+
+### Linux
+
+```bash
+slack --remote-debugging-port=9222
+code --remote-debugging-port=9223
+discord --remote-debugging-port=9224
+```
+
+### Windows
+
+```bash
+"C:\Users\%USERNAME%\AppData\Local\slack\slack.exe" --remote-debugging-port=9222
+"C:\Users\%USERNAME%\AppData\Local\Programs\Microsoft VS Code\Code.exe" --remote-debugging-port=9223
+```
+
+**Important:** If the app is already running, quit it first — the flag must be present at launch time.
+
+## Connecting
+
+```bash
+# Connect to a specific port (persists for session)
+agent-browser connect 9222
+
+# Or pass --cdp on each command
+agent-browser --cdp 9222 snapshot -i
+
+# Auto-discover a running Chromium-based app
+agent-browser --auto-connect snapshot -i
+```
+
+## Tab Management
+
+Electron apps often have multiple windows or webviews:
+
+```bash
+agent-browser tab           # list all targets (windows, webviews)
+agent-browser tab t2        # switch by stable id
+agent-browser tab --url "*settings*"  # switch by URL pattern
+```
+
+## Webview Support
+
+Electron `<webview>` elements appear as separate targets in the tab list:
+
+```bash
+agent-browser connect 9222
+agent-browser tab
+# 0: [page]    Slack - Main Window     https://app.slack.com/
+# 1: [webview] Embedded Content        https://example.com/widget
+
+agent-browser tab t2        # switch to webview
+agent-browser snapshot -i
+agent-browser click @e3
+```
+
+## Common Patterns
+
+### Inspect and Navigate
+
+```bash
+open -a "Slack" --args --remote-debugging-port=9222
+sleep 3
+agent-browser connect 9222
+agent-browser snapshot -i
+agent-browser click @e10
+agent-browser snapshot -i
+```
+
+### Screenshots
+
+```bash
+agent-browser connect 9222
+agent-browser screenshot app-state.png
+agent-browser screenshot --annotate annotated-app.png
+```
+
+### Extract Data
+
+```bash
+agent-browser connect 9222
+agent-browser snapshot -i
+agent-browser get text @e5
+agent-browser snapshot --json > app-state.json
+```
+
+### Fill Forms
+
+```bash
+agent-browser connect 9222
+agent-browser snapshot -i
+agent-browser fill @e3 "search query"
+agent-browser press Enter
+agent-browser wait 1000
+agent-browser snapshot -i
+```
+
+### Multiple Apps Simultaneously
+
+```bash
+agent-browser --session slack connect 9222
+agent-browser --session vscode connect 9223
+
+agent-browser --session slack snapshot -i
+agent-browser --session vscode snapshot -i
+```
+
+## Color Scheme
+
+```bash
+agent-browser connect 9222
+agent-browser --color-scheme dark snapshot -i
+# or
+AGENT_BROWSER_COLOR_SCHEME=dark agent-browser connect 9222
+```
+
+## Troubleshooting
+
+| Problem | Fix |
+|---------|-----|
+| "Connection refused" | App not launched with `--remote-debugging-port`, or port mismatch |
+| Connect fails after launch | Wait a few seconds — `sleep 3` before connect |
+| Elements not in snapshot | Use `agent-browser tab` to switch to the right window/webview |
+| Can't type in inputs | Try `agent-browser keyboard type "text"` or `keyboard inserttext "text"` |
+
+## Supported Apps
+
+Any Electron app: Slack, Discord, Teams, Signal, VS Code, GitHub Desktop, Postman, Figma, Notion, Obsidian, Spotify, Linear, 1Password, and more.

package/.claude/skills/monomind/browse-qa.md

@@ -0,0 +1,229 @@
+---
+name: monomind:browse-qa
+description: Systematic exploratory testing of a web application to find bugs, UX issues, and quality problems. Use when asked to dogfood, QA, exploratory test, find issues, bug hunt, or review the quality of a web app. Produces a structured report with full reproduction evidence — step-by-step screenshots, repro steps, and severity ratings for every finding.
+version: 1.0.0
+triggers:
+  - dogfood
+  - qa this app
+  - find bugs
+  - exploratory test
+  - bug hunt
+  - test this site
+  - quality review
+  - ux review
+  - find issues
+  - systematic test
+tools:
+  - Bash
+requires:
+  - agent-browser >= 0.25.4
+---
+
+<!-- Pattern adapted from agent-browser — rebranded for monomind -->
+
+# Systematic QA / Dogfood Testing (monomind:browse-qa)
+
+Systematically explore a web application, find issues, and produce a report with full reproduction evidence for every finding.
+
+See `monomind:browse` for the full browser automation reference.
+
+## Inputs
+
+| Parameter | Default | Example override |
+|---|---|---|
+| **Target URL** | _(required)_ | `vercel.com`, `http://localhost:3000` |
+| **Session name** | Slugified domain | `my-qa-session` |
+| **Output directory** | `./qa-output/` | `/tmp/qa` |
+| **Scope** | Full app | `Focus on the billing page` |
+| **Authentication** | None | `Sign in as user@example.com` |
+
+Start immediately with defaults. Only ask if authentication is mentioned but credentials are missing.
+
+Always call `agent-browser` directly — never `npx agent-browser`. The direct binary uses the fast Rust client.
+
+## Workflow
+
+```
+1. Initialize    → Set up session, output dirs, report file
+2. Authenticate  → Sign in if needed, save state
+3. Orient        → Navigate to starting point, initial snapshot
+4. Explore       → Systematically visit pages and test features
+5. Document      → Screenshot + record each issue as found
+6. Wrap up       → Summary counts, close session
+```
+
+### 1. Initialize
+
+```bash
+mkdir -p ./qa-output/screenshots
+SESSION="$(echo '<TARGET_URL>' | sed 's|https\?://||; s|/.*||; s|\.|-|g')"
+agent-browser --session "$SESSION" open <TARGET_URL>
+agent-browser --session "$SESSION" wait --load networkidle
+```
+
+### 2. Authenticate (if needed)
+
+```bash
+agent-browser --session "$SESSION" snapshot -i
+agent-browser --session "$SESSION" fill @e1 "<EMAIL>"
+agent-browser --session "$SESSION" fill @e2 "<PASSWORD>"
+agent-browser --session "$SESSION" click @e3
+agent-browser --session "$SESSION" wait --load networkidle
+
+# Save auth state for reuse
+agent-browser --session "$SESSION" state save ./qa-output/auth-state.json
+```
+
+For OTP/email codes: ask the user, wait for input, then enter the code.
+
+### 3. Orient
+
+```bash
+agent-browser --session "$SESSION" screenshot --annotate ./qa-output/screenshots/00-initial.png
+agent-browser --session "$SESSION" snapshot -i
+agent-browser --session "$SESSION" get title
+agent-browser --session "$SESSION" get url
+```
+
+Document the starting state: what is visible, main navigation elements, key actions available.
+
+### 4. Explore
+
+For each area/page:
+
+```bash
+agent-browser --session "$SESSION" click @e[nav-item]
+agent-browser --session "$SESSION" wait --load networkidle
+agent-browser --session "$SESSION" snapshot -i
+agent-browser --session "$SESSION" screenshot ./qa-output/screenshots/<page-name>.png
+```
+
+**Test systematically:**
+- Navigation: does every link work? Does back/forward work?
+- Forms: submit empty, submit invalid, submit valid
+- Interactive elements: hover states, click states, disabled states
+- Responsive: `agent-browser set viewport 375 812` (mobile), `1280 720` (desktop)
+- Error states: what happens when APIs fail? Use `network route` to simulate failures
+- Loading states: `wait --load networkidle` then check if spinners resolve
+
+### 5. Document Each Issue
+
+For every issue found:
+
+```bash
+# 1. Screenshot the broken state
+agent-browser --session "$SESSION" screenshot ./qa-output/screenshots/bug-<N>-<name>.png
+
+# 2. Record reproduction steps in report
+```
+
+Issue format:
+```
+## Issue N: <short title>
+
+**Severity:** Critical / High / Medium / Low
+**URL:** <current URL>
+**Steps to reproduce:**
+1. <step>
+2. <step>
+**Expected:** <what should happen>
+**Actual:** <what happened>
+**Screenshot:** screenshots/bug-N-name.png
+```
+
+### 6. Wrap Up
+
+```bash
+agent-browser --session "$SESSION" close
+```
+
+Print summary:
+```
+QA SUMMARY
+━━━━━━━━━━━━━━━━━━━━━━━━
+Target:  <URL>
+Pages:   <N> tested
+Issues:  Critical=<N> High=<N> Medium=<N> Low=<N>
+Output:  ./qa-output/
+```
+
+## Severity Guide
+
+| Level | Description | Example |
+|---|---|---|
+| Critical | Blocks core user flow | Login broken, payment fails |
+| High | Major feature broken | Form won't submit, page 404 |
+| Medium | Degraded experience | Wrong error message, slow load |
+| Low | Polish / cosmetic | Alignment off, typo |
+
+## Testing Checklist
+
+**Navigation:**
+- [ ] All nav links work
+- [ ] Breadcrumbs correct
+- [ ] Back/forward work
+- [ ] No broken links (`get url` shows expected path)
+
+**Forms:**
+- [ ] Empty submit → validation errors shown
+- [ ] Invalid data → appropriate error
+- [ ] Valid data → success state
+- [ ] Required field indicators visible
+
+**Interactive:**
+- [ ] All buttons clickable (check `is enabled`)
+- [ ] Dropdowns open and close
+- [ ] Modals open and close
+- [ ] Tooltips appear on hover
+
+**Responsive:**
+- [ ] Mobile (375×812): `agent-browser set viewport 375 812`
+- [ ] Tablet (768×1024): `agent-browser set viewport 768 1024`
+- [ ] Desktop (1280×720): `agent-browser set viewport 1280 720`
+
+**Error states:**
+- [ ] Network error: `agent-browser network route "https://api.*" --abort`
+- [ ] Empty state: check when lists/tables have no data
+- [ ] 404 page: navigate to `/nonexistent-path`
+
+**Accessibility:**
+- [ ] Tab order logical (press Tab through all elements)
+- [ ] All inputs have labels (visible in snapshot)
+- [ ] Buttons have accessible names
+
+## API Error Simulation
+
+```bash
+# Block all API calls to test error handling
+agent-browser batch \
+  '["open"]' \
+  '["network", "route", "https://api.example.com/*", "--abort"]' \
+  '["navigate", "https://app.example.com/dashboard"]'
+agent-browser snapshot -i
+# → Verify error states render correctly
+```
+
+## Diff Regression Testing
+
+```bash
+# Baseline
+agent-browser open https://app.example.com && agent-browser snapshot -i > ./qa-output/baseline.txt
+
+# After change
+agent-browser open https://app.example.com && agent-browser diff snapshot --baseline ./qa-output/baseline.txt
+```
+
+## Monomind Integration
+
+```bash
+# Create tasks for critical bugs
+npx monomind task create \
+  --title "CRITICAL: <issue title>" \
+  --description "Steps: <repro steps>. Screenshot: ./qa-output/screenshots/bug-N.png"
+
+# Store QA session patterns for reuse
+npx monomind memory store \
+  --namespace browse \
+  --key "qa-flow-<app>" \
+  --value "open → wait networkidle → screenshot → systematically test nav/forms/responsive"
+```