@questpie/probe 0.1.2 → 0.1.3

package/dist/{browser-DoCXU5Bs.js → browser-C0KoBYfo.js}

@@ -2,9 +2,13 @@ import { parseDuration } from "./duration-DUrbfMLK.js";
 import { loadProbeConfig, resolveBaseUrl } from "./config-BUEMgFYN.js";
 import { AgentBrowserDriver } from "./agent-browser-Cxuu-Zz0.js";
 import { error, info, json, log, success } from "./output-CHUjdVDf.js";
+import { recordAction } from "./recorder-FojdM3gr.js";
 import { defineCommand } from "citty";
 
 //#region src/commands/browser.ts
+function record(command$1, ...args) {
+	recordAction(`browser ${command$1}`, args);
+}
 async function getDriver(args) {
 	const config = await loadProbeConfig();
 	const driverName = args.driver ?? config.browser?.driver ?? "agent-browser";
@@ -45,6 +49,7 @@ const open = defineCommand({
 	async run({ args }) {
 		const driver = await getDriver(args);
 		await driver.open(args.url);
+		record("open", args.url);
 		success(`Opened ${args.url}`);
 	}
 });
@@ -61,6 +66,7 @@ const back = defineCommand({
 	async run({ args }) {
 		const driver = await getDriver(args);
 		await driver.back();
+		record("back");
 		success("Navigated back");
 	}
 });
@@ -77,6 +83,7 @@ const forward = defineCommand({
 	async run({ args }) {
 		const driver = await getDriver(args);
 		await driver.forward();
+		record("forward");
 		success("Navigated forward");
 	}
 });
@@ -93,6 +100,7 @@ const reload = defineCommand({
 	async run({ args }) {
 		const driver = await getDriver(args);
 		await driver.reload();
+		record("reload");
 		success("Reloaded");
 	}
 });
@@ -206,6 +214,7 @@ const click = defineCommand({
 	async run({ args }) {
 		const driver = await getDriver(args);
 		await driver.click(args.ref);
+		record("click", args.ref);
 		success(`Clicked ${args.ref}`);
 	}
 });
@@ -226,6 +235,7 @@ const dblclick = defineCommand({
 	async run({ args }) {
 		const driver = await getDriver(args);
 		await driver.dblclick(args.ref);
+		record("dblclick", args.ref);
 		success(`Double-clicked ${args.ref}`);
 	}
 });
@@ -252,6 +262,7 @@ const fill = defineCommand({
 	async run({ args }) {
 		const driver = await getDriver(args);
 		await driver.fill(args.ref, args.value);
+		record("fill", args.ref, args.value);
 		success(`Filled ${args.ref}`);
 	}
 });
@@ -276,6 +287,7 @@ const selectCmd = defineCommand({
 	async run({ args }) {
 		const driver = await getDriver(args);
 		await driver.select(args.ref, args.value);
+		record("select", args.ref, args.value);
 		success(`Selected "${args.value}" in ${args.ref}`);
 	}
 });
@@ -296,6 +308,7 @@ const checkCmd = defineCommand({
 	async run({ args }) {
 		const driver = await getDriver(args);
 		await driver.check(args.ref);
+		record("check", args.ref);
 		success(`Checked ${args.ref}`);
 	}
 });
@@ -316,6 +329,7 @@ const uncheckCmd = defineCommand({
 	async run({ args }) {
 		const driver = await getDriver(args);
 		await driver.uncheck(args.ref);
+		record("uncheck", args.ref);
 		success(`Unchecked ${args.ref}`);
 	}
 });
@@ -337,6 +351,7 @@ const press = defineCommand({
 	async run({ args }) {
 		const driver = await getDriver(args);
 		await driver.press(args.key);
+		record("press", args.key);
 		success(`Pressed ${args.key}`);
 	}
 });
@@ -358,6 +373,7 @@ const typeCmd = defineCommand({
 	async run({ args }) {
 		const driver = await getDriver(args);
 		await driver.type(args.text);
+		record("type", args.text);
 		success("Typed text");
 	}
 });
@@ -487,6 +503,7 @@ const screenshot = defineCommand({
 			full: args.full,
 			selector: args.selector
 		});
+		record("screenshot", path);
 		success(`Screenshot saved: ${path}`);
 	}
 });

package/dist/{check-1Y6cPMkN.js → check-DzHesF9c.js}

@@ -1,8 +1,8 @@
 import "./duration-DUrbfMLK.js";
 import { loadProbeConfig, resolveBaseUrl } from "./config-BUEMgFYN.js";
 import { error, info, success, warn } from "./output-CHUjdVDf.js";
-import "./state-DRTSIt_r.js";
-import { listProcesses } from "./process-manager-CITbaM9X.js";
+import "./state-B0f4kwdz.js";
+import { listProcesses } from "./process-manager-CUmXxN1Y.js";
 import { defineCommand } from "citty";
 import { ofetch } from "ofetch";
 

package/dist/cli.js

@@ -4,6 +4,23 @@ import { defineCommand, runMain, showUsage } from "citty";
 import { consola } from "consola";
 
 //#region src/cli.ts
