crawlio-browser 1.6.2 → 1.6.3

package/dist/mcp-server/{chunk-T4GKS2PG.js → chunk-KHZBKDGF.js}

@@ -1,7 +1,7 @@
 // src/shared/constants.ts
 import { homedir } from "os";
 import { join } from "path";
-var PKG_VERSION = "1.6.2";
+var PKG_VERSION = "1.6.3";
 var WS_PORT = 9333;
 var WS_PORT_MAX = 9342;
 var WS_HOST = "127.0.0.1";

package/dist/mcp-server/index.js

@@ -9,7 +9,7 @@ import {
   WS_PORT_MAX,
   WS_RECONNECT_GRACE,
   WS_STALE_THRESHOLD
-} from "./chunk-T4GKS2PG.js";
+} from "./chunk-KHZBKDGF.js";
 
 // src/mcp-server/index.ts
 import { randomBytes as randomBytes3 } from "crypto";
@@ -8758,7 +8758,7 @@ function getMaxOutput() {
 process.title = "Crawlio Agent";
 var initMode = process.argv.includes("init") || process.argv.includes("--setup") || process.argv.includes("setup");
 if (initMode) {
-  const { runInit } = await import("./init-PFND5ZFY.js");
+  const { runInit } = await import("./init-3KNW32I6.js");
   await runInit(process.argv.slice(2));
   process.exit(0);
 }

package/dist/mcp-server/{init-PFND5ZFY.js → init-3KNW32I6.js}

@@ -1,6 +1,6 @@
 import {
   PKG_VERSION
-} from "./chunk-T4GKS2PG.js";
+} from "./chunk-KHZBKDGF.js";
 
 // src/mcp-server/init.ts
 import { execFileSync, spawn } from "child_process";
