harnery 0.26.0 → 0.28.0

package/dist/lib/browser/client.js

@@ -155,6 +155,109 @@ export class Browser {
         const buf = await page.screenshot({ path, fullPage: opts.fullPage ?? true, type: "png" });
         return buf.length;
     }
+    /**
+     * Capture a full-page screenshot from an explicit capture viewport and
+     * evaluate the caller's final evidence expression immediately before the
+     * pixels are written. Playwright normally manages the full-page viewport
+     * internally, which leaves callers unable to inspect fixed/sticky geometry
+     * in the state the PNG actually renders.
+     */
+    async screenshotWithEvaluation(path, evaluation, opts = {}) {
+        const page = this.currentPage;
+        const fullPage = opts.fullPage ?? true;
+        const maxPasses = 4;
+        const maxDimension = 32_000;
+        const maxPixels = 128_000_000;
+        const documentExtent = () => page.evaluate(() => ({
+            width: Math.max(document.documentElement.scrollWidth, document.body?.scrollWidth ?? 0),
+            height: Math.max(document.documentElement.scrollHeight, document.body?.scrollHeight ?? 0),
+        }));
+        const originalViewport = page.viewportSize();
+        if (!originalViewport) {
+            throw new Error("Capture-state evaluation requires a page with an explicit viewport.");
+        }
+        let captureViewport = originalViewport;
+        let passes = fullPage ? 0 : 1;
+        let extentBeforeEvaluation = await documentExtent();
+        let bounded = true;
+        if (fullPage) {
+            for (let pass = 0; pass < maxPasses; pass += 1) {
+                passes = pass + 1;
+                const nextViewport = {
+                    width: originalViewport.width,
+                    height: Math.max(originalViewport.height, Math.ceil(extentBeforeEvaluation.height)),
+                };
+                bounded =
+                    nextViewport.width <= maxDimension &&
+                        nextViewport.height <= maxDimension &&
+                        nextViewport.width * nextViewport.height <= maxPixels;
+                if (!bounded)
+                    break;
+                if (nextViewport.width === captureViewport.width &&
+                    nextViewport.height === captureViewport.height &&
+                    extentBeforeEvaluation.width <= captureViewport.width &&
+                    extentBeforeEvaluation.height === captureViewport.height) {
+                    break;
+                }
+                captureViewport = nextViewport;
+                await page.setViewportSize(captureViewport);
+                extentBeforeEvaluation = await documentExtent();
+            }
+        }
+        try {
+            const evaluationResult = await page.evaluate(evaluation);
+            const extentAfterEvaluation = await documentExtent();
+            const buf = await page.screenshot({ path, fullPage: fullPage && bounded, type: "png" });
+            const extentAfterScreenshot = await documentExtent();
+            const screenshot = {
+                width: buf.readUInt32BE(16),
+                height: buf.readUInt32BE(20),
+                bytes: buf.length,
+            };
+            const exact = fullPage
+                ? bounded &&
+                    captureViewport.width === extentBeforeEvaluation.width &&
+                    captureViewport.height === extentBeforeEvaluation.height &&
+                    captureViewport.width === extentAfterEvaluation.width &&
+                    captureViewport.height === extentAfterEvaluation.height &&
+                    captureViewport.width === extentAfterScreenshot.width &&
+                    captureViewport.height === extentAfterScreenshot.height &&
+                    captureViewport.width === screenshot.width &&
+                    captureViewport.height === screenshot.height
+                : captureViewport.width === screenshot.width &&
+                    captureViewport.height === screenshot.height;
+            const reason = !bounded
+                ? "capture_bounds_exceeded"
+                : exact
+                    ? "capture_viewport_converged"
+                    : "capture_viewport_non_convergent";
+            return {
+                bytes: buf.length,
+                evaluation: evaluationResult,
+                viewport: captureViewport,
+                evidence: {
+                    converged: exact,
+                    reason,
+                    passes,
+                    max_passes: maxPasses,
+                    max_dimension: maxDimension,
+                    max_pixels: maxPixels,
+                    original_viewport: originalViewport,
+                    evaluated_viewport: captureViewport,
+                    document_extent_before_evaluation: extentBeforeEvaluation,
+                    document_extent_after_evaluation: extentAfterEvaluation,
+                    document_extent_after_screenshot: extentAfterScreenshot,
+                    screenshot,
+                },
+            };
+        }
+        finally {
+            if (captureViewport.width !== originalViewport.width ||
+                captureViewport.height !== originalViewport.height) {
+                await page.setViewportSize(originalViewport);
+            }
+        }
+    }
     /**
      * Plain-text snapshot of the document body. Suitable as a coarse "what's
      * on screen" signal for LLM iteration loops. For richer extraction, use

package/dist/lib/exec.d.ts

@@ -10,6 +10,10 @@ export interface ExecResult {
     stdout: string;
     stderr: string;
     exitCode: number;
+    /** True when this process killed the child for exceeding `opts.timeout`. A
+     * child that handles the signal cleanly still exits 0, so the exit code alone
+     * cannot distinguish a kill from an ordinary finish. */
+    timedOut?: boolean;
 }
 export interface ExecOpts {
     cwd?: string;

package/dist/lib/exec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exec.d.ts","sourceRoot":"","sources":["../../src/lib/exec.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,QAAQ;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE,QAAa,GAAG,OAAO,CAAC,UAAU,CAAC,CAmC5E;AAED,sEAAsE;AACtE,wBAAsB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAEhG"}
+{"version":3,"file":"exec.d.ts","sourceRoot":"","sources":["../../src/lib/exec.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB;;4DAEwD;IACxD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,QAAQ;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE,QAAa,GAAG,OAAO,CAAC,UAAU,CAAC,CAwC5E;AAED,sEAAsE;AACtE,wBAAsB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAEhG"}

package/dist/lib/exec.js

@@ -29,7 +29,11 @@ export function exec(cmd, opts = {}) {
         proc.stdout?.on("data", (d) => out.push(d));
         proc.stderr?.on("data", (d) => err.push(d));
         const timeout = opts.timeout ?? 30_000;
-        const timer = setTimeout(() => proc.kill(), timeout);
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            proc.kill();
+        }, timeout);
         const finish = (exitCode, errOverride) => {
             clearTimeout(timer);
             const stdout = Buffer.concat(out).toString("utf-8");
@@ -39,6 +43,7 @@ export function exec(cmd, opts = {}) {
                 stdout: shouldTrim ? stdout.trim() : stdout.replace(/\n$/, ""),
                 stderr: shouldTrim ? stderr.trim() : stderr.replace(/\n$/, ""),
                 exitCode,
+                ...(timedOut ? { timedOut: true } : {}),
             });
         };
         // ENOENT (binary not found) and similar spawn failures surface here rather