+const subCommandNames = new Set([
+	"start",
+	"stop",
+	"restart",
+	"ps",
+	"health",
+	"compose",
+	"logs",
+	"http",
+	"check",
+	"browser",
+	"record",
+	"replay",
+	"recordings",
+	"assert",
+	"init"
+]);
 const main = defineCommand({
 	meta: {
 		name: "qprobe",
@@ -11,23 +28,25 @@ const main = defineCommand({
 		description: "Dev testing CLI for AI coding agents"
 	},
 	subCommands: {
-		start: () => import("./start-BJnzhZp9.js").then((m) => m.default),
-		stop: () => import("./stop-C0xDWnnB.js").then((m) => m.default),
-		restart: () => import("./restart-CEzd2Mgn.js").then((m) => m.default),
-		ps: () => import("./ps-UFZx0jy0.js").then((m) => m.default),
-		health: () => import("./health-B36ufFzJ.js").then((m) => m.default),
-		compose: () => import("./compose-1CYahcRa.js").then((m) => m.default),
-		logs: () => import("./logs-BIt5sCky.js").then((m) => m.default),
-		http: () => import("./http-BZouO1Cj.js").then((m) => m.default),
-		check: () => import("./check-1Y6cPMkN.js").then((m) => m.default),
-		browser: () => import("./browser-DoCXU5Bs.js").then((m) => m.default),
-		record: () => import("./record-C4SmoPsT.js").then((m) => m.default),
-		replay: () => import("./replay-Dg9PHNrg.js").then((m) => m.default),
-		recordings: () => import("./recordings-Cb31alos.js").then((m) => m.default),
+		start: () => import("./start-DAj1ldz_.js").then((m) => m.default),
+		stop: () => import("./stop-Y3DscZCW.js").then((m) => m.default),
+		restart: () => import("./restart-CCnfVg7M.js").then((m) => m.default),
+		ps: () => import("./ps-E1hgvd2u.js").then((m) => m.default),
+		health: () => import("./health-Derc4CP4.js").then((m) => m.default),
+		compose: () => import("./compose-BuBOYqop.js").then((m) => m.default),
+		logs: () => import("./logs-LWtXR5o6.js").then((m) => m.default),
+		http: () => import("./http-7baasp3-.js").then((m) => m.default),
+		check: () => import("./check-DzHesF9c.js").then((m) => m.default),
+		browser: () => import("./browser-C0KoBYfo.js").then((m) => m.default),
+		record: () => import("./record-DE4BA6jl.js").then((m) => m.default),
+		replay: () => import("./replay-DTB0C9DC.js").then((m) => m.default),
+		recordings: () => import("./recordings-CmVHyt3A.js").then((m) => m.default),
 		assert: () => import("./assert-BLP5_JwC.js").then((m) => m.default),
-		init: () => import("./init-BjTfn_-A.js").then((m) => m.default)
+		init: () => import("./init-B91b6oc2.js").then((m) => m.default)
 	},
-	async run({ cmd }) {
+	async run({ cmd, rawArgs }) {
+		const firstArg = rawArgs[0];
+		if (firstArg && subCommandNames.has(firstArg)) return;
 		const hasConfig = existsSync("qprobe.config.ts") || existsSync("qprobe.config.js") || existsSync("qprobe.config.mjs");
 		if (hasConfig) {
 			await showUsage(cmd);

package/dist/{compose-1CYahcRa.js → compose-BuBOYqop.js}

@@ -1,8 +1,8 @@
 import "./duration-DUrbfMLK.js";
 import { loadProbeConfig } from "./config-BUEMgFYN.js";
 import { error, info, json, success, table } from "./output-CHUjdVDf.js";
-import "./state-DRTSIt_r.js";
-import { listProcesses, startProcess, stopProcess } from "./process-manager-CITbaM9X.js";
+import "./state-B0f4kwdz.js";
+import { listProcesses, startProcess, stopProcess } from "./process-manager-CUmXxN1Y.js";
 import { defineCommand } from "citty";
 import { ofetch } from "ofetch";
 
@@ -163,7 +163,7 @@ const restart = defineCommand({
 					error(`Unknown service: "${args.name}"`);
 					process.exit(1);
 				}
-				const { stopProcess: stopProcess$1, startProcess: startProcess$1 } = await import("./process-manager-BVSQm3gK.js");
+				const { stopProcess: stopProcess$1, startProcess: startProcess$1 } = await import("./process-manager-D_k19e8-.js");
 				try {
 					await stopProcess$1(args.name);
 				} catch {}

package/dist/{logs-BIt5sCky.js → logs-LWtXR5o6.js}

@@ -1,6 +1,6 @@
 import { parseDuration } from "./duration-DUrbfMLK.js";
 import { error, info, json, log } from "./output-CHUjdVDf.js";
-import { getLogPath, listProcessNames } from "./state-DRTSIt_r.js";
+import { getLogPath, listProcessNames } from "./state-B0f4kwdz.js";
 import { defineCommand } from "citty";
 import { consola } from "consola";
 import { readFile, stat } from "node:fs/promises";

package/dist/{process-manager-CITbaM9X.js → process-manager-CUmXxN1Y.js}

@@ -1,4 +1,4 @@
-import { ensureLogsDir, getLogPath, listProcessNames, readPid, readState, removePid, removeState, savePid, saveState } from "./state-DRTSIt_r.js";
+import { ensureLogsDir, getLogPath, listProcessNames, readPid, readState, removePid, removeState, savePid, saveState } from "./state-B0f4kwdz.js";
 import { openSync } from "node:fs";
 import { appendFile } from "node:fs/promises";
 import { spawn } from "node:child_process";

package/dist/process-manager-D_k19e8-.js

@@ -0,0 +1,4 @@
+import "./state-B0f4kwdz.js";
+import { getProcessState, listProcesses, startProcess, stopAll, stopProcess } from "./process-manager-CUmXxN1Y.js";
+
+export { startProcess, stopProcess };

package/dist/{ps-UFZx0jy0.js → ps-E1hgvd2u.js}

@@ -1,6 +1,6 @@
 import { info, json, table } from "./output-CHUjdVDf.js";
-import "./state-DRTSIt_r.js";
-import { listProcesses } from "./process-manager-CITbaM9X.js";
+import "./state-B0f4kwdz.js";
+import { listProcesses } from "./process-manager-CUmXxN1Y.js";
 import { defineCommand } from "citty";
 
 //#region src/commands/ps.ts

package/dist/{record-C4SmoPsT.js → record-DE4BA6jl.js}

@@ -1,65 +1,12 @@
 import "./duration-DUrbfMLK.js";
 import { loadProbeConfig } from "./config-BUEMgFYN.js";
 import { error, info, success } from "./output-CHUjdVDf.js";
-import { generatePlaywrightTest } from "./codegen-BH3cUNuf.js";
+import { cancelRecording, getActiveRecording, startRecording, stopRecording } from "./recorder-FojdM3gr.js";
+import { generatePlaywrightTest } from "./codegen-XzGmnbb5.js";
 import { defineCommand } from "citty";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
-//#region src/testing/recorder.ts
-const STATE_FILE = "tmp/qprobe/state/recording.json";
-let activeRecording = null;
-async function startRecording(name) {
-	if (activeRecording) throw new Error(`Already recording "${activeRecording.name}". Stop it first.`);
-	const config = await loadProbeConfig();
-	activeRecording = {
-		name,
-		startedAt: new Date().toISOString(),
-		baseUrl: config.http?.baseUrl ?? config.browser?.baseUrl,
-		actions: []
-	};
-	await mkdir("tmp/qprobe/state", { recursive: true });
-	await writeFile(STATE_FILE, JSON.stringify(activeRecording, null, 2), "utf-8");
-}
-async function stopRecording() {
-	const recording = activeRecording ?? await loadActiveRecording();
-	if (!recording) throw new Error("No active recording");
-	recording.finishedAt = new Date().toISOString();
-	const config = await loadProbeConfig();
-	const testsDir = config.tests?.dir ?? "tests/qprobe";
-	const recordingsDir = join(testsDir, "recordings");
-	await mkdir(recordingsDir, { recursive: true });
-	const jsonPath = join(recordingsDir, `${recording.name}.json`);
-	await writeFile(jsonPath, JSON.stringify(recording, null, 2), "utf-8");
-	activeRecording = null;
-	try {
-		const { rm: rm$1 } = await import("node:fs/promises");
-		await rm$1(STATE_FILE);
-	} catch {}
-	return recording;
-}
-async function cancelRecording() {
-	activeRecording = null;
-	try {
-		const { rm: rm$1 } = await import("node:fs/promises");
-		await rm$1(STATE_FILE);
-	} catch {}
-}
-async function loadActiveRecording() {
-	try {
-		const content = await readFile(STATE_FILE, "utf-8");
-		activeRecording = JSON.parse(content);
-		return activeRecording;
-	} catch {
-		return null;
-	}
-}
-async function getActiveRecording() {
-	if (activeRecording) return activeRecording;
-	return loadActiveRecording();
-}
-
-//#endregion
 //#region src/commands/record.ts
 const start = defineCommand({
 	meta: {

package/dist/recorder-FojdM3gr.js

@@ -0,0 +1,81 @@
+import { loadProbeConfig } from "./config-BUEMgFYN.js";
+import { readFileSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+//#region src/testing/recorder.ts
+const STATE_FILE = "tmp/qprobe/state/recording.json";
+let activeRecording = null;
+async function startRecording(name) {
+	const existing = activeRecording ?? await loadActiveRecording();
+	if (existing) {
+		const startedAt = new Date(existing.startedAt);
+		const elapsed = Date.now() - startedAt.getTime();
+		const mins = Math.floor(elapsed / 6e4);
+		const age = mins > 0 ? ` (started ${mins}m ago)` : "";
+		throw new Error(`Already recording "${existing.name}"${age}. Run "qprobe record stop" or "qprobe record cancel" first.`);
+	}
+	const config = await loadProbeConfig();
+	activeRecording = {
+		name,
+		startedAt: new Date().toISOString(),
+		baseUrl: config.http?.baseUrl ?? config.browser?.baseUrl,
+		actions: []
+	};
+	await mkdir("tmp/qprobe/state", { recursive: true });
+	await writeFile(STATE_FILE, JSON.stringify(activeRecording, null, 2), "utf-8");
+}
+function recordAction(command, args) {
+	if (!activeRecording) try {
+		const content = readFileSync(STATE_FILE, "utf-8");
+		activeRecording = JSON.parse(content);
+	} catch {
+		return;
+	}
+	activeRecording.actions.push({
+		command,
+		args,
+		timestamp: new Date().toISOString()
+	});
+	writeFile(STATE_FILE, JSON.stringify(activeRecording, null, 2), "utf-8");
+}
+async function stopRecording() {
+	const recording = activeRecording ?? await loadActiveRecording();
+	if (!recording) throw new Error("No active recording");
+	recording.finishedAt = new Date().toISOString();
+	const config = await loadProbeConfig();
+	const testsDir = config.tests?.dir ?? "tests/qprobe";
+	const recordingsDir = join(testsDir, "recordings");
+	await mkdir(recordingsDir, { recursive: true });
+	const jsonPath = join(recordingsDir, `${recording.name}.json`);
+	await writeFile(jsonPath, JSON.stringify(recording, null, 2), "utf-8");
+	activeRecording = null;
+	try {
+		const { rm: rm$1 } = await import("node:fs/promises");
+		await rm$1(STATE_FILE);
+	} catch {}
+	return recording;
+}
+async function cancelRecording() {
+	activeRecording = null;
+	try {
+		const { rm: rm$1 } = await import("node:fs/promises");
+		await rm$1(STATE_FILE);
+	} catch {}
+}
+async function loadActiveRecording() {
+	try {
+		const content = await readFile(STATE_FILE, "utf-8");
+		activeRecording = JSON.parse(content);
+		return activeRecording;
+	} catch {
+		return null;
+	}
+}
+async function getActiveRecording() {
+	if (activeRecording) return activeRecording;
+	return loadActiveRecording();
+}
+
+//#endregion
+export { cancelRecording, getActiveRecording, recordAction, startRecording, stopRecording };

package/dist/{recordings-Cb31alos.js → recordings-CmVHyt3A.js}

@@ -1,8 +1,8 @@
 import "./duration-DUrbfMLK.js";
 import { loadProbeConfig } from "./config-BUEMgFYN.js";
 import { error, info, json, log, success } from "./output-CHUjdVDf.js";
-import { generatePlaywrightTest } from "./codegen-BH3cUNuf.js";
-import { formatRecordingsList } from "./reporter-CqWc26OP.js";
+import { generatePlaywrightTest } from "./codegen-XzGmnbb5.js";
+import { formatRecordingsList } from "./reporter-B-dIKeqZ.js";
 import { defineCommand } from "citty";
 import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";

package/dist/{replay-Dg9PHNrg.js → replay-DTB0C9DC.js}

@@ -1,7 +1,7 @@
 import "./duration-DUrbfMLK.js";
 import { loadProbeConfig } from "./config-BUEMgFYN.js";
 import { error, log } from "./output-CHUjdVDf.js";
-import { formatReplayResult } from "./reporter-CqWc26OP.js";
+import { formatReplayResult } from "./reporter-B-dIKeqZ.js";
 import { defineCommand } from "citty";
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";

package/dist/{restart-CEzd2Mgn.js → restart-CCnfVg7M.js}

@@ -1,6 +1,6 @@
 import { error, success } from "./output-CHUjdVDf.js";
-import "./state-DRTSIt_r.js";
-import { getProcessState, startProcess, stopProcess } from "./process-manager-CITbaM9X.js";
+import "./state-B0f4kwdz.js";
+import { getProcessState, startProcess, stopProcess } from "./process-manager-CUmXxN1Y.js";
 import { defineCommand } from "citty";
 
 //#region src/commands/restart.ts

package/dist/{start-BJnzhZp9.js → start-DAj1ldz_.js}

@@ -1,7 +1,7 @@
 import { parseDuration } from "./duration-DUrbfMLK.js";
 import { error, success } from "./output-CHUjdVDf.js";
-import "./state-DRTSIt_r.js";
-import { startProcess } from "./process-manager-CITbaM9X.js";
+import "./state-B0f4kwdz.js";
+import { startProcess } from "./process-manager-CUmXxN1Y.js";
 import { defineCommand } from "citty";
 
 //#region src/commands/start.ts

package/dist/{stop-C0xDWnnB.js → stop-Y3DscZCW.js}

@@ -1,6 +1,6 @@
 import { error, success } from "./output-CHUjdVDf.js";
-import "./state-DRTSIt_r.js";
-import { stopAll, stopProcess } from "./process-manager-CITbaM9X.js";
+import "./state-B0f4kwdz.js";
+import { stopAll, stopProcess } from "./process-manager-CUmXxN1Y.js";
 import { defineCommand } from "citty";
 
 //#region src/commands/stop.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@questpie/probe",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Dev testing CLI for AI coding agents",
   "license": "MIT",
   "type": "module",

package/skills/qprobe/SKILL.md

@@ -5,100 +5,234 @@ description: "QUESTPIE Probe — dev testing CLI for AI coding agents. Orchestra
 
 # QUESTPIE Probe
 
-Dev testing CLI. Manages dev servers, reads logs, controls browsers, sends HTTP requests, records and replays tests.
+Dev testing CLI for AI coding agents. Start servers, read logs, test APIs, control browsers, record and replay tests.
 
 **Install CLI:** `bun add -g @questpie/probe`
 **Install skill:** `bunx skills add questpie/probe`
+**Docs:** https://probe.questpie.com/docs
 
-## Core Principle
-
-> Read logs before opening a browser. 90% of debugging needs zero visual context.
-
-## Quick Start
-
-```bash
-qprobe compose up                           # start all services from config
-qprobe check http://localhost:3000           # health + console + network summary
-qprobe logs server --grep "ERROR"            # check process logs
-qprobe http GET /api/health                  # test API endpoint
-qprobe browser open http://localhost:3000    # open browser (only if needed)
-qprobe browser snapshot -i                   # see interactive elements
-```
-
-## Command Groups
-
-| Command | What it does | When to use |
-|---------|-------------|-------------|
-| `qprobe start` | Start a process with ready detection | Need to run dev server, DB, worker |
-| `qprobe stop` | Stop a running process | Cleanup, restart |
-| `qprobe ps` | List running processes | Check what's running |
-| `qprobe health` | Poll URL until healthy | Wait for server to be ready |
-| `qprobe compose` | Multi-service orchestration | Start full stack (DB+server+admin) |
-| `qprobe logs` | Read/filter/follow process logs | Debug server errors |
-| `qprobe http` | Send HTTP requests | Test API endpoints |
-| `qprobe check` | All-in-one health summary | Quick status overview |
-| `qprobe browser` | Browser automation | Visual testing, form filling |
-| `qprobe record` | Record a test session | Capture a flow for regression |
-| `qprobe replay` | Replay recorded tests | Run regression (zero AI tokens) |
-| `qprobe assert` | Assert conditions | Verify state in CI or scripts |
-
-## Recommended Workflow
-
-1. **Start stack** → `qprobe compose up`
-2. **Read logs** → `qprobe logs --all --grep ERROR` (no browser yet!)
-3. **Test API** → `qprobe http GET /api/health` (still no browser!)
-4. **Quick check** → `qprobe check` (summarizes everything)
-5. **Open browser** → `qprobe browser open /login` (only if needed)
-6. **Record test** → `qprobe record start "login-flow"`
-7. **Replay free** → `qprobe replay --all` (pure Playwright, zero tokens)
-
-## Sub-Skills
-
-For detailed reference on each command group, read the corresponding reference file:
-
-- **Process management** (start, stop, ps, health, restart) → read `references/process.md`
-- **Compose** (multi-service orchestration, config file) → read `references/compose.md`
-- **HTTP requests** (API testing, auth, assertions) → read `references/http.md`
-- **Browser control** (snapshot, click, fill, console, network) → read `references/browser.md`
-- **Recording & replay** (test capture, Playwright codegen) → read `references/recording.md`
-
-## Config File
-
-Create `qprobe.config.ts` in project root (optional — CLI works without it):
-
-```typescript
-import { defineConfig } from '@questpie/probe'
-
-export default defineConfig({
-  services: {
-    db: {
-      cmd: 'docker compose up postgres',
-      ready: 'ready to accept connections',
-    },
-    server: {
-      cmd: 'bun dev',
-      ready: 'ready on http://localhost:3000',
-      port: 3000,
-      health: '/api/health',
-      depends: ['db'],
-    },
-  },
-  browser: {
-    driver: 'agent-browser',
-    baseUrl: 'http://localhost:3000',
-  },
-  http: {
-    baseUrl: 'http://localhost:3000',
-  },
-})
-```
-
-## Tips for Agents
-
-- **Always check logs before opening browser** — most bugs are visible in `qprobe logs`
-- **Use `qprobe check`** for a one-command overview of server health
-- **Use `qprobe http`** instead of browser for API testing — much cheaper on tokens
-- **Snapshot with `-i`** (interactive only) to save tokens — skip structural/decorative elements
-- **Snapshot with `--diff`** after actions to see only what changed
-- **Record flows you want to verify later** — replay costs zero AI tokens
-- **Grep is your friend** — `qprobe logs server --grep "ERROR"` is faster than reading everything
+## Core Principles
+
+1. **Logs before browser** — 90% of bugs are visible in logs and HTTP responses. Open a browser only when you need visual verification.
+2. **Record → replay free** — record a flow once, replay it forever with pure Playwright. Zero AI tokens on regression.
+3. **Token-efficient** — use `snapshot -i` (interactive only), `--diff` (changes only), `--grep` (filtered logs). Read only what you need.
+
+---
+
+## Testing Workflow
+
+Follow this order every time you test an app. Do NOT skip to browser.
+
+### Step 1 — Start the app
+```bash
+# Option A: from config
+qprobe compose up
+
+# Option B: manually
+qprobe start server "bun dev" --ready "ready on" --port 3000
+```
+
+### Step 2 — Check health (no browser yet)
+```bash
+qprobe ps                                    # is it running?
+qprobe health http://localhost:3000/api/health   # does it respond?
+qprobe check http://localhost:3000           # all-in-one summary
+```
+
+### Step 3 — Read logs (no browser yet)
+```bash
+qprobe logs server                           # recent logs
+qprobe logs server --grep "ERROR"            # find errors
+qprobe logs server --level error             # only ERROR level
+qprobe logs --all --grep "ERROR"             # errors from all services
+```
+
+### Step 4 — Test API (no browser yet)
+```bash
+qprobe http GET /api/health --status 200
+qprobe http GET /api/users --status 200
+qprobe http POST /api/users -d '{"name":"Test"}' --status 201
+```
+
+### Step 5 — Open browser (only if needed)
+```bash
+qprobe browser open http://localhost:3000
+qprobe browser snapshot -i -c               # see interactive elements
+qprobe browser errors                        # JS errors?
+qprobe browser network --failed              # failed requests?
+qprobe browser console --level error         # console errors?
+```
+
+### Step 6 — Interact and verify
+```bash
+qprobe browser click @e3                     # click element from snapshot
+qprobe browser fill @e2 "hello"              # fill input
+qprobe browser press Enter                   # submit
+qprobe browser snapshot --diff               # what changed?
+qprobe browser screenshot                    # visual proof
+```
+
+### Step 7 — Assert
+```bash
+qprobe assert status 200 /api/health        # API is healthy
+qprobe assert no-errors                      # no JS errors in browser
+qprobe assert no-network-errors              # no 4xx/5xx in network
+qprobe assert text "Dashboard"              # page shows expected text
+qprobe assert title "My App"                # page title matches
+```
+
+### Step 8 — Record for regression
+```bash
+qprobe record start "my-flow"
+# ... repeat steps 5-7 ...
+qprobe record stop                           # saves JSON + generates .spec.ts
+qprobe replay "my-flow"                      # run Playwright test (zero tokens)
+qprobe replay --all                          # run all recorded tests
+```
+
+### Step 9 — Cleanup
+```bash
+qprobe stop --all                            # or: qprobe compose down
+```
+
+---
+
+## Debugging Workflow
+
+When something doesn't work — don't jump to browser. Triage in this order:
+
+### 1. Is it running?
+```bash
+qprobe ps
+qprobe check
+```
+
+### 2. Check logs for errors
+```bash
+qprobe logs server --level error
+qprobe logs --all --grep "Error|fail|crash" --since 10m
+```
+
+### 3. Test API directly
+```bash
+qprobe http GET /api/health --status 200
+qprobe http GET /api/<endpoint> -v              # verbose: see full request/response
+```
+
+### 4. Browser only if UI bug
+```bash
+qprobe browser open <url>
+qprobe browser console --level error            # JS errors?
+qprobe browser network --failed                 # failed requests?
+qprobe browser snapshot -i                      # what does the page show?
+```
+
+### 5. Fix → restart → verify → record
+```bash
+qprobe restart server
+qprobe logs server --level error --since 1m     # should be empty now
+qprobe record start "fix-<issue>"
+# (re-run the verification steps that failed before)
+qprobe assert no-errors
+qprobe record stop
+qprobe replay "fix-<issue>"                     # MUST pass
+```
+
+### Exit Codes
+
+| Code | Meaning | What to do |
+|------|---------|------------|
+| 0 | Success | Continue |
+| 1 | Assertion/command error | Read the output message |
+| 2 | Process timeout | Ready pattern not matched — check logs, increase `--timeout` |
+| 3 | Health check failed | Server not responding — check if process is running |
+| 4 | Config error | Check `qprobe.config.ts` syntax |
+| 5 | Browser driver missing | Install: `bun add -g agent-browser` |
+| 6 | Replay test failure | Regression — check what changed in code |
+
+---
+
+## Shipping a Feature
+
+A feature is **NOT done** until its replay passes.
+
+### 1. Plan what to test
+
+Before writing any test, identify:
+- What are the **critical user flows** for this feature?
+- What are the **edge cases**? (empty state, validation errors, permissions)
+- What **API endpoints** does it touch?
+
+If unclear — **ask the user** for their expected flows and scenarios.
+
+### 2. Verify with logs + API first
+```bash
+qprobe logs server --level error                # no errors after change
+qprobe http GET /api/<endpoint> --status 200    # API works
+```
+
+### 3. Record each user flow
+```bash
+# For each critical flow:
+qprobe record start "<feature>-<flow-name>"
+qprobe browser open <start-url>
+# (interact: fill, click, navigate)
+qprobe assert no-errors
+qprobe assert no-network-errors
+qprobe record stop
+```
+
+### 4. Replay ALL — must pass
+```bash
+qprobe replay --all
+# If any replay fails → fix and re-record that flow
+```
+
+### 5. Feature is shippable when:
+- All **existing replays** still pass (no regressions)
+- All **new feature flows** are recorded and pass
+- **No JS errors**, no network errors
+
+---
+
+## Command Reference
+
+| Command | Purpose | When to use |
+|---------|---------|-------------|
+| `qprobe start` | Start process with ready detection | Dev server, DB, worker |
+| `qprobe stop` | Graceful stop (SIGTERM → SIGKILL) | Cleanup |
+| `qprobe restart` | Stop + start with saved config | After code changes |
+| `qprobe ps` | List running processes | Check what's up |
+| `qprobe health` | Poll URL until healthy | Wait for server |
+| `qprobe compose` | Multi-service orchestration | Start full stack |
+| `qprobe logs` | Read/filter/follow logs | Debug errors |
+| `qprobe http` | HTTP requests with assertions | Test API |
+| `qprobe check` | All-in-one health summary | Quick overview |
+| `qprobe browser` | Browser automation (27 subcommands) | Visual testing |
+| `qprobe record` | Record browser actions | Capture test flow |
+| `qprobe replay` | Run recorded Playwright tests | Regression testing |
+| `qprobe assert` | Assert conditions (exit 1 on fail) | Verify state |
+| `qprobe init` | Scaffold qprobe.config.ts | Project setup |
+
+## Detailed References
+
+Read the reference file for the command group you need:
+
+- **Process management** (start, stop, ps, health, restart) → `references/process.md`
+- **Logs** (read, filter, grep, follow, merge) → `references/logs.md`
+- **HTTP requests & API testing** → `references/http.md`
+- **Quick health check** (one-shot status + services) → `references/check.md`
+- **Browser control** (snapshot, click, fill, console, network) → `references/browser.md`
+- **Service orchestration** (compose up/down, dependencies) → `references/compose.md`
+- **Recording & replay** (test capture, Playwright codegen) → `references/recording.md`
+- **Assertions** (text, element, URL, status, errors) → `references/assertions.md`
+- **UX testing methods** (heuristics, task completion, a11y) → `references/ux.md`
+
+## Tips
+
+- `qprobe logs server --grep "ERROR"` is faster than reading all logs
+- `qprobe http` is cheaper than `qprobe browser` for API testing
+- `snapshot -i` saves tokens — shows only interactive elements
+- `snapshot --diff` after actions shows only what changed
+- `qprobe check` gives a one-command status overview
+- Record flows early — replay is free forever

package/skills/qprobe/references/assertions.md

@@ -0,0 +1,168 @@
+# Assertions Reference
+
+Assert conditions against browser state or HTTP endpoints. Exit code 0 on pass, exit code 1 on fail.
+
+## Assertion Types
+
+### text / no-text
+
+```bash
+qprobe assert text "Dashboard"              # page body contains text
+qprobe assert no-text "Error"               # page body does NOT contain text
+```
+
+- **Case-sensitive** — `"Dashboard"` will NOT match `"dashboard"`
+- Uses `includes()` on full page text content
+- Requires open browser session
+
+Output:
+```
+✅ Page contains "Dashboard"
+❌ Page does not contain "Dashboard"    # exit 1
+```
+
+### element
+
+```bash
+qprobe assert element @e3                    # ref from snapshot exists
+qprobe assert element "#user-avatar"         # CSS selector exists
+```
+
+- Checks the interactive snapshot (`-i -c`) for the ref or selector string
+- Accepts `@e` refs (from most recent snapshot) and CSS selectors
+
+Output:
+```
+✅ Element "@e3" exists
+❌ Element "@e3" not found               # exit 1
+```
+
+### url
+
+```bash
+qprobe assert url "/dashboard"               # URL contains /dashboard
+qprobe assert url "^https://"                # URL starts with https
+qprobe assert url "/users/\\d+"              # regex match
+```
+
+- Pattern is a **JavaScript RegExp** (not glob, not exact match)
+- Matches against full current URL
+
+Output:
+```
+✅ URL matches "/dashboard" (http://localhost:3000/dashboard)
+❌ URL "http://localhost:3000/login" does not match "/dashboard"    # exit 1
+```
+
+### title
+
+```bash
+qprobe assert title "Dashboard"
+```
+
+- **Case-sensitive** `includes()` on page title
+
+Output:
+```
+✅ Title contains "Dashboard" (Dashboard - My App)
+❌ Title "Login - My App" does not contain "Dashboard"    # exit 1
+```
+
+### status
+
+```bash
+qprobe assert status 200 /api/health        # TWO arguments: code + path
+qprobe assert status 404 /api/nonexistent
+qprobe assert status 201 /api/users
+```
+
+- **Two positional arguments**: expected status code, then URL path
+- Path resolves against baseUrl (same resolution as `qprobe http`)
+- Makes an HTTP request and checks the response status
+
+Output:
+```
+✅ http://localhost:3000/api/health returned 200
+❌ http://localhost:3000/api/health returned 500, expected 200    # exit 1
+```
+
+### no-errors
+
+```bash
+qprobe assert no-errors
+```
+
+- Checks browser console for uncaught JS exceptions
+- Requires open browser session
+
+Output:
+```
+✅ No JS errors
+
+❌ Found 2 JS error(s):                                          # exit 1
+  TypeError: Cannot read properties of undefined (reading 'map')
+  ReferenceError: user is not defined
+```
+
+### no-network-errors
+
+```bash
+qprobe assert no-network-errors
+```
+
+- Checks network tab for 4xx/5xx HTTP responses
+- Requires open browser session
+
+Output:
+```
+✅ No network errors
+
+❌ Found 1 network error(s):                                     # exit 1
+  POST 500 /api/users
+```
+
+## Common Patterns
+
+### After form submission
+```bash
+qprobe browser click @e5                     # submit
+qprobe browser wait --network idle
+qprobe assert no-errors
+qprobe assert no-network-errors
+qprobe assert text "Saved successfully"
+```
+
+### After page navigation
+```bash
+qprobe browser click @e3
+qprobe assert url "/dashboard"
+qprobe assert title "Dashboard"
+qprobe assert no-errors
+```
+
+### Full health check (API + browser)
+```bash
+qprobe assert status 200 /api/health
+qprobe assert status 200 /api/users
+qprobe assert no-errors
+qprobe assert no-network-errors
+```
+
+### CI/script chaining
+```bash
+# All assertions exit 1 on failure — chain with &&
+qprobe assert status 200 /api/health && \
+qprobe assert no-errors && \
+qprobe assert text "Welcome" && \
+echo "All checks passed"
+```
+
+## Tips
+
+- `text` / `no-text` are **case-sensitive** — use exact case from the page
+- `url` uses **regex** — escape dots in literal URLs: `"localhost\\.com"`
+- `element` checks the interactive snapshot string, not raw DOM
+- `status` needs **TWO args** — the expected code AND the URL path
+- `no-errors` and `no-network-errors` **require an open browser session**
+- Chain assertions with `&&` for scripts and CI
+- All assertions exit code 1 on failure — useful for conditional logic

package/skills/qprobe/references/check.md

@@ -0,0 +1,61 @@
+# Check Reference
+
+Quick one-shot health check. Single HTTP request + timing + running services summary.
+
+## Usage
+
+```bash
+qprobe check [url]
+```
+
+No flags. URL defaults to baseUrl from config (same resolution as `qprobe http`).
+
+## What It Does
+
+1. Makes a single HTTP request to the URL
+2. Reports HTTP status code + response time in milliseconds
+3. Lists all running managed processes
+
+## Output
+
+```bash
+qprobe check http://localhost:3000
+# ✅ HTTP 200 OK (45ms)
+# ℹ 3 service(s) running (db, server, worker)
+```
+
+```bash
+qprobe check http://localhost:3000
+# ❌ HTTP 500 Internal Server Error (120ms)
+# ℹ 2 service(s) running (db, server)
+```
+
+```bash
+qprobe check http://localhost:3000
+# ❌ Connection failed: ECONNREFUSED
+# ⚠ No managed services running
+```
+
+```bash
+# Without URL — uses config baseUrl
+qprobe check
+# ✅ HTTP 200 OK (32ms)
+# ℹ 1 service(s) running (server)
+```
+
+## check vs health
+
+| | `qprobe check` | `qprobe health` |
+|--|----------------|-----------------|
+| Requests | Single | Polling until success |
+| Timeout | None | `--timeout` (default 30s) |
+| Retries | No | Yes (`--interval`) |
+| Service list | Yes | No |
+| Use case | "Is it up right now?" | "Wait until it's up" |
+
+## When to Use
+
+- **First command in debugging** — quick sanity check before digging deeper
+- **After `qprobe compose up`** — verify the stack came up
+- **After `qprobe restart`** — verify server is responding
+- Simpler than `qprobe health` when you don't need polling/retries

package/skills/qprobe/references/logs.md

@@ -0,0 +1,116 @@
+# Logs Reference
+
+Timestamped, level-parsed logs for every managed process.
+
+## Usage
+
+```bash
+qprobe logs <name> [flags]          # single process
+qprobe logs --all [flags]           # all processes, merged by timestamp
+qprobe logs --unified [flags]       # all processes + browser log
+```
+
+## Flags
+
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--follow` | `-f` | `false` | Stream new entries in real time (tail -f). Blocks until Ctrl+C |
+| `--lines` | `-n` | `50` | Number of recent lines to show |
+| `--grep` | | — | Case-insensitive regex filter on message text |
+| `--level` | | — | Exact level filter: `error`, `warn`, `info`, `debug` |
+| `--since` | | — | Time range: `30s`, `5m`, `1h` — only entries newer than this |
+| `--all` | | `false` | Merge logs from all processes, sorted by timestamp |
+| `--unified` | | `false` | All processes + browser console, interleaved |
+| `--json` | | `false` | Output as JSON array of LogEntry objects |
+
+## Output Format
+
+Single process:
+```
+2026-03-25T20:30:15.247Z INFO  Server ready on http://localhost:3000
+2026-03-25T20:30:16.103Z ERROR Connection refused to database
+```
+
+With `--all` or `--unified` (includes source name):
+```
+[server] 2026-03-25T20:30:15.247Z INFO  Server ready on http://localhost:3000
+[db]     2026-03-25T20:30:14.892Z INFO  PostgreSQL ready to accept connections
+[server] 2026-03-25T20:30:16.103Z ERROR Connection refused to database
+```
+
+Colors in follow mode: ERROR = red, WARN = yellow, others = default.
+
+JSON output (`--json`):
+```json
+[
+  {
+    "timestamp": "2026-03-25T20:30:16.103Z",
+    "level": "ERROR",
+    "message": "Connection refused to database",
+    "source": "server"
+  }
+]
+```
+
+## Examples
+
+```bash
+# Last 50 lines from server (default)
+qprobe logs server
+
+# Only errors
+qprobe logs server --level error
+
+# Regex search across message text (case-insensitive)
+qprobe logs server --grep "connection|timeout|refused"
+
+# Errors from the last 5 minutes
+qprobe logs server --level error --since 5m
+
+# Stream new errors in real time
+qprobe logs server -f --level error
+# (blocks — Ctrl+C to stop)
+
+# Check all services for a pattern
+qprobe logs --all --grep "ECONNREFUSED"
+
+# Last 200 lines as JSON (pipe to jq)
+qprobe logs server --json --lines 200
+```
+
+## Common Patterns
+
+### Find why the server crashed
+```bash
+qprobe ps                                       # is it still running?
+qprobe logs server --level error                 # recent errors
+qprobe logs server --grep "stack|trace|fatal"    # stack traces
+```
+
+### Watch for errors during testing
+```bash
+# In one terminal / before testing:
+qprobe logs server -f --level error
+# Run browser commands in another terminal — errors appear in real time
+```
+
+### Check all services after compose up
+```bash
+qprobe compose up
+qprobe logs --all --level error --since 1m       # any errors during startup?
+```
+
+### Machine-readable logs for analysis
+```bash
+qprobe logs server --json --since 1h | jq '.[] | select(.level == "ERROR")'
+```
+
+## Tips
+
+- **Always check logs BEFORE opening a browser** — most bugs are visible here
+- `--grep` is a regex — use `"fail|error|crash"` for broad search
+- `--level error` is faster than `--grep "error"` (exact field match vs string search)
+- `--since 5m` narrows results to recent issues — useful after code changes
+- Follow mode (`-f`) blocks the terminal — use it for real-time monitoring during testing
+- Log files are stored in `tmp/qprobe/logs/<name>.log`
+- Level detection is automatic: lines containing "error" → ERROR, "warn" → WARN, etc.

package/skills/qprobe/references/recording.md

@@ -184,6 +184,47 @@ tests/qprobe/
 └── playwright.config.ts        # auto-generated
 ```
 
+## Edge Cases
+
+### Stale recording from a previous session
+If a recording was started but the CLI process was interrupted (Ctrl+C, crash, terminal closed), the state file persists on disk.
+
+Next `qprobe record start` will detect it:
+```
+Already recording "old-name" (started 45m ago).
+Run "qprobe record stop" or "qprobe record cancel" first.
+```
+
+Fix: `qprobe record cancel`
+
+### Starting when one is already active
+```
+Already recording "login-flow".
+Run "qprobe record stop" or "qprobe record cancel" first.
+```
+
+Always cancel or stop before starting a new recording.
+
+### Error during recording
+If a browser command fails during recording, the recording **continues**. The failed action is still captured. Stop or cancel when ready.
+
+### Empty recording
+If you stop a recording with zero actions, the JSON and `.spec.ts` files are still generated — but the test will be empty and pass trivially.
+
+### Recording is transparent
+When no recording is active, all browser and HTTP commands work identically. Recording state is completely transparent — commands behave the same whether recording is on or off.
+
+### Corrupted state file
+If the state file is corrupted and `record cancel` doesn't work:
+```bash
+rm tmp/qprobe/state/recording.json
+```
+
+### File locations
+- Active recording state: `tmp/qprobe/state/recording.json`
+- Saved recordings: `tests/qprobe/recordings/<name>.json`
+- Generated tests: `tests/qprobe/recordings/<name>.spec.ts`
+
 ## Tips
 
 - **Record important flows early** — login, CRUD, critical paths
@@ -192,3 +233,4 @@ tests/qprobe/
 - **Export recordings** to share with team or run in CI
 - **Edit generated .spec.ts** files to add custom assertions
 - **Use `--retries 2`** for network-dependent tests that may be flaky
+- **If `record start` fails** — check for stale recording with `qprobe record cancel`

package/dist/process-manager-BVSQm3gK.js

@@ -1,4 +0,0 @@
-import "./state-DRTSIt_r.js";
-import { getProcessState, listProcesses, startProcess, stopAll, stopProcess } from "./process-manager-CITbaM9X.js";
-
-export { startProcess, stopProcess };