@rolepod/uiproof 0.5.0 → 0.6.0

package/.claude-plugin/marketplace.json

@@ -10,8 +10,8 @@
     {
       "name": "rolepod-uiproof",
       "source": "./",
-      "description": "26 MCP tools (21 atomic browser/mobile primitives + 5 composite workflows) + 5 user-invocable skills. v0.5 completes the UI verification surface — console + network observability, hover/drag/fill_form/upload/dialog, runtime emulation, multi-page, gated JS eval — replacing chrome-devtools-mcp and playwright-mcp for UI testing. Web production-ready via Playwright; mobile (iOS/Android) via Appium scaffolded — see `rolepod-uiproof doctor` for readiness.",
-      "version": "0.5.0",
+      "description": "26 MCP tools (21 atomic browser/mobile primitives + 5 composite workflows) + 5 user-invocable skills. v0.6 adds Extension Protocol v1 support — works standalone today, becomes the verify-phase UI provider when installed alongside the `rolepod` parent plugin (evidence routes to `.rolepod/evidence/` with `manifest.json`). Replaces chrome-devtools-mcp and playwright-mcp for UI testing. Web production-ready via Playwright; mobile (iOS/Android) via Appium scaffolded — see `rolepod-uiproof doctor` for readiness.",
+      "version": "0.6.0",
       "author": {
         "name": "nuttaruj"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "rolepod-uiproof",
-  "version": "0.5.0",
-  "description": "Multi-platform UI/mobile automation for AI agents — 5 shipped skills (verify-ui, audit-a11y, visual-diff, scaffold-e2e, check-errors) + MCP server with 26 tools. v0.5 completes the UI verification surface: console + network observability, hover/drag/fill_form/upload/dialog, runtime emulation, multi-page support, gated JS eval — replacing chrome-devtools-mcp and playwright-mcp for UI testing.",
+  "version": "0.6.0",
+  "description": "Multi-platform UI/mobile automation for AI agents — 5 shipped skills (verify-ui, audit-a11y, visual-diff, scaffold-e2e, check-errors) + MCP server with 26 tools. Works standalone OR with the `rolepod` parent plugin: when ROLEPOD_PARENT=1 is set, evidence routes to `.rolepod/evidence/` with a `manifest.json` per Extension Protocol v1, so parent's `check-work` skill can aggregate UI verify results into its phase report. v0.5 completed the UI verification surface (console + network observability, hover/drag/fill_form/upload/dialog, runtime emulation, multi-page, gated JS eval).",
   "author": {
     "name": "nuttaruj",
     "url": "https://github.com/nuttaruj"

package/.codex-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "rolepod-uiproof",
-  "version": "0.5.0",
-  "description": "Multi-platform UI/mobile automation for AI agents — 5 shipped skills (verify-ui, audit-a11y, visual-diff, scaffold-e2e, check-errors) + MCP server with 26 tools. v0.5 completes the UI verification surface: console + network observability, hover/drag/fill_form/upload/dialog, runtime emulation, multi-page, gated JS eval.",
+  "version": "0.6.0",
+  "description": "Multi-platform UI/mobile automation for AI agents — 5 shipped skills (verify-ui, audit-a11y, visual-diff, scaffold-e2e, check-errors) + MCP server with 26 tools. v0.6 adds Extension Protocol v1 — works standalone today, becomes the verify-phase UI provider when paired with the `rolepod` parent plugin.",
   "author": {
     "name": "nuttaruj",
     "url": "https://github.com/nuttaruj"
@@ -25,7 +25,7 @@
   "interface": {
     "displayName": "Rolepod UIProof",
     "shortDescription": "UI verification, a11y audits, visual diff, e2e scaffolding — for AI coding agents.",
-    "longDescription": "rolepod-uiproof ships an MCP server with 26 tools (21 atomic + 5 composite) and 5 user-invocable skills (/verify-ui, /audit-a11y, /visual-diff, /scaffold-e2e, /check-errors). Web is fully supported via Playwright; mobile (iOS/Android via Appium) supports basic input. v0.5 completes the UI verification surface — console logs, network requests, HAR/video/trace capture, runtime emulation, multi-page popups.",
+    "longDescription": "rolepod-uiproof ships an MCP server with 26 tools (21 atomic + 5 composite) and 5 user-invocable skills (/verify-ui, /audit-a11y, /visual-diff, /scaffold-e2e, /check-errors). Web is fully supported via Playwright; mobile (iOS/Android via Appium) supports basic input. v0.6: pair with the `rolepod` parent plugin (v2.7+) and uiproof becomes the verify-phase UI provider — evidence routes to `.rolepod/evidence/` with a `manifest.json` per Extension Protocol v1.",
     "developerName": "nuttaruj",
     "category": "Productivity",
     "capabilities": ["Read", "Write", "Bash"],

package/.cursor-plugin/plugin.json

@@ -1,8 +1,8 @@
 {
   "name": "rolepod-uiproof",
   "displayName": "Rolepod UIProof",
-  "version": "0.5.0",
-  "description": "Multi-platform UI / mobile automation MCP server + 5 shipped skills (verify-ui, audit-a11y, visual-diff, scaffold-e2e, check-errors) for AI coding agents. v0.5 completes the UI verification surface: console + network observability, hover/drag/fill_form/upload/dialog, runtime emulation, multi-page, gated JS eval — replacing chrome-devtools-mcp and playwright-mcp.",
+  "version": "0.6.0",
+  "description": "Multi-platform UI / mobile automation MCP server + 5 shipped skills (verify-ui, audit-a11y, visual-diff, scaffold-e2e, check-errors) for AI coding agents. v0.6 adds Extension Protocol v1 — works standalone today, becomes the verify-phase UI provider when paired with the `rolepod` parent plugin (evidence routes to `.rolepod/evidence/` with `manifest.json`). Replaces chrome-devtools-mcp and playwright-mcp.",
   "author": {
     "name": "nuttaruj"
   },

package/CHANGELOG.md

@@ -7,6 +7,75 @@ release.
 
 ## [Unreleased]
 
+## [0.6.0] — 2026-05-27
+
+**Extension Protocol v1 — `uiproof` becomes parent-aware. Standalone
+behavior unchanged.**
+
+When the parent `rolepod` plugin (v2.7+) sets `ROLEPOD_PARENT=1` via
+its SessionStart hook, uiproof routes evidence to the shared
+`.rolepod/evidence/` tree and emits a `manifest.json` per spec so the
+parent's `check-work` skill can aggregate UI verify results into its
+phase report. With no parent installed the v0.5 behavior is preserved
+exactly — same artifact path, same tool output, plus a `manifest.json`
+in each run dir as a bonus.
+
+### Added
+
+- **Env-aware evidence path** in `ArtifactStore`. Detected at
+  construction from `process.env.ROLEPOD_PARENT === "1"`.
+  - standalone: `.rolepod-uiproof/artifacts/{prefix}_{ts}_{uuid}/`
+  - with-parent: `.rolepod/evidence/{ts}-rolepod-uiproof-{skill}/`
+- **`manifest.json`** written by every composite that starts a run
+  (`verify_ui_flow`, `audit_a11y`, `visual_diff`, `scaffold_e2e`).
+  Schema follows Extension Protocol v1: `protocol`, `plugin`, `skill`,
+  `phase`, `status`, `summary`, `started_at`, `finished_at`,
+  `artifacts: [{type, path}]`, `metadata`. Best-effort: any IO failure
+  is logged but never thrown.
+- **Graduated a11y status**. `audit_a11y` manifest carries `status`:
+  `critical/serious > 0 → fail`, `moderate/minor > 0 → warn`, no
+  issues → `pass`. Keeps the `warn` signal a strict pass/fail would
+  discard.
+- **Protocol version check**. When `ROLEPOD_PROTOCOL` is set but
+  does not equal `v1`, `buildServer()` logs a one-shot warning. Does
+  not block; manifest is still written in v1 shape.
+- **`/check-errors` evidence routing doc** alongside the other 4
+  skills.
+
+### Changed
+
+- `ArtifactStore.startRun(prefix, opts?)` — `opts.skill` is new and
+  optional. Provides the canonical skill name for both the
+  with-parent dirname and the manifest's `skill` field. Return shape
+  extended with `skill` and `mode` (back-compat: existing destructuring
+  of `{ runId, runDir }` keeps working).
+- `buildServer()` log line surfaces `protocol: "v1"` and
+  `mode: "standalone" | "with-parent"` alongside the existing version
+  + tools list.
+- All 5 shipped skills' SKILL.md gained an "Evidence routing" section
+  between "Process" / "Outputs" and "If the tool is unavailable".
+  Mirrored to `plugins/rolepod-uiproof/skills/`.
+- README "Standalone vs Combined" section added explaining the two
+  modes.
+
+### Behavior
+
+- **Standalone:** unchanged. Evidence still written to
+  `.rolepod-uiproof/artifacts/`. New: a `manifest.json` appears in each
+  run dir. Tool return values gain an optional `manifest: "<path>"`
+  field; everything else is byte-for-byte identical.
+- **With rolepod parent:** evidence written to
+  `.rolepod/evidence/<ts>-rolepod-uiproof-<skill>/` with `manifest.json`
+  per protocol spec. Visual baselines stay in
+  `.rolepod-uiproof/baselines/` regardless of mode.
+
+### Non-goals (kept out of v0.6)
+
+- Dynamic capabilities registry (`.claude-plugin/capabilities.json`)
+- Protocol version negotiation beyond a single warn
+- Cross-child coordination (uiproof ↔ wplab handoff inside one run)
+- Mobile platform support stays at the v0.5 partial level
+
 ## [0.5.0] — 2026-05-27
 
 **Complete UI verification surface — one MCP replaces chrome-devtools-mcp

package/README.md

@@ -27,6 +27,21 @@ One MCP server, one tool surface, five skills you invoke from chat. Web is produ
 
 Every skill is **single-backend** (D-024) — it calls the rolepod-uiproof server and only the rolepod-uiproof server. If the server is unavailable, the skill fails with a clear diagnostic. Multi-backend routing belongs in the parent [`rolepod`](https://github.com/nuttaruj/rolepod) plugin's phase skills, not here.
 
+## Standalone vs Combined
+
+`rolepod-uiproof` works either as a **standalone** browser MCP for any project, or **combined** with the [`rolepod`](https://github.com/nuttaruj/rolepod) parent plugin (v2.7+) where it becomes the Verify phase provider for UI artifacts.
+
+**Standalone** (default): use the 5 skills directly as atomic browser tools. Evidence saved under `./.rolepod-uiproof/artifacts/<run>/` with a `manifest.json` per Extension Protocol v1.
+
+**Combined with rolepod parent**: when the parent's SessionStart hook sets `ROLEPOD_PARENT=1`, uiproof writes evidence to `./.rolepod/evidence/<ts>-rolepod-uiproof-<skill>/` instead, where parent's `check-work` skill auto-aggregates manifests into the verify report. No skill changes — same 26 tools, same 5 skills, smarter routing.
+
+| Install | Unlocks |
+|---|---|
+| uiproof alone | Browser test, a11y audit, visual diff, e2e scaffold, error gate |
+| uiproof + rolepod parent | + verify-phase aggregation, evidence handoff to `check-work` |
+
+The `manifest.json` is written in BOTH modes, so installing the parent later still lets historic artifacts get picked up. Baselines for `/visual-diff` always live in `./.rolepod-uiproof/baselines/` regardless of mode — they are user-curated configuration, not per-run evidence.
+
 ## Install
 
 Pick your CLI. All install paths share the same MCP server (`@rolepod/uiproof` on npm) and the same skill set.

package/dist/bin/rolepod-uiproof.js

@@ -175,7 +175,7 @@ function runInstallMobile() {
 
 // src/cli/replay.ts
 import { readFile } from "fs/promises";
-import { resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
 
 // src/artifact/ArtifactStore.ts
 import { randomUUID } from "crypto";
@@ -204,16 +204,49 @@ var log = {
 // src/artifact/ArtifactStore.ts
 var ArtifactStore = class {
   rootDir;
+  mode;
+  baselineRoot;
   constructor(opts = {}) {
-    this.rootDir = opts.rootDir ?? resolve2(process.cwd(), ".rolepod-uiproof", "artifacts");
+    const detectedParent = process.env.ROLEPOD_PARENT === "1";
+    this.mode = opts.mode ?? (detectedParent ? "with-parent" : "standalone");
+    if (opts.rootDir !== void 0) {
+      this.rootDir = opts.rootDir;
+    } else if (this.mode === "with-parent") {
+      this.rootDir = resolve2(process.cwd(), ".rolepod", "evidence");
+    } else {
+      this.rootDir = resolve2(process.cwd(), ".rolepod-uiproof", "artifacts");
+    }
+    this.baselineRoot = resolve2(process.cwd(), ".rolepod-uiproof", "baselines");
   }
-  /** Allocate a fresh run id and ensure its directory exists. */
-  async startRun(prefix = "run") {
-    const runId = `${prefix}_${this.timestampSlug()}_${randomUUID().slice(0, 8)}`;
+  /**
+   * Allocate a fresh run dir and ensure it exists.
+   *
+   * - standalone: `./.rolepod-uiproof/artifacts/{prefix}_{ts}_{uuid}/`
+   * - with-parent: `./.rolepod/evidence/{ts}-rolepod-uiproof-{skill}/`
+   *
+   * `prefix` is preserved for back-compat with v0.5 callers; new callers
+   * should also pass `opts.skill` so the with-parent path can be derived
+   * unambiguously and the manifest can be emitted with the canonical
+   * skill name.
+   */
+  async startRun(prefix = "run", opts = {}) {
+    const ts = this.timestampSlug();
+    const skill = opts.skill ?? prefix;
+    let runId;
+    if (this.mode === "with-parent") {
+      runId = `${ts}-rolepod-uiproof-${skill}`;
+    } else {
+      runId = `${prefix}_${ts}_${randomUUID().slice(0, 8)}`;
+    }
     const runDir = resolve2(this.rootDir, runId);
     await mkdir(runDir, { recursive: true });
-    log.debug("artifact run started", { run_id: runId, dir: runDir });
-    return { runId, runDir };
+    log.debug("artifact run started", {
+      run_id: runId,
+      dir: runDir,
+      mode: this.mode,
+      skill
+    });
+    return { runId, runDir, skill, mode: this.mode };
   }
   async writeScreenshot(runDir, buf, name) {
     const path = resolve2(runDir, `${name}.png`);
@@ -241,7 +274,7 @@ var ArtifactStore = class {
   }
   /** Root for stored visual baselines: `./.rolepod-uiproof/baselines/`. */
   get baselineDir() {
-    return resolve2(this.rootDir, "..", "baselines");
+    return this.baselineRoot;
   }
   timestampSlug() {
     const d = /* @__PURE__ */ new Date();
@@ -1170,21 +1203,21 @@ var PlaywrightEngine = class {
     if (s.dialogArming) {
       s.dialogArming.resolve(false);
     }
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       const arming = {
         action: opts.action,
         text: opts.text,
         expiresAt,
         resolve: (handled) => {
           s.dialogArming = null;
-          resolve6({ handled });
+          resolve7({ handled });
         }
       };
       s.dialogArming = arming;
       const timer = setTimeout(() => {
         if (s.dialogArming === arming) {
           s.dialogArming = null;
-          resolve6({ handled: false });
+          resolve7({ handled: false });
         }
       }, timeoutMs);
       timer.unref?.();
@@ -2035,6 +2068,37 @@ async function ddmin(input, reproduces) {
   return current;
 }
 
+// src/util/manifest.ts
+import { writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+var ROLEPOD_PROTOCOL_VERSION = "rolepod/v1";
+async function writeManifest(input) {
+  const manifest = {
+    protocol: ROLEPOD_PROTOCOL_VERSION,
+    plugin: "rolepod-uiproof",
+    skill: input.skill,
+    phase: input.phase,
+    status: input.status,
+    summary: input.summary,
+    started_at: input.startedAt,
+    finished_at: input.finishedAt,
+    artifacts: input.artifacts,
+    metadata: input.metadata ?? {}
+  };
+  const path = resolve3(input.runDir, "manifest.json");
+  try {
+    await writeFile2(path, JSON.stringify(manifest, null, 2), "utf8");
+    return path;
+  } catch (err) {
+    log.warn("manifest write failed", {
+      run_dir: input.runDir,
+      skill: input.skill,
+      err: String(err)
+    });
+    return void 0;
+  }
+}
+
 // src/tools/result.ts
 function ok(value) {
   return {
@@ -2076,7 +2140,11 @@ var verifyUiFlowTool = {
   inputShape: verifyUiFlowShape,
   build(ctx) {
     return safeHandler(async (args) => {
-      const { runId, runDir } = await ctx.store.startRun("verify");
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const { runId, runDir, skill } = await ctx.store.startRun(
+        "verify",
+        { skill: "verify-ui" }
+      );
       const initial = await runFlow(ctx, args, args.steps, runDir, {
         captureEvidence: true,
         bundleName: "replay.json"
@@ -2101,10 +2169,49 @@ var verifyUiFlowTool = {
           attempts: min.attempts
         };
       }
+      const manifestPath = await writeManifest({
+        runDir,
+        skill,
+        phase: "verify",
+        status: initial.passed ? "pass" : "fail",
+        summary: buildVerifySummary(args, initial),
+        startedAt,
+        finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        artifacts: flattenVerifyEvidence(initial.evidence),
+        metadata: {
+          mode: args.mode,
+          step_count: args.steps.length,
+          expect_count: args.expect.length,
+          ...initial.finalUrl !== void 0 ? { final_url: initial.finalUrl } : {}
+        }
+      });
+      if (manifestPath) result.manifest = manifestPath;
       return ok(result);
     });
   }
 };
+function buildVerifySummary(args, outcome) {
+  const stepCount = args.steps.length;
+  const expectCount = args.expect.length;
+  if (outcome.passed) {
+    return `${stepCount} step(s), ${expectCount} expect(s) passed`;
+  }
+  if (outcome.failedAtStep !== void 0) {
+    return `failed at step ${outcome.failedAtStep}: ${outcome.failureReason ?? "unknown"}`;
+  }
+  return `failed: ${outcome.failureReason ?? "unknown"}`;
+}
+function flattenVerifyEvidence(ev) {
+  const out = [];
+  for (const s of ev.screenshots) out.push({ type: "screenshot", path: s });
+  if (ev.replay_bundle) out.push({ type: "replay_bundle", path: ev.replay_bundle });
+  if (ev.console) out.push({ type: "console", path: ev.console });
+  if (ev.a11y_tree) out.push({ type: "a11y_tree", path: ev.a11y_tree });
+  if (ev.har) out.push({ type: "har", path: ev.har });
+  if (ev.trace) out.push({ type: "trace", path: ev.trace });
+  if (ev.video) for (const v of ev.video) out.push({ type: "video", path: v });
+  return out;
+}
 function buildCaptureOptions(captures, runDir) {
   const cap = {};
   if (captures.has("har")) {
@@ -2518,7 +2625,7 @@ function treeHasText(tree, text) {
 
 // src/cli/replay.ts
 async function runReplay(bundlePath) {
-  const abs = resolve3(bundlePath);
+  const abs = resolve4(bundlePath);
   const raw = await readFile(abs, "utf8");
   const bundle = JSON.parse(raw);
   if (bundle.version !== 1) {
@@ -3042,7 +3149,11 @@ var auditA11yTool = {
   inputShape: auditA11yShape,
   build(ctx) {
     return safeHandler(async (args) => {
-      const { runId, runDir } = await ctx.store.startRun("audit");
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const { runId, runDir, skill } = await ctx.store.startRun(
+        "audit",
+        { skill: "audit-a11y" }
+      );
       const session = await ctx.registry.open(args.open);
       const engine = ctx.registry.engineFor(session.id);
       if (!(engine instanceof PlaywrightEngine)) {
@@ -3110,15 +3221,45 @@ var auditA11yTool = {
           await ctx.registry.close(session).catch(() => void 0);
         }
       }
+      const counts = countBySeverity(issues);
+      const status = a11yStatus(counts);
+      const artifacts = reportPath ? [{ type: "report", path: reportPath }] : [];
+      const manifestPath = await writeManifest({
+        runDir,
+        skill,
+        phase: "verify",
+        status,
+        summary: buildAuditSummary(args.level, counts, status),
+        startedAt,
+        finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        artifacts,
+        metadata: {
+          level: args.level,
+          scope: args.scope,
+          counts,
+          report_format: args.report_format
+        }
+      });
       return ok({
         run_id: runId,
-        counts: countBySeverity(issues),
+        counts,
         issues,
-        report_path: reportPath
+        report_path: reportPath,
+        ...manifestPath ? { manifest: manifestPath } : {}
       });
     });
   }
 };
+function a11yStatus(counts) {
+  if ((counts.critical ?? 0) + (counts.serious ?? 0) > 0) return "fail";
+  if ((counts.moderate ?? 0) + (counts.minor ?? 0) > 0) return "warn";
+  return "pass";
+}
+function buildAuditSummary(level, counts, status) {
+  const total = (counts.critical ?? 0) + (counts.serious ?? 0) + (counts.moderate ?? 0) + (counts.minor ?? 0);
+  if (status === "pass") return `${level}: 0 issues`;
+  return `${level}: ${total} issue(s) \u2014 critical=${counts.critical ?? 0}, serious=${counts.serious ?? 0}, moderate=${counts.moderate ?? 0}, minor=${counts.minor ?? 0}`;
+}
 function pickWcagRef(tags) {
   return tags.find((t) => /^wcag\d/.test(t));
 }
@@ -3235,14 +3376,18 @@ function scoreTree(root, tokens) {
 
 // src/tools/composite/scaffold_e2e.ts
 import { readFile as readFile2 } from "fs/promises";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 var scaffoldE2eTool = {
   name: ToolNames.scaffoldE2e,
   description: "Generate a runnable e2e test file (playwright-test, vitest+playwright, or pytest+selenium) from a scenario description and optional replay bundle from a prior verify_ui_flow run.",
   inputShape: scaffoldE2eShape,
   build(ctx) {
     return safeHandler(async (args) => {
-      const { runId, runDir } = await ctx.store.startRun("scaffold");
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const { runId, runDir, skill } = await ctx.store.startRun(
+        "scaffold",
+        { skill: "scaffold-e2e" }
+      );
       const slug = slugify(args.scenario_nl);
       const bundle = args.recorded_bundle ? await loadReplay(args.recorded_bundle) : null;
       const ctxObj = { args, slug, bundle };
@@ -3280,19 +3425,35 @@ var scaffoldE2eTool = {
           );
       }
       const path = await ctx.store.writeReport(runDir, filename, body);
+      const manifestPath = await writeManifest({
+        runDir,
+        skill,
+        phase: "build",
+        status: "pass",
+        summary: `generated ${args.framework} test "${filename}" from ${bundle ? "replay bundle" : "scenario"}`,
+        startedAt,
+        finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        artifacts: [{ type: "test_file", path }],
+        metadata: {
+          framework: args.framework,
+          language,
+          from_replay_bundle: Boolean(bundle)
+        }
+      });
       return ok({
         run_id: runId,
         test_file_path: path,
         language,
         dependencies,
         setup_notes: setupNotes,
-        from_replay_bundle: Boolean(bundle)
+        from_replay_bundle: Boolean(bundle),
+        ...manifestPath ? { manifest: manifestPath } : {}
       });
     });
   }
 };
 async function loadReplay(bundlePath) {
-  const raw = await readFile2(resolve4(bundlePath), "utf8");
+  const raw = await readFile2(resolve5(bundlePath), "utf8");
   return JSON.parse(raw);
 }
 function slugify(s) {
@@ -3581,7 +3742,7 @@ function indent(block, n) {
 // src/tools/composite/visual_diff.ts
 import { existsSync as existsSync2 } from "fs";
 import { readFile as readFile3 } from "fs/promises";
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 import pixelmatch from "pixelmatch";
 import { PNG } from "pngjs";
 var visualDiffTool = {
@@ -3590,7 +3751,11 @@ var visualDiffTool = {
   inputShape: visualDiffShape,
   build(ctx) {
     return safeHandler(async (args) => {
-      const { runId, runDir } = await ctx.store.startRun("vdiff");
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const { runId, runDir, skill } = await ctx.store.startRun(
+        "vdiff",
+        { skill: "visual-diff" }
+      );
       const session = await ctx.registry.open({
         ...args.open,
         ...args.viewport ? { viewport: args.viewport } : {}
@@ -3609,7 +3774,7 @@ var visualDiffTool = {
         );
         const currentPath = await ctx.store.writeScreenshot(runDir, buf, "current");
         await ctx.store.ensureDir(ctx.store.baselineDir);
-        const baselinePath = resolve5(
+        const baselinePath = resolve6(
           ctx.store.baselineDir,
           `${args.baseline_id}.png`
         );
@@ -3619,6 +3784,20 @@ var visualDiffTool = {
             `${args.baseline_id}.png`,
             buf
           );
+          const manifestPath2 = await writeManifest({
+            runDir,
+            skill,
+            phase: "verify",
+            status: "pass",
+            summary: `baseline "${args.baseline_id}" seeded from current capture`,
+            startedAt,
+            finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            artifacts: [
+              { type: "baseline", path: baselinePath },
+              { type: "screenshot", path: currentPath }
+            ],
+            metadata: { baseline_id: args.baseline_id, seeded: true }
+          });
           return ok({
             run_id: runId,
             baseline_id: args.baseline_id,
@@ -3626,6 +3805,7 @@ var visualDiffTool = {
             passed: true,
             baseline_path: baselinePath,
             current_path: currentPath,
+            ...manifestPath2 ? { manifest: manifestPath2 } : {},
             note: "Baseline did not exist \u2014 current capture saved as the new baseline."
           });
         }
@@ -3656,21 +3836,45 @@ var visualDiffTool = {
         );
         const total = baseline.width * baseline.height;
         const diffPct = diffPixels / total;
+        const passed = diffPct <= args.threshold_pct;
         const diffImagePath = await ctx.store.writeBytes(
           runDir,
           "diff.png",
           PNG.sync.write(diff)
         );
+        const artifacts = [
+          { type: "baseline", path: baselinePath },
+          { type: "screenshot", path: currentPath },
+          { type: "diff", path: diffImagePath }
+        ];
+        const manifestPath = await writeManifest({
+          runDir,
+          skill,
+          phase: "verify",
+          status: passed ? "pass" : "fail",
+          summary: `diff ${(diffPct * 100).toFixed(3)}% vs baseline "${args.baseline_id}" (threshold ${(args.threshold_pct * 100).toFixed(3)}%)`,
+          startedAt,
+          finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          artifacts,
+          metadata: {
+            baseline_id: args.baseline_id,
+            diff_pct: Number(diffPct.toFixed(6)),
+            diff_pixels: diffPixels,
+            total_pixels: total,
+            threshold_pct: args.threshold_pct
+          }
+        });
         return ok({
           run_id: runId,
           baseline_id: args.baseline_id,
           diff_pct: Number(diffPct.toFixed(6)),
           diff_pixels: diffPixels,
           total_pixels: total,
-          passed: diffPct <= args.threshold_pct,
+          passed,
           baseline_path: baselinePath,
           current_path: currentPath,
-          diff_image_path: diffImagePath
+          diff_image_path: diffImagePath,
+          ...manifestPath ? { manifest: manifestPath } : {}
         });
       } finally {
         if (args.close_on_finish) {
@@ -3939,8 +4143,19 @@ var toolMetadata = {
 
 // src/server.ts
 var SERVER_NAME = "rolepod-uiproof";
-var SERVER_VERSION = "0.5.0";
+var SERVER_VERSION = "0.6.0";
+var SUPPORTED_PROTOCOL = "v1";
+function checkProtocolCompat() {
+  const requested = process.env.ROLEPOD_PROTOCOL;
+  if (!requested) return;
+  if (requested !== SUPPORTED_PROTOCOL) {
+    console.warn(
+      `rolepod protocol mismatch: expected ${SUPPORTED_PROTOCOL}, got ${requested}. Manifest will still be written in ${SUPPORTED_PROTOCOL} shape \u2014 parent may not parse it correctly.`
+    );
+  }
+}
 function buildServer(opts = {}) {
+  checkProtocolCompat();
   const webEngine = createWebEngine();
   const registry = new SessionRegistry({ idleTimeoutMs: opts.idleTimeoutMs });
   registry.register("web", webEngine);
@@ -4001,6 +4216,8 @@ function buildServer(opts = {}) {
   }
   log.info("rolepod-uiproof server built", {
     version: SERVER_VERSION,
+    protocol: SUPPORTED_PROTOCOL,
+    mode: store.mode,
     tools: tools.map((t) => t.name)
   });
   return {