@@ -615,14 +615,7 @@ async function startDetachedServer(serverPath, nodePath) {
 }
 var BUNDLED_SKILLS = [
   { name: "browser-automation", files: ["SKILL.md", "reference.md"] },
-  { name: "web-research", files: ["SKILL.md"] },
-  { name: "investigate", files: ["SKILL.md"] },
-  { name: "extract", files: ["SKILL.md"] },
-  { name: "compare", files: ["SKILL.md"] },
-  { name: "clone", files: ["SKILL.md"] },
-  { name: "dossier", files: ["SKILL.md"] },
-  { name: "monitor", files: ["SKILL.md"] },
-  { name: "test", files: ["SKILL.md"] }
+  { name: "web-research", files: ["SKILL.md"] }
 ];
 function installBrowserSkill(dryRun) {
   console.log("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crawlio-browser",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "MCP server with 114 CDP-backed tools for browser automation — screenshots, DOM, network capture, framework detection, cookies, storage, session recording, structured data extraction, tracking analysis, SEO auditing, technographic fingerprinting, performance metrics via Chrome",
   "type": "module",
   "main": "dist/mcp-server/index.js",
@@ -10,7 +10,8 @@
   "files": [
     "bin/crawlio-browser.js",
     "dist/mcp-server/",
-    "skills/",
+    "skills/browser-automation/",
+    "skills/web-research/",
     "README.md"
   ],
   "scripts": {

package/skills/web-research/SKILL.md

@@ -29,7 +29,7 @@ await connect_tab({ url: "https://example.com" })
 
 // Extract everything in one call
 const page = await smart.extractPage()
-// Returns: { capture, performance, security, fonts, meta }
+// Returns: { capture, performance, security, fonts, meta, accessibility, mobileReadiness, gaps }
 ```
 
 For visual evidence, add `smart.scrollCapture()`:
@@ -63,12 +63,34 @@ const record = {
   security: page.security,             // TLS, cert, mixed content
   fonts: page.fonts,                   // declared + computed
   meta: page.meta,                     // OG tags, structured data, headings, nav links
+  accessibility: page.accessibility,   // node count, landmarks, images without alt, heading structure
+  mobileReadiness: page.mobileReadiness, // viewport meta, media queries, overflow
+  gaps: page.gaps,                     // what data failed — check before trusting null fields
 }
 ```
 
 ### Phase 3: Analyze
 
-Compare against a fixed rubric. Produce structured findings, not prose.
+Compare against a fixed rubric. Produce validated findings using `smart.finding()`:
+
+```js
+smart.finding({
+  claim: "Site loads 47 network requests with 2 failures",
+  evidence: ["network.total: 47", "network.failed: 2"],
+  sourceUrl: page.capture.url,
+  confidence: "high",
+  method: "extractPage",
+  dimension: "performance"  // auto-caps confidence if perf data had gaps
+})
+
+// Retrieve all findings from this session
+const allFindings = smart.findings()
+
+// Reset for next research task
+smart.clearFindings()
+```
+
+If `extractPage()` reported gaps (e.g., performance metrics failed), findings with matching `dimension` get confidence automatically capped one level (high → medium, medium → low). Check `page.gaps` to understand what data is missing.
 
 ## Use Existing Tools — Not Manual Equivalents
 
@@ -128,9 +150,12 @@ When comparing sites, evaluate these dimensions:
 
 ### Prefer:
 
-- **One `extractPage()` per page** — it runs capture_page + perf + security + fonts + meta in parallel
-- **`comparePages()` for 2-site comparisons** — handles navigation + extraction for both sites
-- **Structured findings** — each with URL, extracted data, and confidence level
+- **One `extractPage()` per page** — it runs 7 ops in parallel (capture + perf + security + fonts + meta + accessibility + mobile-readiness) with typed gaps
+- **`comparePages()` for 2-site comparisons** — returns `{ siteA, siteB, scaffold }` with 11 fixed comparison dimensions
+- **`smart.finding()` for validated findings** — enforces claim + evidence + sourceUrl + confidence + method schema
+- **No `smart.screenshot()`** — it doesn't exist. Use `bridge.send({ type: 'take_screenshot' })` or `smart.scrollCapture()`
+- **No `smart.snapshot({ compact: true })`** — compact option doesn't exist. Use `smart.snapshot()` or `{ interactive: true }`
+- **No `location.href = "..."` for navigation** — use `smart.navigate(url)`. Direct assignment breaks CDP
 
 ## Example: Competitive Audit
 

package/skills/clone/SKILL.md

@@ -1,101 +0,0 @@
----
-name: clone
-description: "Clone a site — capture design tokens, component tree, assets, and compile a replayable skill"
-allowed-tools: Agent, Read, Write, Bash, Glob, Grep
-argument-hint: <url>
----
-
-# Clone Investigation
-
-You are running a **clone** investigation. Your goal is to capture the design system, component structure, and assets of a target URL, then compile the investigation into a replayable skill.
-
-## Loop Definition
-
-Read `loops/clone.json` to understand the phase sequence. The clone loop has 5 phases:
-
-1. **crawl** — Spawn `crawlio-crawler` to capture the target URL. Record the `EVIDENCE_ID`.
-2. **analyze** — Spawn `crawlio-analyzer` with the crawl evidence ID. Identifies framework, rendering mode, component patterns.
-3. **extract-design** — Spawn `crawlio-extractor` with the crawl evidence ID and `what: "design"`. Extracts design tokens (colors, typography, spacing, breakpoints).
-4. **compile** (optional) — Spawn `crawlio-recorder` to compile the investigation into a replayable SKILL.md.
-5. **synthesize** — Spawn `crawlio-synthesizer` with all phase evidence to produce the final `CloneBlueprint`.
-
-## Execution
-
-1. Read `loops/clone.json` to confirm phase order.
-2. Parse the user's argument: `<url>`.
-3. Spawn `crawlio-crawler` to capture the page:
-   ```
-   Crawl <url> and write PageEvidence to .crawlio/evidence/.
-   ```
-   Record `EVIDENCE_ID=<crawlId>`.
-
-4. Spawn `crawlio-analyzer` with the crawl evidence:
-   ```
-   Read PageEvidence from .crawlio/evidence/<crawlId>.json.
-   Analyze framework, rendering mode, and component patterns.
-   Write FrameworkEvidence to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<analyzeId>`.
-
-5. Spawn `crawlio-extractor` for design token extraction:
-   ```
-   Read PageEvidence from .crawlio/evidence/<crawlId>.json.
-   Extract "design" data — colors, typography, spacing, breakpoints.
-   Write DesignTokens evidence to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<designId>`.
-
-6. Spawn `crawlio-recorder` to compile the investigation:
-   ```
-   Read evidence chain: <crawlId>, <analyzeId>, <designId>.
-   Compile into a replayable SKILL.md.
-   ```
-   Record the skill path.
-
-7. Spawn `crawlio-synthesizer` to produce the CloneBlueprint:
-   ```
-   Read all evidence: <crawlId>, <analyzeId>, <designId>.
-   Produce a CloneBlueprint with design tokens, component tree, assets, and compiled skill path.
-   Write to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<blueprintId>`.
-
-8. Read the CloneBlueprint evidence and summarize results for the user.
-
-## Output Format
-
-```
-## Clone: <url>
-
-### Design Tokens
-- Colors: [count] tokens extracted
-- Typography: [count] font stacks
-- Spacing: [count] spacing values
-- Breakpoints: [count] responsive breakpoints
-
-### Component Tree
-- Root: <root component>
-- Components: [count] total
-- Types: [breakdown by type]
-
-### Assets
-- [count] total assets ([breakdown by type])
-
-### Compiled Skill
-- Path: <skill path or "not compiled">
-
-### Evidence Chain
-- Crawler: <crawlId> (quality: ...)
-- Analyzer: <analyzeId> (quality: ...)
-- Design: <designId> (quality: ...)
-- Blueprint: <blueprintId> (quality: ...)
-
-### Coverage Gaps
-- [Any gaps from the investigation]
-
-### Confidence
-- Overall: high/medium/low
-```

package/skills/compare/SKILL.md

@@ -1,102 +0,0 @@
----
-name: compare
-description: "Compare two URLs side-by-side across 10 typed dimensions"
-allowed-tools: Agent, Read, Write, Bash, Glob, Grep
-argument-hint: <urlA> <urlB>
----
-
-# Compare Investigation
-
-You are running a **compare** investigation. Your goal is to capture two URLs, analyze their frameworks, and produce a `ComparisonReport` with typed findings across 10 dimensions.
-
-## The 10 Dimensions
-
-| # | Dimension | What It Measures |
-|---|-----------|------------------|
-| 1 | Framework | Technology stack, versions, SSR mode |
-| 2 | Performance | Web Vitals, load metrics, bottlenecks |
-| 3 | Security | TLS, headers, cookies, mixed content |
-| 4 | SEO | Meta tags, structured data, heading hierarchy |
-| 5 | Accessibility | ARIA, semantic HTML, keyboard nav, contrast |
-| 6 | Error Surface | Console errors, network failures, JS exceptions |
-| 7 | Third-Party Load | External scripts, tracking, CDN, SDK risk |
-| 8 | Architecture | SSR vs CSR, routing, data fetching, state management |
-| 9 | Content Delivery | Caching, compression, asset optimization |
-| 10 | Mobile Readiness | Viewport, responsive signals, device emulation |
-
-## Loop Definition
-
-Read `loops/compare.json` to understand the phase sequence. The compare loop has 6 phases:
-
-1. **crawl-a** — Spawn `crawlio-crawler` to capture URL A. Record the `EVIDENCE_ID`.
-2. **crawl-b** — Spawn `crawlio-crawler` to capture URL B. Record the `EVIDENCE_ID`.
-3. **analyze-a** (optional) — Spawn `crawlio-analyzer` with crawl-a evidence to identify frameworks.
-4. **analyze-b** (optional) — Spawn `crawlio-analyzer` with crawl-b evidence to identify frameworks.
-5. **compare** — Spawn `crawlio-comparator` with all evidence IDs. It reads both URLs' evidence, compares across 10 dimensions, and writes an `EvidenceEnvelope<ComparisonReport>`.
-6. **synthesize** (optional) — Spawn `crawlio-synthesizer` if a full blueprint is useful.
-
-## Execution
-
-1. Read `loops/compare.json` to confirm phase order.
-2. Parse the user's arguments: `<urlA>` and `<urlB>`.
-3. Spawn `crawlio-crawler` for URL A:
-   ```
-   Crawl <urlA> and write PageEvidence to .crawlio/evidence/.
-   ```
-   Record `EVIDENCE_ID=<crawlAId>`.
-
-4. Spawn `crawlio-crawler` for URL B:
-   ```
-   Crawl <urlB> and write PageEvidence to .crawlio/evidence/.
-   ```
-   Record `EVIDENCE_ID=<crawlBId>`.
-
-5. Spawn `crawlio-analyzer` for URL A (optional):
-   ```
-   Analyze page evidence <crawlAId> for <urlA>. Read from .crawlio/evidence/. Write FrameworkEvidence to .crawlio/evidence/.
-   ```
-   Record `EVIDENCE_ID=<analyzeAId>`.
-
-6. Spawn `crawlio-analyzer` for URL B (optional):
-   ```
-   Analyze page evidence <crawlBId> for <urlB>. Read from .crawlio/evidence/. Write FrameworkEvidence to .crawlio/evidence/.
-   ```
-   Record `EVIDENCE_ID=<analyzeBId>`.
-
-7. Spawn `crawlio-comparator` with all evidence:
-   ```
-   Compare URL A (<urlA>) against URL B (<urlB>).
-   Evidence IDs — crawl-a: <crawlAId>, crawl-b: <crawlBId>, analyze-a: <analyzeAId>, analyze-b: <analyzeBId>.
-   Read all evidence from .crawlio/evidence/. Write EvidenceEnvelope<ComparisonReport> to .crawlio/evidence/.
-   ```
-   Record `EVIDENCE_ID=<compareId>`.
-
-8. Read the ComparisonReport evidence and summarize for the user.
-
-## Output Format
-
-```
-## Compare: <urlA> vs <urlB>
-
-### Winner: <A|B|Tie|Inconclusive>
-<winnerReason>
-
-### Dimension Results
-| Dimension | Verdict | Confidence | Key Differences |
-|-----------|---------|------------|-----------------|
-| [per-dimension rows] |
-
-### Summary
-- Total differences: N
-- Critical differences: N
-
-### Evidence Chain
-- Crawl A: <crawlAId> (quality: ...)
-- Crawl B: <crawlBId> (quality: ...)
-- Analyze A: <analyzeAId> (quality: ...)
-- Analyze B: <analyzeBId> (quality: ...)
-- Compare: <compareId> (quality: ...)
-
-### Confidence
-- Overall: high/medium/low
-```

package/skills/dossier/SKILL.md

@@ -1,146 +0,0 @@
----
-name: dossier
-description: "Competitive dossier — orchestrate investigate + test + extract into a unified analysis"
-allowed-tools: Agent, Read, Write, Bash, Glob, Grep
-argument-hint: <url>
----
-
-# Dossier Investigation
-
-You are running a **compose** investigation. Your goal is to orchestrate multiple investigation families (investigate, test, extract) into a unified `CompetitiveDossier` for a target URL.
-
-## Loop Definition
-
-Read `loops/compose.json` to understand the phase sequence. The compose loop has 8 phases:
-
-1. **crawl** — Spawn `crawlio-crawler` to capture the target URL. Record the `EVIDENCE_ID`.
-2. **analyze** — Spawn `crawlio-analyzer` with the crawl evidence ID. Identifies framework and rendering mode.
-3. **network** (optional) — Spawn `crawlio-network` with the crawl evidence ID. Discovers API endpoints, auth, third-party services.
-4. **synthesize** — Spawn `crawlio-synthesizer` with all evidence to produce a `TechBlueprint`.
-5. **audit** (optional) — Spawn `crawlio-auditor` with the crawl evidence ID. Runs accessibility, performance, security, SEO, and best-practices audits.
-6. **extract-design** (optional) — Spawn `crawlio-extractor` to extract design tokens.
-7. **extract-api** (optional) — Spawn `crawlio-extractor` to extract API surface data.
-8. **compile-dossier** — Spawn `crawlio-composer` with all accumulated evidence IDs. Produces the final `CompetitiveDossier`.
-
-## Execution
-
-1. Read `loops/compose.json` to confirm phase order.
-2. Parse the user's argument: `<url>`.
-3. Spawn `crawlio-crawler` to capture the page:
-   ```
-   Crawl <url> and write PageEvidence to .crawlio/evidence/.
-   ```
-   Record `EVIDENCE_ID=<crawlId>`.
-
-4. Spawn `crawlio-analyzer` with the crawl evidence:
-   ```
-   Read PageEvidence from .crawlio/evidence/<crawlId>.json.
-   Analyze framework, rendering mode, and component patterns.
-   Write FrameworkEvidence to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<analyzeId>`.
-
-5. Spawn `crawlio-network` to discover API surface (optional):
-   ```
-   Read PageEvidence from .crawlio/evidence/<crawlId>.json.
-   Discover API endpoints, authentication patterns, rate limiting, third-party integrations.
-   Write APIMap to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<networkId>`.
-
-6. Spawn `crawlio-synthesizer` to produce a TechBlueprint:
-   ```
-   Read all evidence: <crawlId>, <analyzeId>, <networkId>.
-   Produce a TechBlueprint with typed findings.
-   Write to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<blueprintId>`.
-
-7. Spawn `crawlio-auditor` to run audits (optional):
-   ```
-   Read PageEvidence from .crawlio/evidence/<crawlId>.json.
-   Run accessibility, performance, security, SEO, and best-practices audits.
-   Write TestSuite to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<auditId>`.
-
-8. Spawn `crawlio-extractor` to extract design tokens (optional):
-   ```
-   Read PageEvidence from .crawlio/evidence/<crawlId>.json.
-   Extract "design" data — colors, typography, spacing, breakpoints.
-   Write DesignTokens to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<designId>`.
-
-9. Spawn `crawlio-extractor` to extract API surface (optional):
-   ```
-   Read PageEvidence from .crawlio/evidence/<crawlId>.json.
-   Extract "api" data — endpoints, auth, third-party services.
-   Write APIMap to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<apiExtractId>`.
-
-10. Spawn `crawlio-composer` with all accumulated evidence:
-    ```
-    Read all evidence from prior phases. Evidence IDs:
-    - crawl: <crawlId>
-    - analyze: <analyzeId>
-    - network: <networkId> (if available)
-    - blueprint: <blueprintId>
-    - audit: <auditId> (if available)
-    - design: <designId> (if available)
-    - api-extract: <apiExtractId> (if available)
-    Compile a CompetitiveDossier with strengths, weaknesses, opportunities, and recommendations.
-    Write to .crawlio/evidence/.
-    Target URL: <url>
-    ```
-    Record `EVIDENCE_ID=<dossierId>`.
-
-11. Read the CompetitiveDossier evidence and summarize for the user.
-
-## Output Format
-
-```
-## Dossier: <url>
-
-### Executive Summary
-<executiveSummary>
-
-### Strengths
-- [bullet list of strengths with confidence levels]
-
-### Weaknesses
-- [bullet list of weaknesses with confidence levels]
-
-### Opportunities
-- [bullet list of opportunities]
-
-### Recommendations
-| Priority | Category | Action |
-|----------|----------|--------|
-| [per-recommendation rows, sorted by priority] |
-
-### Families Executed
-- [list of families that contributed evidence]
-
-### Evidence Chain
-- Crawler: <crawlId> (quality: ...)
-- Analyzer: <analyzeId> (quality: ...)
-- Network: <networkId> (quality: ...)
-- Blueprint: <blueprintId> (quality: ...)
-- Auditor: <auditId> (quality: ...)
-- Design: <designId> (quality: ...)
-- Dossier: <dossierId> (quality: ...)
-
-### Coverage Gaps
-- [Aggregated gaps from all phases]
-
-### Confidence
-- Overall: high/medium/low
-```

package/skills/extract/SKILL.md

@@ -1,67 +0,0 @@
----
-name: extract
-description: "Extract structured data from a URL — tables, API surface, design tokens, auth flows"
-allowed-tools: Agent, Read, Write, Bash, Glob, Grep
-argument-hint: <url> <what>
----
-
-# Extract Investigation
-
-You are running an **extract** investigation. Your goal is to capture a page and extract specific structured data from it based on the `what` parameter.
-
-## Extraction Targets
-
-| `what` | Evidence Type | What It Extracts |
-|--------|---------------|------------------|
-| `tables` | `TableExtraction` | Tabular data from DOM patterns |
-| `data` | `DataExtraction` | All structured data (tables + JSON-LD) |
-| `api` | `APIMap` | API endpoints, auth, third-party services |
-| `design` | `DesignTokens` | Colors, typography, spacing, breakpoints |
-| `auth` | `AuthFlow` | Login flows, token storage, CSRF, OAuth |
-
-## Loop Definition
-
-Read `loops/extract.json` to understand the phase sequence. The extract loop has 3 phases:
-
-1. **crawl** — Spawn `crawlio-crawler` to capture the target URL. Record the `EVIDENCE_ID`.
-2. **extract** — Spawn `crawlio-extractor` with the crawl evidence ID and the `what` parameter. It reads the `EvidenceEnvelope<PageEvidence>`, runs the appropriate extraction strategy, and writes a typed evidence envelope.
-3. **synthesize** (optional) — Spawn `crawlio-synthesizer` if a full blueprint is useful.
-
-## Execution
-
-1. Read `loops/extract.json` to confirm phase order.
-2. Parse the user's arguments: `<url>` and `<what>` (one of: tables, data, api, design, auth).
-3. Spawn `crawlio-crawler` to capture the page:
-   ```
-   Crawl <url> and write PageEvidence to .crawlio/evidence/.
-   ```
-   Record `EVIDENCE_ID=<crawlId>`.
-
-4. Spawn `crawlio-extractor` with the crawl evidence and extraction target:
-   ```
-   Read PageEvidence from .crawlio/evidence/<crawlId>.json.
-   Extract "<what>" data and write the appropriate typed evidence to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<extractId>`.
-
-5. Read the extraction evidence and summarize results for the user.
-
-## Output Format
-
-```
-## Extract: <what> from <url>
-
-### Results
-- [Key findings from the extraction]
-
-### Evidence Chain
-- Crawler: <crawlId> (quality: ...)
-- Extractor: <extractId> (quality: ...)
-
-### Coverage Gaps
-- [Any gaps from extraction]
-
-### Confidence
-- Overall: high/medium/low
-```

package/skills/investigate/SKILL.md

@@ -1,97 +0,0 @@
----
-name: investigate
-description: "Investigate a website — crawl, analyze frameworks, discover APIs, synthesize findings"
-allowed-tools: Agent, Read, Write, Bash, Glob, Grep
-argument-hint: <url>
----
-
-# Investigate
-
-You are running an **investigate** investigation. Your goal is to crawl a target URL, analyze its framework and architecture, discover API endpoints, and synthesize all findings into a `TechBlueprint`.
-
-## Loop Definition
-
-Read `loops/investigate.json` to understand the phase sequence. The investigate loop has 5 phases:
-
-1. **crawl** — Spawn `crawlio-crawler` to capture the target URL. Record the `EVIDENCE_ID`.
-2. **analyze** — Spawn `crawlio-analyzer` with the crawl evidence ID. Identifies framework, rendering mode, component patterns.
-3. **network** — Spawn `crawlio-network` with the crawl evidence ID. Discovers API endpoints, authentication patterns, rate limiting, third-party integrations.
-4. **synthesize** — Spawn `crawlio-synthesizer` with all phase evidence to produce the final `TechBlueprint`.
-5. **record** — Spawn `crawlio-recorder` to compile the investigation into a replayable SKILL.md.
-
-## Execution
-
-1. Read `loops/investigate.json` to confirm phase order.
-2. Parse the user's argument: `<url>`.
-3. Spawn `crawlio-crawler` to capture the page:
-   ```
-   Crawl <url> and write PageEvidence to .crawlio/evidence/.
-   ```
-   Record `EVIDENCE_ID=<crawlId>`.
-
-4. Spawn `crawlio-analyzer` with the crawl evidence:
-   ```
-   Read PageEvidence from .crawlio/evidence/<crawlId>.json.
-   Analyze framework, rendering mode, and component patterns.
-   Write FrameworkEvidence to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<analyzeId>`.
-
-5. Spawn `crawlio-network` to discover APIs:
-   ```
-   Read PageEvidence from .crawlio/evidence/<crawlId>.json.
-   Discover API endpoints, authentication patterns, rate limiting, third-party integrations.
-   Write APIMap to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<networkId>`.
-
-6. Spawn `crawlio-synthesizer` to produce the TechBlueprint:
-   ```
-   Read all evidence: <crawlId>, <analyzeId>, <networkId>.
-   Produce a TechBlueprint with typed findings, confidence levels, and gap tracking.
-   Write to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<blueprintId>`.
-
-7. Spawn `crawlio-recorder` to compile the investigation:
-   ```
-   Read evidence chain: <crawlId>, <analyzeId>, <networkId>, <blueprintId>.
-   Compile into a replayable SKILL.md.
-   ```
-   Record the skill path.
-
-8. Read the TechBlueprint evidence and summarize results for the user.
-
-## Output Format
-
-```
-## Investigate: <url>
-
-### Framework
-- Name: <framework>
-- Version: <version>
-- Rendering: <SSR|CSR|SSG|ISR>
-
-### API Surface
-- Endpoints: [count] discovered
-- Auth: <pattern>
-- Third-party: [count] integrations
-
-### Architecture
-- [Key architectural findings]
-
-### Evidence Chain
-- Crawler: <crawlId> (quality: ...)
-- Analyzer: <analyzeId> (quality: ...)
-- Network: <networkId> (quality: ...)
-- Blueprint: <blueprintId> (quality: ...)
-
-### Coverage Gaps
-- [Any gaps from the investigation]
-
-### Confidence
-- Overall: high/medium/low
-```

package/skills/monitor/SKILL.md

@@ -1,64 +0,0 @@
----
-name: monitor
-description: "Monitor a URL for changes — baseline capture, re-capture, diff report"
-allowed-tools: Agent, Read, Write, Bash, Glob, Grep
-argument-hint: <url>
----
-
-# Monitor Investigation
-
-You are running a **monitor** investigation. Your goal is to capture a baseline snapshot of the target URL, re-capture it, and produce a `DiffReport` showing what changed between the two captures.
-
-## Loop Definition
-
-Read `loops/monitor.json` to understand the phase sequence. The monitor loop has 3 phases:
-
-1. **baseline** — Spawn `crawlio-crawler` to capture the target URL. Record the `EVIDENCE_ID`.
-2. **recapture** — Spawn `crawlio-crawler` again with the same URL. Record the second `EVIDENCE_ID`.
-3. **diff** — Spawn `crawlio-differ` with both evidence IDs. It reads both `EvidenceEnvelope<PageEvidence>` files, compares them field by field across 10 dimensions, and writes an `EvidenceEnvelope<DiffReport>`.
-
-## Execution
-
-1. Read `loops/monitor.json` to confirm phase order.
-2. Spawn `crawlio-crawler` for the baseline capture:
-   ```
-   Crawl <url> and write PageEvidence to .crawlio/evidence/.
-   ```
-   Record `EVIDENCE_ID=<baselineId>`.
-
-3. Spawn `crawlio-crawler` for the recapture:
-   ```
-   Crawl <url> and write PageEvidence to .crawlio/evidence/.
-   ```
-   Record `EVIDENCE_ID=<currentId>`.
-
-4. Spawn `crawlio-differ` with both evidence IDs:
-   ```
-   Compare baseline evidence <baselineId> against current evidence <currentId> for <url>.
-   Read both from .crawlio/evidence/. Write EvidenceEnvelope<DiffReport> to .crawlio/evidence/.
-   ```
-   Record `EVIDENCE_ID=<diffId>`.
-
-5. Read the DiffReport evidence and summarize changes for the user.
-
-## Output Format
-
-```
-## Monitor: <url>
-
-### Changes Detected
-- [List of DiffChange entries grouped by dimension]
-
-### Summary
-- Total changes: N
-- Breaking changes: N
-- Dimensions affected: [list]
-
-### Evidence Chain
-- Baseline: <baselineId> (quality: ...)
-- Current: <currentId> (quality: ...)
-- Diff: <diffId> (quality: ...)
-
-### Confidence
-- Overall: high/medium/low
-```

package/skills/test/SKILL.md

@@ -1,101 +0,0 @@
----
-name: test
-description: "Automated testing — accessibility, performance, security, SEO, and best-practices audits with testable flow discovery"
-allowed-tools: Agent, Read, Write, Bash, Glob, Grep
-argument-hint: <url>
----
-
-# Test Investigation
-
-You are running a **test** investigation. Your goal is to audit a target URL across accessibility, performance, security, SEO, and best-practices categories, discover testable user flows, and produce a `TestSuite` evidence report.
-
-## Loop Definition
-
-Read `loops/test.json` to understand the phase sequence. The test loop has 5 phases:
-
-1. **crawl** — Spawn `crawlio-crawler` to capture the target URL. Record the `EVIDENCE_ID`.
-2. **analyze** — Spawn `crawlio-analyzer` with the crawl evidence ID. Identifies framework and rendering mode to inform test strategy.
-3. **audit** — Spawn `crawlio-auditor` with the crawl evidence ID. Runs accessibility, performance, security, SEO, and best-practices checks.
-4. **discover-flows** (optional) — Spawn `crawlio-auditor` with the crawl evidence ID and flow discovery focus. Discovers testable user flows from navigation/forms.
-5. **synthesize** — Spawn `crawlio-synthesizer` with all phase evidence to produce the final `TestSuite`.
-
-## Execution
-
-1. Read `loops/test.json` to confirm phase order.
-2. Parse the user's argument: `<url>`.
-3. Spawn `crawlio-crawler` to capture the page:
-   ```
-   Crawl <url> and write PageEvidence to .crawlio/evidence/.
-   ```
-   Record `EVIDENCE_ID=<crawlId>`.
-
-4. Spawn `crawlio-analyzer` with the crawl evidence:
-   ```
-   Read PageEvidence from .crawlio/evidence/<crawlId>.json.
-   Analyze framework, rendering mode, and component patterns.
-   Write FrameworkEvidence to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<analyzeId>`.
-
-5. Spawn `crawlio-auditor` to run audits:
-   ```
-   Read PageEvidence from .crawlio/evidence/<crawlId>.json.
-   Run accessibility, performance, security, SEO, and best-practices audits.
-   Discover testable user flows from navigation and forms.
-   Write TestSuite evidence to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<auditId>`.
-
-6. Spawn `crawlio-synthesizer` to produce the final TestSuite:
-   ```
-   Read all evidence: <crawlId>, <analyzeId>, <auditId>.
-   Produce a TestSuite with audit results, discovered flows, and overall score.
-   Write to .crawlio/evidence/.
-   Target URL: <url>
-   ```
-   Record `EVIDENCE_ID=<suiteId>`.
-
-7. Read the TestSuite evidence and summarize results for the user.
-
-## Output Format
-
-```
-## Test: <url>
-
-### Summary
-- Score: [0-100]/100
-- Tests: [passed] passed, [failed] failed, [warnings] warnings
-- Flows: [count] testable flows discovered
-
-### Accessibility
-- [audit results with pass/fail/warning status]
-
-### Performance
-- [audit results with scores]
-
-### Security
-- [audit results with pass/fail status]
-
-### SEO
-- [audit results]
-
-### Best Practices
-- [audit results]
-
-### Discovered Flows
-- [list of testable flows with steps]
-
-### Evidence Chain
-- Crawler: <crawlId> (quality: ...)
-- Analyzer: <analyzeId> (quality: ...)
-- Auditor: <auditId> (quality: ...)
-- Suite: <suiteId> (quality: ...)
-
-### Coverage Gaps
-- [Any gaps from the investigation]
-
-### Confidence
-- Overall: high/medium/low
-```