deepflow 0.1.87 → 0.1.89

package/src/skills/browse-fetch/SKILL.md

@@ -7,229 +7,35 @@ allowed-tools: [Bash, WebFetch, WebSearch, Read]
 
 # Browse-Fetch
 
-Retrieve live web content with a headless browser. Handles JavaScript-rendered pages, SPAs, and dynamic content that WebFetch cannot reach.
+Retrieve live web content with a headless browser. Handles JS-rendered pages, SPAs, and dynamic content that WebFetch cannot reach.
 
-## When to Use
-
-- Reading documentation sites that require JavaScript to render (e.g., React-based docs, Vite, Next.js portals)
-- Fetching the current content of a specific URL provided by the user
-- Extracting article or reference content from a known page before implementing code against it
-
-## Skip When
-
-- The URL is a plain HTML page or GitHub raw file — use WebFetch instead (faster, no overhead)
-- The target requires authentication (login wall) or CAPTCHA — browser cannot bypass; note the block and continue
+**Use when:** URL requires JavaScript rendering (React-based docs, SPAs, portals).
+**Skip when:** Plain HTML / GitHub raw file (use WebFetch) or auth-walled / CAPTCHA-blocked page.
 
 ---
 
 ## Browser Core Protocol
 
-This protocol is the reusable foundation for all browser-based skills (browse-fetch, browse-verify, etc.).
+The fetch script below implements all steps. Summary of what each phase does:
 
-### 1. Install Check
+1. **Runtime detection** — prefer `node`, fall back to `bun`.
+2. **Install check** — `require('playwright')` or auto-install chromium via npx.
+3. **Launch** — headless Chromium with desktop Chrome user-agent.
+4. **Navigate** — `goto` with `domcontentloaded` (upgrade to `networkidle` if content missing), 30s timeout, 1.5s settle delay.
+5. **Block detection** — check title/URL for login walls, body for CAPTCHA. On detection: log, skip, continue task.
+6. **Extract** — `page.evaluate()` converts DOM → Markdown in-browser (zero deps). Strips noise elements (nav/footer/header/aside/scripts/cookies), picks `main|article|[role=main]|body`, recursive `md()` handles headings, lists, tables, code blocks, links, images, blockquotes, definition lists. Falls back to `page.innerText('body')` if extraction < 100 chars.
+7. **Truncate** — cap at 16000 chars (~4000 tokens). Append `[content truncated]` marker.
+8. **Cleanup** — always `browser.close()` in `finally`.
 