package/dist/lib/tunnel/error-page.d.ts

@@ -0,0 +1,15 @@
+export interface TunnelErrorPageOptions {
+    kind: "access-denied" | "upstream-unavailable";
+    incidentId: string;
+    timestamp: string;
+    tunnelName: string;
+    method: string;
+    path: string;
+    clientIp: string;
+    cloudflareRay: string;
+    target?: string;
+    errorCode?: string;
+    errorMessage?: string;
+}
+export declare function renderTunnelErrorPage(options: TunnelErrorPageOptions): string;
+//# sourceMappingURL=error-page.d.ts.map

package/dist/lib/tunnel/error-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-page.d.ts","sourceRoot":"","sources":["../../../src/lib/tunnel/error-page.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,eAAe,GAAG,sBAAsB,CAAC;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA6BD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,GAAG,MAAM,CAwE7E"}

package/dist/lib/tunnel/error-page.js

@@ -0,0 +1,98 @@
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#039;");
+}
+function diagnosticText(options) {
+    const lines = [
+        `Tunnel incident: ${options.incidentId}`,
+        `Time: ${options.timestamp}`,
+        `Problem: ${options.kind}`,
+        `Tunnel: ${options.tunnelName}`,
+        `Request: ${options.method} ${options.path}`,
+        `Client IP: ${options.clientIp || "(not provided by proxy)"}`,
+        `Cloudflare Ray: ${options.cloudflareRay || "(not provided)"}`,
+    ];
+    if (options.target)
+        lines.push(`Upstream: ${options.target}`);
+    if (options.errorCode)
+        lines.push(`Error code: ${options.errorCode}`);
+    if (options.errorMessage)
+        lines.push(`Error: ${options.errorMessage}`);
+    return lines.join("\n");
+}
+export function renderTunnelErrorPage(options) {
+    const denied = options.kind === "access-denied";
+    const title = denied ? "This device is not allowed yet" : "The preview is temporarily offline";
+    const summary = denied
+        ? "The tunnel is running, but this device's public IP is not on its access list."
+        : "The public tunnel and access check are working, but the local preview server is not responding.";
+    const nextStep = denied
+        ? "Copy the diagnostic below and send it to the person running the tunnel. It includes the public IP that needs to be allowed."
+        : "Copy the diagnostic below and send it to the person running the tunnel. The incident ID can be matched to the server log.";
+    const diagnostic = diagnosticText(options);
+    const safeDiagnosticForScript = JSON.stringify(diagnostic).replaceAll("<", "\\u003c");
+    return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <meta name="robots" content="noindex,nofollow">
+  <title>${escapeHtml(title)}</title>
+  <style>
+    :root { color-scheme: light; font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+    * { box-sizing: border-box; }
+    body { margin: 0; min-height: 100vh; background: #f4f2ed; color: #17211c; display: grid; place-items: center; padding: 24px; }
+    main { width: min(100%, 720px); background: #fff; border: 1px solid #d8d4ca; border-radius: 18px; box-shadow: 0 18px 50px rgba(23, 33, 28, .10); overflow: hidden; }
+    .bar { height: 8px; background: ${denied ? "#b54708" : "#b42318"}; }
+    .content { padding: clamp(24px, 5vw, 48px); }
+    .eyebrow { margin: 0 0 10px; color: ${denied ? "#8a3708" : "#912018"}; font-size: 13px; font-weight: 750; letter-spacing: .09em; text-transform: uppercase; }
+    h1 { margin: 0; max-width: 18ch; font-size: clamp(30px, 7vw, 48px); line-height: 1.02; letter-spacing: -.04em; }
+    .summary { margin: 20px 0 10px; max-width: 58ch; font-size: 18px; line-height: 1.55; }
+    .next { margin: 0 0 24px; max-width: 62ch; color: #536058; line-height: 1.55; }
+    .diagnostic-wrap { position: relative; }
+    pre { margin: 0; padding: 18px; border: 1px solid #ccd2cd; border-radius: 12px; background: #111814; color: #edf5ef; font: 13px/1.55 ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; white-space: pre-wrap; overflow-wrap: anywhere; }
+    button { width: 100%; margin-top: 12px; border: 0; border-radius: 11px; padding: 14px 18px; background: #17643a; color: #fff; font: inherit; font-weight: 750; cursor: pointer; }
+    button:hover { background: #0e5230; }
+    button:focus-visible { outline: 3px solid #87c89f; outline-offset: 3px; }
+    .incident { margin: 18px 0 0; color: #68736c; font-size: 13px; text-align: center; }
+  </style>
+</head>
+<body>
+  <main>
+    <div class="bar"></div>
+    <div class="content">
+      <p class="eyebrow">Tunnel diagnostic</p>
+      <h1>${escapeHtml(title)}</h1>
+      <p class="summary">${escapeHtml(summary)}</p>
+      <p class="next">${escapeHtml(nextStep)}</p>
+      <div class="diagnostic-wrap">
+        <pre id="diagnostic">${escapeHtml(diagnostic)}</pre>
+        <button id="copy" type="button">Copy diagnostic</button>
+      </div>
+      <p class="incident">Incident ${escapeHtml(options.incidentId)}</p>
+    </div>
+  </main>
+  <script>
+    const diagnostic = ${safeDiagnosticForScript};
+    const button = document.getElementById("copy");
+    button.addEventListener("click", async () => {
+      try {
+        await navigator.clipboard.writeText(diagnostic);
+        button.textContent = "Copied";
+      } catch {
+        const range = document.createRange();
+        range.selectNodeContents(document.getElementById("diagnostic"));
+        const selection = window.getSelection();
+        selection.removeAllRanges();
+        selection.addRange(range);
+        button.textContent = "Selected — copy now";
+      }
+    });
+  </script>
+</body>
+</html>`;
+}

package/dist/lib/tunnel/gate.d.ts

@@ -1,13 +1,2 @@
-declare function argvFlag(flag: string): string | undefined;
-declare const ALLOW: Set<string>;
-declare const TARGET: string;
-declare const VHOST: string;
-declare const PORT: number;
-declare const ACCESS: string;
-declare const UPSTREAM_HTTP: string;
-declare const UPSTREAM_WS: string;
-interface WsData {
-    path: string;
-}
-declare const server: Bun.Server<WsData>;
+export {};
 //# sourceMappingURL=gate.d.ts.map

package/dist/lib/tunnel/gate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../../src/lib/tunnel/gate.ts"],"names":[],"mappings":"AAiBA,iBAAS,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGlD;AAED,QAAA,MAAM,KAAK,aAKV,CAAC;AACF,QAAA,MAAM,MAAM,QAAwD,CAAC;AACrE,QAAA,MAAM,KAAK,QAAkD,CAAC;AAC9D,QAAA,MAAM,IAAI,QAA0E,CAAC;AACrF,QAAA,MAAM,MAAM,QAA8D,CAAC;AAE3E,QAAA,MAAM,aAAa,QAAqB,CAAC;AACzC,QAAA,MAAM,WAAW,QAAmB,CAAC;AAErC,UAAU,MAAM;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAED,QAAA,MAAM,MAAM,oBA4EV,CAAC"}
+{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../../src/lib/tunnel/gate.ts"],"names":[],"mappings":""}

package/dist/lib/tunnel/gate.js

@@ -1,4 +1,3 @@
-"use strict";
 // Reverse-proxy worker spawned by `tunnel up`. Listens on 127.0.0.1:<port>
 // and forwards HTTP + WebSocket requests to an upstream with a Host header
 // rewrite and Content-Encoding stripped (Bun's fetch auto-decompresses the
@@ -9,6 +8,7 @@
 // Runs detached, outside the CLI command framework; no command context is
 // available; stdout/stderr is captured into .cache/tunnel/gate.log by the
 // spawner.
+import { renderTunnelErrorPage } from "./error-page";
 // `--port`/`--name` are also passed on argv (not just env) so the gate's port
 // and instance name show up in its process command line. That's what lets
 // `tunnel down` scope its stray-process sweep to a single instance via
@@ -27,8 +27,27 @@ const TARGET = process.env.HARNERY_TUNNEL_TARGET ?? "127.0.0.1:8001";
 const VHOST = process.env.HARNERY_TUNNEL_VHOST ?? "localhost";
 const PORT = Number(process.env.HARNERY_TUNNEL_PORT ?? argvFlag("--port") ?? "9001");
 const ACCESS = process.env.HARNERY_TUNNEL_ACCESS ?? "cloudflare-allowlist";
+const NAME = argvFlag("--name") ?? "default";
 const UPSTREAM_HTTP = `http://${TARGET}`;
 const UPSTREAM_WS = `ws://${TARGET}`;
+function requestDetails(req, url) {
+    return {
+        incidentId: crypto.randomUUID().slice(0, 8),
+        timestamp: new Date().toISOString(),
+        tunnelName: NAME,
+        method: req.method,
+        path: url.pathname + url.search,
+        clientIp: req.headers.get("cf-connecting-ip") ?? "",
+        cloudflareRay: req.headers.get("cf-ray") ?? "",
+    };
+}
+function errorDetails(error) {
+    if (!(error instanceof Error)) {
+        return { code: "UnknownError", message: String(error) };
+    }
+    const code = "code" in error && typeof error.code === "string" ? error.code : error.name || "Error";
+    return { code, message: error.message || "The upstream request failed." };
+}
 const server = Bun.serve({
     port: PORT,
     hostname: "127.0.0.1",
@@ -42,12 +61,20 @@ const server = Bun.serve({
         if (ACCESS === "cloudflare-allowlist") {
             const ip = req.headers.get("cf-connecting-ip") ?? "";
             if (!ALLOW.has(ip)) {
+                const details = requestDetails(req, url);
                 // Log denials so operators can whitelist a phone/laptop that just
                 // hit 403 without asking the human to dig up their public IP.
                 console.log(
                 // lint-ok-emission: detached worker, see file note above
-                `deny: ${ip || "(missing-cf-connecting-ip)"} ${req.method} ${url.pathname}`);
-                return new Response("403 Forbidden\n", { status: 403 });
+                `deny: incident=${details.incidentId} ip=${ip || "(missing-cf-connecting-ip)"} ray=${details.cloudflareRay || "(missing)"} ${req.method} ${details.path}`);
+                return new Response(renderTunnelErrorPage({ ...details, kind: "access-denied" }), {
+                    status: 403,
+                    headers: {
+                        "cache-control": "no-store",
+                        "content-type": "text/html; charset=utf-8",
+                        "x-harnery-tunnel-incident": details.incidentId,
+                    },
+                });
             }
         }
         if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
@@ -68,7 +95,35 @@ const server = Bun.serve({
         if (!["GET", "HEAD"].includes(req.method)) {
             init.body = await req.arrayBuffer();
         }
-        const resp = await fetch(UPSTREAM_HTTP + url.pathname + url.search, init);
+        let resp;
+        try {
+            resp = await fetch(UPSTREAM_HTTP + url.pathname + url.search, init);
+        }
+        catch (error) {
+            const details = requestDetails(req, url);
+            const failure = errorDetails(error);
+            console.log(
+            // lint-ok-emission: detached worker, see file note above
+            `upstream-error: incident=${details.incidentId} ip=${details.clientIp || "(missing-cf-connecting-ip)"} ray=${details.cloudflareRay || "(missing)"} code=${failure.code} ${req.method} ${details.path}`);
+            return new Response(renderTunnelErrorPage({
+                ...details,
+                kind: "upstream-unavailable",
+                target: UPSTREAM_HTTP,
+                errorCode: failure.code,
+                errorMessage: failure.message,
+            }), {
+                // Cloudflare replaces 502 response bodies with its own generic error
+                // page. Return the diagnostic as a successful document and preserve
+                // the semantic status in a header so the human can actually see it.
+                status: 200,
+                headers: {
+                    "cache-control": "no-store",
+                    "content-type": "text/html; charset=utf-8",
+                    "x-harnery-tunnel-incident": details.incidentId,
+                    "x-harnery-tunnel-status": "502",
+                },
+            });
+        }
         const respHeaders = new Headers(resp.headers);
         respHeaders.delete("content-encoding");
         respHeaders.delete("content-length");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harnery",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "description": "Multi-agent coordination for AI coding agents - Claude Code, Cursor, and Codex.",
   "license": "MIT",
   "author": "Ryan Kelly",

package/src/commands/browse.ts

@@ -67,6 +67,7 @@ interface BrowseOpts {
   press?: string;
   waitFor?: string;
   evaluate?: string;
+  captureEvaluate?: string;
   batch?: string;
   networkHar?: string;
   login?: boolean;
@@ -179,6 +180,10 @@ export function registerBrowseCommand(
       "--evaluate <js>",
       "Run JS in the page context after navigation; result printed to stdout",
     )
+    .option(
+      "--capture-evaluate <js>",
+      "In trio mode, evaluate JS inside the exact screenshot viewport immediately before capture; result is written as captureEval",
+    )
     .option(
       "--batch <steps>",
       "Run multiple steps in one session, semicolon-separated. Each step is one of: " +
@@ -601,6 +606,11 @@ async function runBrowse(
     }
 
     if (printMode) {
+      if (opts.captureEvaluate) {
+        throw new Error(
+          "--capture-evaluate requires trio mode so its result can be bound to a screenshot.",
+        );
+      }
       if (opts.baseline || opts.diff) {
         throw new Error(
           "--baseline / --diff require trio mode (screenshot file). Remove --snapshot/--html/--json or capture the screenshot first.",
@@ -911,10 +921,27 @@ async function runTrioMode(
   const skipScreenshot = opts.screenshot === false || opts.domOnly === true;
   let pngPath: string | undefined;
   let pngBytes: number | undefined;
+  let captureEvalResult: unknown;
+  let captureViewport: { width: number; height: number } | undefined;
+  let captureEvidence: unknown;
   if (!skipScreenshot) {
     pngPath = `${prefix}.png`;
-    pngBytes = await browser.screenshot(pngPath, { fullPage: opts.fullPage !== false });
+    if (opts.captureEvaluate) {
+      const captured = await browser.screenshotWithEvaluation(pngPath, opts.captureEvaluate, {
+        fullPage: opts.fullPage !== false,
+      });
+      pngBytes = captured.bytes;
+      captureEvalResult = captured.evaluation;
+      captureViewport = captured.viewport;
+      captureEvidence = captured.evidence;
+    } else {
+      pngBytes = await browser.screenshot(pngPath, { fullPage: opts.fullPage !== false });
+    }
     written.push(pngPath);
+  } else if (opts.captureEvaluate) {
+    throw new Error(
+      "--capture-evaluate requires a screenshot; remove --no-screenshot / --dom-only.",
+    );
   }
 
   const htmlPath = `${prefix}.html`;
@@ -937,6 +964,11 @@ async function runTrioMode(
   };
   if (pngBytes !== undefined) envelope.screenshotBytes = pngBytes;
   if (opts.evaluate) envelope.eval = evalResult;
+  if (opts.captureEvaluate) {
+    envelope.captureEval = captureEvalResult;
+    envelope.captureViewport = captureViewport;
+    envelope.captureEvidence = captureEvidence;
+  }
   if (opts.networkHar) envelope.har = resolve(opts.networkHar);
   if (visibility) envelope.visibility = visibility;
   if (widths) envelope.width = widths;

package/src/commands/harness.ts

@@ -24,6 +24,7 @@ interface AttestOpts extends FormatOpts {
   timeout?: string;
   yes?: boolean;
   subscriptionOnly?: boolean;
+  projection?: boolean;
 }
 
 const registry = createBuiltinHarnessRegistry();
@@ -101,6 +102,10 @@ export function registerHarnessCommand(program: Command, emit: EmitContext): voi
       "Scrub API-key vars so the child uses its stored login (repo default via config.jsonc workflow.subscriptionOnly)",
     )
     .option("--timeout <ms>", "Per-harness probe timeout in milliseconds")
+    .option(
+      "--projection",
+      "Also probe whether a declared sandbox is enforced; costs two extra turns per capable harness",
+    )
     .option("--json", "Machine-readable attestation report")
     .action(async (harnesses: string[], opts: AttestOpts) => {
       if (!opts.yes) {
@@ -127,6 +132,7 @@ export function registerHarnessCommand(program: Command, emit: EmitContext): voi
           harnesses,
           timeoutMs,
           subscriptionOnly,
+          projection: opts.projection === true,
         });
         if (opts.json) {
           emit.config({ format: "json" });

package/src/commands/work.ts

@@ -19,6 +19,7 @@ import {
   reconcileWorkItem,
   reopenWorkItem,
   runWorkItem,
+  type WorkAttempt,
   type WorkRecord,
 } from "../core/work/index.ts";
 import { WorkflowParkedError } from "../core/workflow/index.ts";
@@ -52,8 +53,12 @@ interface GovernanceOpts {
   actor?: string;
   reason?: string;
   json?: boolean;
+  finding?: string[];
+  dispose?: string[];
 }
 
+const MAX_ATTEMPT_JOURNAL_ERROR_RENDER = 240;
+
 export function registerWorkCommand(program: Command, emit: EmitContext): void {
   const registry = createBuiltinHarnessRegistry();
   const harnesses = registry.ids();
@@ -257,14 +262,66 @@ function registerGovernanceCommand(
     )
     .option("--actor <name>", "Actor recorded in the governance receipt")
     .option("--reason <text>", "Bounded decision reason")
-    .option("--json", "Emit the complete work record as JSON")
-    .action((workId: string, opts: GovernanceOpts) => {
-      withWorkRoot(emit, (coordRoot) => {
-        const fn =
-          name === "accept" ? acceptWorkItem : name === "cancel" ? cancelWorkItem : reopenWorkItem;
-        emitWork(fn(coordRoot, workId, opts), opts.json, emit, true);
-      });
+    .option("--json", "Emit the complete work record as JSON");
+  const command = work.commands.at(-1) as Command;
+  if (name === "reopen") {
+    command.option(
+      "--finding <text>",
+      "Correction the next attempt must address (repeatable)",
+      collectValue,
+      [] as string[],
+    );
+  }
+  if (name === "accept") {
+    command.option(
+      "--dispose <id=outcome[:reason]>",
+      "Dispose of an open finding: fixed, or deferred:<reason> (repeatable)",
+      collectValue,
+      [] as string[],
+    );
+  }
+  command.action((workId: string, opts: GovernanceOpts) => {
+    withWorkRoot(emit, (coordRoot) => {
+      const fn =
+        name === "accept" ? acceptWorkItem : name === "cancel" ? cancelWorkItem : reopenWorkItem;
+      emitWork(
+        fn(coordRoot, workId, {
+          ...opts,
+          ...(opts.finding?.length ? { findings: opts.finding } : {}),
+          ...(opts.dispose?.length ? { dispositions: opts.dispose.map(parseDisposition) } : {}),
+        }),
+        opts.json,
+        emit,
+        true,
+      );
     });
+  });
+}
+
+function collectValue(value: string, previous: string[]): string[] {
+  return [...previous, value];
+}
+
+/** `<id>=fixed` or `<id>=deferred:<reason>`. Deferring without a reason is
+ * rejected downstream, so a lapsed finding cannot look like a decision. */
+function parseDisposition(input: string): {
+  id: string;
+  outcome: "fixed" | "deferred";
+  reason?: string;
+} {
+  const split = input.indexOf("=");
+  if (split <= 0)
+    throw new Error(`invalid --dispose ${JSON.stringify(input)}; expected <id>=<outcome>`);
+  const id = input.slice(0, split).trim();
+  const rest = input.slice(split + 1).trim();
+  const [outcome, ...reasonParts] = rest.split(":");
+  if (outcome !== "fixed" && outcome !== "deferred") {
+    throw new Error(
+      `invalid --dispose outcome ${JSON.stringify(outcome)}; expected fixed or deferred`,
+    );
+  }
+  const reason = reasonParts.join(":").trim();
+  return { id, outcome, ...(reason ? { reason } : {}) };
 }
 
 function emitWork(
@@ -297,18 +354,28 @@ function emitWork(
     lines.push("acceptance:", ...record.intent.acceptance.map((item) => `  - ${item}`));
   }
   if (projection.attempts.length) {
-    lines.push(
-      "attempts:",
-      ...projection.attempts.map(
-        (attempt) => `  ${attempt.number}. ${attempt.run_id}  ${attempt.status}`,
-      ),
-    );
+    lines.push("attempts:", ...projection.attempts.map(renderAttemptRow));
   }
   if (projection.approval_id) lines.push(`approval: ${projection.approval_id}`);
   if (projection.proof_path) lines.push(`proof: ${projection.proof_path}`);
   emit.text(`${lines.join("\n")}\n`);
 }
 
+export function renderAttemptRow(attempt: WorkAttempt): string {
+  const statusDetail =
+    attempt.status === "journal_unreadable"
+      ? `: ${renderAttemptJournalError(attempt.journal_error)}`
+      : "";
+  return `  ${attempt.number}. ${attempt.run_id}  ${attempt.status}${statusDetail}`;
+}
+
+function renderAttemptJournalError(error: string | undefined): string {
+  const normalized = (error ?? "").replace(/\s+/g, " ").trim();
+  const value = normalized || "unknown journal read error";
+  if (value.length <= MAX_ATTEMPT_JOURNAL_ERROR_RENDER) return value;
+  return `${value.slice(0, MAX_ATTEMPT_JOURNAL_ERROR_RENDER - 3).trimEnd()}...`;
+}
+
 function renderWorkRow(record: WorkRecord): string {
   const projection = record.projection;
   return `${record.intent.id}  ${projection.state.padEnd(17)}  ${projection.attempts_used}/${record.intent.max_attempts}  ${projection.next_action.padEnd(21)}  ${record.intent.title}`;