harnery 0.27.0 → 0.28.0

package/src/core/workflow/spawn-codex.ts

@@ -61,6 +61,14 @@ export function buildCodexInvocation(req: SpawnRequest, resultFile?: string): Ha
 }
 
 export function normalizeCodexResult(raw: HarnessRawResult): SpawnResult {
+  if (raw.timedOut) {
+    return {
+      ok: false,
+      text: "",
+      durationMs: raw.durationMs,
+      error: `codex timed out after ${raw.durationMs}ms and was killed`,
+    };
+  }
   if (raw.exitCode === 127) {
     return { ok: false, text: "", durationMs: raw.durationMs, error: notFoundError("codex") };
   }

package/src/core/workflow/spawn-cursor.ts

@@ -74,6 +74,14 @@ export function buildCursorInvocation(req: SpawnRequest): HarnessInvocation {
 }
 
 export function normalizeCursorResult(raw: HarnessRawResult): SpawnResult {
+  if (raw.timedOut) {
+    return {
+      ok: false,
+      text: "",
+      durationMs: raw.durationMs,
+      error: `cursor timed out after ${raw.durationMs}ms and was killed`,
+    };
+  }
   if (raw.exitCode === 127) {
     return { ok: false, text: "", durationMs: raw.durationMs, error: notFoundError("cursor") };
   }

package/src/core/workflow/types.ts

@@ -427,6 +427,18 @@ export interface WorkflowAttemptContext {
   readonly number: number;
   readonly trigger: "initial" | "retry";
   readonly prior?: Readonly<WorkflowAttemptPriorContext>;
+  /** Open findings an operator raised against a prior attempt. Present on any
+   * trigger, because a reopen with findings starts a fresh initial attempt.
+   * Distinct from `prior`, which is evidence the run itself produced. */
+  readonly findings?: readonly Readonly<WorkflowOperatorFinding>[];
+}
+
+/** One correction an operator raised against work they judged wrong. Authored
+ * by a human, not derived from proof, and carried until explicitly disposed. */
+export interface WorkflowOperatorFinding {
+  readonly id: string;
+  readonly actor: string;
+  readonly statement: string;
 }
 
 export interface EngineOpts {

package/src/core/workflow/workspaces/state.ts

@@ -17,6 +17,9 @@ import {
   stableDigest,
   writeImmutableJson,
 } from "../durable-record.ts";
+
+export { appendWorkflowJournalEvent } from "../journal.ts";
+
 import type {
   GitRepositoryBinding,
   IntegrationApplyAttempt,
@@ -34,7 +37,7 @@ import type {
 } from "./types.ts";
 
 const JSON_LIMIT = 512 * 1024;
-const EVENT_LIMIT = 32 * 1024;
+const WORKSPACE_EVENT_BYTES = 32 * 1024;
 const ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/;
 
 export interface WorkspaceClaim {
@@ -181,7 +184,11 @@ export function appendWorkspaceEvent(
   event: string,
   data: Record<string, unknown> = {},
 ): WorkspaceProviderEvent {
-  if (!event || event.length > 100 || Buffer.byteLength(JSON.stringify(data)) > EVENT_LIMIT / 2) {
+  if (
+    !event ||
+    event.length > 100 ||
+    Buffer.byteLength(JSON.stringify(data)) > WORKSPACE_EVENT_BYTES / 2
+  ) {
     throw new Error("workspace provider event is invalid or too large");
   }
   const path = workspaceEventsPath(coordRoot, claim.provider_id, claim.binding_id);
@@ -204,7 +211,7 @@ export function appendWorkspaceEvent(
     record_sha256: stableDigest(basis),
   };
   const line = `${canonicalJson(record)}\n`;
-  if (Buffer.byteLength(line) > EVENT_LIMIT)
+  if (Buffer.byteLength(line) > WORKSPACE_EVENT_BYTES)
     throw new Error("workspace provider event is too large");
   const fd = openSync(path, "a", 0o600);
   try {
@@ -232,7 +239,7 @@ export function readWorkspaceEvents(
     .split("\n")
     .filter(Boolean)
     .map((line, index) => {
-      if (Buffer.byteLength(line) > EVENT_LIMIT) {
+      if (Buffer.byteLength(line) > WORKSPACE_EVENT_BYTES) {
         throw new Error(`workspace event ${index + 1} is too large`);
       }
       let record: WorkspaceProviderEvent;
@@ -270,33 +277,6 @@ function recordsDigestPlaceholder(): null {
   return null;
 }
 
-export function appendWorkflowJournalEvent(
-  coordRoot: string,
-  runId: string,
-  event: string,
-  data: Record<string, unknown>,
-): void {
-  const path = join(workflowRunDir(coordRoot, runId), "journal.jsonl");
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-  const existed = existsSync(path);
-  const line = `${JSON.stringify({
-    schema_version: 1,
-    run_id: runId,
-    ts: new Date().toISOString(),
-    event,
-    ...data,
-  })}\n`;
-  if (Buffer.byteLength(line) > EVENT_LIMIT) throw new Error("workflow journal event is too large");
-  const fd = openSync(path, "a", 0o600);
-  try {
-    writeFileSync(fd, line, "utf8");
-    fsyncSync(fd);
-  } finally {
-    closeSync(fd);
-  }
-  if (!existed) fsyncParentDirectory(path);
-}
-
 export type WorkflowSupplement =
   | WorkspaceBinding
   | IntegrationReviewRecord
@@ -327,7 +307,7 @@ export function appendCleanupAttempt(
     record_sha256: stableDigest(basis),
   };
   const line = `${canonicalJson(attempt)}\n`;
-  if (Buffer.byteLength(line) > EVENT_LIMIT) {
+  if (Buffer.byteLength(line) > WORKSPACE_EVENT_BYTES) {
     throw new Error("workspace cleanup attempt is too large");
   }
   const fd = openSync(path, "a", 0o600);
@@ -388,7 +368,7 @@ function appendChainedRecord(
   label: string,
 ): void {
   const line = `${canonicalJson(record)}\n`;
-  if (Buffer.byteLength(line) > EVENT_LIMIT) {
+  if (Buffer.byteLength(line) > WORKSPACE_EVENT_BYTES) {
     throw new Error(`${label} is too large`);
   }
   const fd = openSync(path, "a", 0o600);

package/src/lib/browser/client.ts

@@ -295,6 +295,135 @@ export class Browser {
     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<T = unknown>(
+    path: string,
+    evaluation: string,
+    opts: { fullPage?: boolean } = {},
+  ): Promise<{
+    bytes: number;
+    evaluation: T;
+    viewport: { width: number; height: number };
+    evidence: {
+      converged: boolean;
+      reason: string;
+      passes: number;
+      max_passes: number;
+      max_dimension: number;
+      max_pixels: number;
+      original_viewport: { width: number; height: number };
+      evaluated_viewport: { width: number; height: number };
+      document_extent_before_evaluation: { width: number; height: number };
+      document_extent_after_evaluation: { width: number; height: number };
+      document_extent_after_screenshot: { width: number; height: number };
+      screenshot: { width: number; height: number; bytes: number };
+    };
+  }> {
+    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<T>(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/src/lib/exec.ts

@@ -13,6 +13,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 {
@@ -46,7 +50,11 @@ export function exec(cmd: string[], opts: ExecOpts = {}): Promise<ExecResult> {
     proc.stderr?.on("data", (d: Buffer) => 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: number, errOverride?: string): void => {
       clearTimeout(timer);
@@ -57,6 +65,7 @@ export function exec(cmd: string[], opts: ExecOpts = {}): Promise<ExecResult> {
         stdout: shouldTrim ? stdout.trim() : stdout.replace(/\n$/, ""),
         stderr: shouldTrim ? stderr.trim() : stderr.replace(/\n$/, ""),
         exitCode,
+        ...(timedOut ? { timedOut: true } : {}),
       });
     };