-Before launching, verify Playwright is available:
+## Fetch Script
+
+Inline via `$RUNTIME -e`. Adapt URL per query.
 
 ```bash
-# Prefer Node.js; fall back to Bun
 if which node > /dev/null 2>&1; then RUNTIME=node; elif which bun > /dev/null 2>&1; then RUNTIME=bun; else echo "Error: neither node nor bun found" && exit 1; fi
 
 $RUNTIME -e "require('playwright')" 2>/dev/null \
   || npx --yes playwright install chromium --with-deps 2>&1 | tail -5
-```
-
-If installation fails, fall back to WebFetch (see Fallback section below).
-
-### 2. Launch Command
-
-```bash
-# Detect runtime — prefer Node.js per decision
-if which node > /dev/null 2>&1; then RUNTIME=node; elif which bun > /dev/null 2>&1; then RUNTIME=bun; else echo "Error: neither node nor bun found" && exit 1; fi
-
-$RUNTIME -e "
-const { chromium } = require('playwright');
-(async () => {
-  const browser = await chromium.launch({ headless: true });
-  const context = await browser.newContext({
-    userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
-  });
-  const page = await context.newPage();
-
-  // --- navigation + extraction (see sections 3–4) ---
-
-  await browser.close();
-})().catch(e => { console.error(e.message); process.exit(1); });
-"
-```
-
-### 3. Navigation
-
-```js
-// Inside the async IIFE above
-await page.goto(URL, { waitUntil: 'domcontentloaded', timeout: 30000 });
-// Allow JS to settle
-await page.waitForTimeout(1500);
-```
-
-- Use `waitUntil: 'domcontentloaded'` for speed; upgrade to `'networkidle'` only if content is missing.
-- Set `timeout: 30000` (30 s). On timeout, treat as graceful failure (see section 5).
-
-### 4. Content Extraction
-
-Extract content as **structured Markdown** optimized for LLM consumption (not raw HTML or flat text).
-
-```js
-// Convert DOM to Markdown inside the browser context — zero dependencies
-let text = await page.evaluate(() => {
-  // Remove noise elements
-  const noise = 'nav, footer, header, aside, script, style, noscript, svg, [role="navigation"], [role="banner"], [role="contentinfo"], .cookie-banner, #cookie-consent';
-  document.querySelectorAll(noise).forEach(el => el.remove());
-
-  // Pick main content container
-  const root = document.querySelector('main, article, [role="main"]') || document.body;
-
-  function md(node, listDepth = 0) {
-    if (node.nodeType === 3) return node.textContent;
-    if (node.nodeType !== 1) return '';
-    const tag = node.tagName.toLowerCase();
-    const children = () => Array.from(node.childNodes).map(c => md(c, listDepth)).join('');
-
-    // Skip hidden elements
-    if (node.getAttribute('aria-hidden') === 'true' || node.hidden) return '';
-
-    switch (tag) {
-      case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6': {
-        const level = '#'.repeat(parseInt(tag[1]));
-        const text = node.textContent.trim();
-        return text ? '\n\n' + level + ' ' + text + '\n\n' : '';
-      }
-      case 'p': return '\n\n' + children().trim() + '\n\n';
-      case 'br': return '\n';
-      case 'hr': return '\n\n---\n\n';
-      case 'strong': case 'b': { const t = children().trim(); return t ? '**' + t + '**' : ''; }
-      case 'em': case 'i': { const t = children().trim(); return t ? '*' + t + '*' : ''; }
-      case 'code': {
-        const t = node.textContent;
-        return node.parentElement && node.parentElement.tagName.toLowerCase() === 'pre' ? t : '`' + t + '`';
-      }
-      case 'pre': {
-        const code = node.querySelector('code');
-        const lang = code ? (code.className.match(/language-(\w+)/)||[])[1] || '' : '';
-        const t = (code || node).textContent.trim();
-        return '\n\n```' + lang + '\n' + t + '\n```\n\n';
-      }
-      case 'a': {
-        const href = node.getAttribute('href');
-        const t = children().trim();
-        return (href && t && !href.startsWith('#')) ? '[' + t + '](' + href + ')' : t;
-      }
-      case 'img': {
-        const alt = node.getAttribute('alt') || '';
-        return alt ? '[image: ' + alt + ']' : '';
-      }
-      case 'ul': case 'ol': return '\n\n' + children() + '\n';
-      case 'li': {
-        const indent = '  '.repeat(listDepth);
-        const bullet = node.parentElement && node.parentElement.tagName.toLowerCase() === 'ol'
-          ? (Array.from(node.parentElement.children).indexOf(node) + 1) + '. '
-          : '- ';
-        const content = Array.from(node.childNodes).map(c => {
-          const t = c.tagName && (c.tagName.toLowerCase() === 'ul' || c.tagName.toLowerCase() === 'ol')
-            ? md(c, listDepth + 1) : md(c, listDepth);
-          return t;
-        }).join('').trim();
-        return indent + bullet + content + '\n';
-      }
-      case 'table': {
-        const rows = Array.from(node.querySelectorAll('tr'));
-        if (!rows.length) return '';
-        const matrix = rows.map(r => Array.from(r.querySelectorAll('th, td')).map(c => c.textContent.trim()));
-        const cols = Math.max(...matrix.map(r => r.length));
-        const widths = Array.from({length: cols}, (_, i) => Math.max(...matrix.map(r => (r[i]||'').length), 3));
-        let out = '\n\n';
-        matrix.forEach((row, ri) => {
-          out += '| ' + Array.from({length: cols}, (_, i) => (row[i]||'').padEnd(widths[i])).join(' | ') + ' |\n';
-          if (ri === 0) out += '| ' + widths.map(w => '-'.repeat(w)).join(' | ') + ' |\n';
-        });
-        return out + '\n';
-      }
-      case 'blockquote': return '\n\n> ' + children().trim().replace(/\n/g, '\n> ') + '\n\n';
-      case 'dl': return '\n\n' + children() + '\n';
-      case 'dt': return '**' + children().trim() + '**\n';
-      case 'dd': return ': ' + children().trim() + '\n';
-      case 'div': case 'section': case 'span': case 'figure': case 'figcaption':
-        return children();
-      default: return children();
-    }
-  }
-
-  let result = md(root);
-  // Collapse excessive whitespace
-  result = result.replace(/\n{3,}/g, '\n\n').trim();
-  return result;
-});
-
-// Fallback if extraction is too short
-if (!text || text.trim().length < 100) {
-  text = await page.innerText('body').catch(() => '');
-}
-
-// Truncate to ~4000 tokens (~16000 chars) to stay within context budget
-const MAX_CHARS = 16000;
-if (text.length > MAX_CHARS) {
-  text = text.slice(0, MAX_CHARS) + '\n\n[content truncated — use a more specific selector or paginate]';
-}
-
-console.log(text);
-```
-
-For interactive element inspection (e.g., browse-verify), use `locator.ariaSnapshot()` instead of `innerText`.
-
-### 5. Graceful Failure
-
-Detect and handle blocks without crashing:
-
-```js
-const title = await page.title();
-const url   = page.url();
-
-// Login wall
-if (/sign.?in|log.?in|auth/i.test(title) || url.includes('/login')) {
-  console.log(`[browse-fetch] Blocked by login wall at ${url}. Skipping.`);
-  await browser.close();
-  process.exit(0);
-}
-
-// CAPTCHA
-const bodyText = await page.innerText('body').catch(() => '');
-if (/captcha|robot|human verification/i.test(bodyText)) {
-  console.log(`[browse-fetch] CAPTCHA detected at ${url}. Skipping.`);
-  await browser.close();
-  process.exit(0);
-}
-```
-
-On graceful failure: return the URL and a short explanation, then continue with the task using available context.
-
-### 6. Cleanup
-
-Always close the browser in a `finally` block or after use:
-
-```js
-await browser.close();
-```
-
----
-
-## Fetch Workflow
-
-**Goal:** retrieve and return structured Markdown content of a single URL.
-
-The full inline script uses `page.evaluate()` to convert DOM → Markdown inside the browser (zero Node dependencies). Adapt the URL per query.
-
-```bash
-# Full inline script — adapt URL per query
-if which node > /dev/null 2>&1; then RUNTIME=node; elif which bun > /dev/null 2>&1; then RUNTIME=bun; else echo "Error: neither node nor bun found" && exit 1; fi
 
 $RUNTIME -e "
 const { chromium } = require('playwright');
@@ -342,77 +148,46 @@ const { chromium } = require('playwright');
 "
 ```
 
-The agent inlines the full script via `node -e` or `bun -e` so no temp files are needed for extractions under ~4000 tokens.
+For interactive element inspection (e.g., browse-verify), use `locator.ariaSnapshot()` instead of DOM extraction.
 
 ---
 
 ## Search + Navigation Protocol
 
-**Time-box:** 60 seconds total. **Page cap:** 5 pages per query.
-
-> Search engines (Google, DuckDuckGo) block headless browsers with CAPTCHAs. Do NOT use Playwright to search them.
-
-Instead, use one of these strategies:
+**Time-box:** 60s. **Page cap:** 5 pages per query.
 
-| Strategy | When to use |
-|----------|-------------|
-| Direct URL construction | You know the domain (e.g., `docs.stripe.com/api/charges`) |
-| WebSearch tool | General keyword search before fetching pages |
-| Site-specific search | Navigate to `site.com/search?q=term` if the site exposes it |
+Do NOT use Playwright for Google/DuckDuckGo (CAPTCHA). Instead:
 
-**Navigation loop** (up to 5 pages):
+| Strategy | When |
+|----------|------|
+| Direct URL construction | Domain is known (e.g., `docs.stripe.com/api/charges`) |
+| WebSearch tool | General keyword search before fetching |
+| Site-specific search | Site exposes `/search?q=term` |
 
-1. Construct or obtain the target URL.
-2. Run the fetch workflow above.
-3. If the page lacks the needed information, look for a next-page link or a more specific sub-URL.
-4. Repeat up to 4 more times (5 total).
-5. Stop and summarize what was found within the 60 s window.
+Navigation loop: construct URL → fetch → if info missing, find next-page or sub-URL → repeat (max 5 pages) → summarize within 60s.
 
 ---
 
 ## Session Cache
 
-The context window is the cache. Extracted content lives in the conversation until it is no longer needed.
-
-For extractions larger than ~4000 tokens, write to a temp file and reference it:
-
-```bash
-# Write large extraction to temp file
-TMPFILE=$(mktemp /tmp/browse-fetch-XXXXXX.txt)
-$RUNTIME -e "...script..." > "$TMPFILE"
-echo "Content saved to $TMPFILE"
-# Read relevant sections with grep or head rather than loading all at once
-```
+Context window is the cache. For extractions > ~4000 tokens, write to temp file (`mktemp /tmp/browse-fetch-XXXXXX.txt`) and read relevant sections with grep/head.
 
 ---
 
 ## Fallback Without Playwright
 
-When Playwright is unavailable or fails to install, fall back to the WebFetch tool for:
-
-- Static HTML sites (GitHub README, raw docs, Wikipedia)
-- Any URL the user provides where JavaScript rendering is not required
-
 | Condition | Action |
 |-----------|--------|
-| `playwright` not installed, install fails | Use WebFetch |
-| Page is a known static domain (github.com/raw, pastebin, etc.) | Use WebFetch directly — skip Playwright |
-| Playwright times out twice | Use WebFetch as fallback attempt |
-
-```
-WebFetch: { url: "https://example.com/page", prompt: "Extract the main content" }
-```
-
-If WebFetch also fails, return the URL with an explanation and continue the task.
+| Playwright install fails | Use WebFetch |
+| Known static domain (github raw, pastebin, wikipedia) | Use WebFetch directly, skip Playwright |
+| Playwright times out twice | Use WebFetch as fallback |
+| WebFetch also fails | Return URL with explanation, continue task |
 
 ---
 
 ## Rules
 
-- Always run the install check before the first browser launch in a session.
-- Detect runtime with `which node` first; fall back to `bun` if node is absent.
-- Never navigate to Google or DuckDuckGo with Playwright — use WebSearch tool or direct URLs.
-- Truncate output at ~4000 tokens (~16 000 chars) to protect context budget.
-- On login wall or CAPTCHA, log the block, skip, and continue — never retry infinitely.
-- Close the browser in every code path (use `finally`).
+- Never navigate to Google/DuckDuckGo with Playwright — use WebSearch or direct URLs.
+- On login wall or CAPTCHA: log, skip, continue. Never retry infinitely.
+- Close browser in every code path (`finally` block).
 - Do not persist browser sessions across unrelated tasks.

package/src/skills/browse-verify/SKILL.md

@@ -8,49 +8,18 @@ context: fork
 
 Headless browser verification using Playwright's accessibility tree. Evaluates structured assertions from PLAN.md without LLM calls — purely deterministic matching.
 
-## When to Use
+**Use when:** Spec has browser-based ACs (element presence, text content, roles, interactive states, structure).
+**Skip when:** No browser-facing ACs or backend-only implementation.
 
-After implementing a spec that contains browser-based acceptance criteria:
-- Visual/layout checks (element presence, text content, roles)
-- Interactive state checks (aria-checked, aria-expanded, aria-disabled)
-- Structural checks (element within a container)
+**Prerequisites:** Node.js or Bun + Playwright 1.x. Runtime detection and browser auto-install follow the same protocol as browse-fetch (`which node || which bun`; `npx playwright install chromium`).
 
-**Skip when:** The spec has no browser-facing ACs, or the implementation is backend-only.
-
-## Prerequisites
-
-- Node.js (preferred) or Bun
-- Playwright 1.x (`npm install playwright` or `npx playwright install`)
-- Chromium browser (auto-installed if missing)
-
-## Runtime Detection
-
-```bash
-# Prefer Node.js; fall back to Bun
-if which node > /dev/null 2>&1; then
-  RUNTIME=node
-elif which bun > /dev/null 2>&1; then
-  RUNTIME=bun
-else
-  echo "Error: neither node nor bun found" && exit 1
-fi
-```
-
-## Browser Auto-Install
-
-Before running, ensure Chromium is available:
-
-```bash
-npx playwright install chromium
-```
-
-Run this once per environment. If it fails due to permissions, instruct the user to run it manually.
+---
 
 ## Protocol
 
 ### 1. Read Assertions from PLAN.md
 
-Assertions are written into PLAN.md by the `plan` skill during planning. Format:
+Assertions are written by the `plan` skill. Format:
 
 ```yaml
 assertions:
@@ -65,10 +34,6 @@ assertions:
     name: "Dashboard"
     check: visible
     within: main
-  - role: textbox
-    name: "Email"
-    check: value
-    value: "user@example.com"
 ```
 
 Assertion schema:
@@ -78,36 +43,29 @@ Assertion schema:
 | `role`   | yes      | ARIA role (button, checkbox, heading, textbox, link, etc.) |
 | `name`   | yes      | Accessible name (exact or partial match) |
 | `check`  | yes      | One of: `visible`, `absent`, `state`, `value`, `count` |
-| `value`  | no       | Expected value for `state` or `value` checks |
+| `value`  | no       | Expected value for `state`, `value`, or `count` checks |
 | `within` | no       | Ancestor role or selector to scope the search |
 
 ### 2. Launch Browser and Navigate
 
 ```javascript
-const { chromium } = require('playwright');
-
 const browser = await chromium.launch({ headless: true });
 const page = await browser.newPage();
-
 await page.goto(TARGET_URL, { waitUntil: 'networkidle' });
 ```
 
-`TARGET_URL` is read from the spec's metadata or passed as an argument.
+`TARGET_URL` from spec metadata or passed as argument.
 
 ### 3. Extract Accessibility Tree
 
 Use `locator.ariaSnapshot()` — **NOT** `page.accessibility.snapshot()` (removed in Playwright 1.x):
 
 ```javascript
-// Full-page aria snapshot (YAML-like role tree)
 const snapshot = await page.locator('body').ariaSnapshot();
-
-// Scoped snapshot within a container
-const containerSnapshot = await page.locator('main').ariaSnapshot();
+// Scoped: await page.locator('main').ariaSnapshot();
 ```
 
-`ariaSnapshot()` returns a YAML-like string such as:
-
+Returns YAML-like role tree:
 ```yaml
 - heading "Dashboard" [level=1]
 - button "Submit" [disabled]
@@ -115,151 +73,59 @@ const containerSnapshot = await page.locator('main').ariaSnapshot();
 - textbox "Email": user@example.com
 ```
 
-### 4. Capture Bounding Boxes (optional)
+### 4. Bounding Boxes (optional)
 
-For spatial/layout assertions or debugging:
+For spatial/layout assertions: `await page.getByRole(role, { name }).boundingBox()` returns `{ x, y, width, height }` or null.
 
-```javascript
-const element = page.getByRole(role, { name: assertionName });
-const box = await element.boundingBox();
-// box: { x, y, width, height } or null if not visible
-```
-
-### 5. Evaluate Assertions Deterministically
+### 5. Evaluate Assertions
 
-Parse the aria snapshot and evaluate each assertion. No LLM calls during this phase.
-
-```javascript
-function evaluateAssertion(snapshot, assertion) {
-  const { role, name, check, value, within } = assertion;
+Parse the aria snapshot and evaluate each assertion deterministically (no LLM calls).
 
-  // Optionally scope to a sub-tree
-  const tree = within
-    ? extractSubtree(snapshot, within)
-    : snapshot;
-
-  switch (check) {
-    case 'visible':
-      return treeContains(tree, role, name);
-
-    case 'absent':
-      return !treeContains(tree, role, name);
-
-    case 'state':
-      // e.g., value: "checked", "disabled", "expanded"
-      return treeContainsWithState(tree, role, name, value);
-
-    case 'value':
-      // Matches textbox/combobox displayed value
-      return treeContainsWithValue(tree, role, name, value);
-
-    case 'count':
-      return countMatches(tree, role, name) === parseInt(value, 10);
-  }
-}
-```
+| Check | Logic |
+|-------|-------|
+| `visible` | Role+name found in tree |
+| `absent` | Role+name NOT found in tree |
+| `state` | Role+name found with state token (e.g., `[checked]`, `[disabled]`, `[expanded]`) |
+| `value` | Role+name found with matching displayed value (textbox/combobox) |
+| `count` | Number of role+name matches equals `parseInt(value)` |
 
 Matching rules:
-- Role matching is case-insensitive
-- Name matching is case-insensitive substring match (unless wrapped in quotes for exact match)
-- State tokens (`[checked]`, `[disabled]`, `[expanded]`) are parsed from the snapshot line
-
-### 6. Capture Screenshot
+- Role matching: case-insensitive
+- Name matching: case-insensitive substring (exact match only when assertion wraps name in quotes)
+- If `within` specified, scope to that ancestor's subtree first
 
-After evaluation, capture a screenshot for the audit trail:
+### 6. Screenshot
 
-```javascript
-const screenshotDir = `.deepflow/screenshots/${specName}`;
-const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-const screenshotPath = `${screenshotDir}/${timestamp}.png`;
-
-await fs.mkdir(screenshotDir, { recursive: true });
-await page.screenshot({ path: screenshotPath, fullPage: true });
+Capture after every run regardless of pass/fail:
 ```
-
-Screenshot path convention: `.deepflow/screenshots/{spec-name}/{timestamp}.png`
+.deepflow/screenshots/{spec-name}/{ISO-timestamp}.png
+```
+Use `page.screenshot({ path, fullPage: true })`.
 
 ### 7. Report Results
 
-Emit a structured result for each assertion:
-
 ```
-[PASS] button "Submit" — visible ✓
-[PASS] checkbox "Accept terms" — state: checked ✓
+[PASS] button "Submit" — visible
 [FAIL] heading "Dashboard" — expected visible, not found in snapshot
-[PASS] textbox "Email" — value: user@example.com ✓
 
-Results: 3 passed, 1 failed
+Results: 1 passed, 1 failed
 Screenshot: .deepflow/screenshots/login-form/2026-03-14T12-00-00-000Z.png
 ```
 
-Exit with code 0 if all assertions pass, 1 if any fail.
+Exit code 0 if all pass, 1 if any fail.
 
 ### 8. Tear Down
 
-```javascript
-await browser.close();
-```
-
-Always close the browser, even on error (use try/finally).
+Always `browser.close()` in a `finally` block.
 
-## Full Script Template
-
-```javascript
-#!/usr/bin/env node
-const { chromium } = require('playwright');
-const fs = require('fs/promises');
-const path = require('path');
-
-async function main({ targetUrl, specName, assertions }) {
-  // Auto-install chromium if needed
-  // (handled by: npx playwright install chromium)
-
-  const browser = await chromium.launch({ headless: true });
-  const page = await browser.newPage();
-
-  try {
-    await page.goto(targetUrl, { waitUntil: 'networkidle' });
-
-    const snapshot = await page.locator('body').ariaSnapshot();
-
-    const results = assertions.map(assertion => ({
-      assertion,
-      passed: evaluateAssertion(snapshot, assertion),
-    }));
-
-    // Screenshot
-    const screenshotDir = path.join('.deepflow', 'screenshots', specName);
-    await fs.mkdir(screenshotDir, { recursive: true });
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const screenshotPath = path.join(screenshotDir, `${timestamp}.png`);
-    await page.screenshot({ path: screenshotPath, fullPage: true });
-
-    // Report
-    const passed = results.filter(r => r.passed).length;
-    const failed = results.filter(r => !r.passed).length;
-
-    for (const { assertion, passed: ok } of results) {
-      const status = ok ? '[PASS]' : '[FAIL]';
-      console.log(`${status} ${assertion.role} "${assertion.name}" — ${assertion.check}${assertion.value ? ': ' + assertion.value : ''}`);
-    }
-
-    console.log(`\nResults: ${passed} passed, ${failed} failed`);
-    console.log(`Screenshot: ${screenshotPath}`);
-
-    process.exit(failed > 0 ? 1 : 0);
-  } finally {
-    await browser.close();
-  }
-}
-```
+---
 
 ## Rules
 
-- Never call an LLM during the verify phase — all assertion evaluation is deterministic
-- Always use `locator.ariaSnapshot()`, never `page.accessibility.snapshot()` (removed)
-- Always close the browser in a `finally` block
-- Screenshot every run regardless of pass/fail outcome
-- If Playwright is not installed, emit a clear error and instructions — don't silently skip
-- Partial name matching is the default; use exact matching only when the assertion specifies it
-- Report results to stdout in the structured format above for downstream parsing
+- Never call an LLM during the verify phase — all evaluation is deterministic.
+- Always use `locator.ariaSnapshot()`, never `page.accessibility.snapshot()` (removed).
+- Always close browser in `finally`.
+- Screenshot every run regardless of outcome.
+- If Playwright not installed, emit clear error with instructions — don't silently skip.
+- Partial name matching is default; exact only when assertion specifies it.
+- Report results in structured format above for downstream parsing.

package/src/skills/code-completeness/SKILL.md

@@ -4,9 +4,7 @@ description: Finds incomplete code in codebase. Use when analyzing for TODOs, st
 allowed-tools: [Read, Grep, Glob]
 ---
 
-# Code Completeness
-
-Find incomplete work in codebase.
+# Code Completeness — Find Incomplete Work
 
 ## Explicit Markers
 
@@ -30,8 +28,7 @@ Find incomplete work in codebase.
 
 | Pattern | Language |
 |---------|----------|
-| `it.skip`, `test.skip` | JavaScript |
-| `describe.skip` | JavaScript |
+| `it.skip`, `test.skip`, `describe.skip` | JavaScript |
 | `@pytest.mark.skip` | Python |
 | `t.Skip()` | Go |
 
@@ -51,10 +48,6 @@ REQ-1: {requirement}
 Status: PARTIAL
 Found: src/api/upload.ts:45 — `// TODO: validation`
 Action: Complete validation
-
-REQ-2: {requirement}
-Status: MISSING
-Action: Create src/services/storage.ts
 ```
 
 ## Rules