@runcofactor/cli 0.10.0

package/dist/src-LB4HBTJQ.js

@@ -0,0 +1,1516 @@
+import { createRequire as __cr } from "module"; const require = __cr(import.meta.url);
+import {
+  parseTraceActions,
+  reconstructSnapshots
+} from "./chunk-52IO7ACJ.js";
+import "./chunk-VKVL7WBN.js";
+
+// ../diagnostic-workspace/src/assemble-workspace.ts
+import * as fs10 from "fs/promises";
+
+// ../diagnostic-workspace/src/_shared.ts
+var NAVIGATION_ACTIONS = /* @__PURE__ */ new Set([
+  "navigate",
+  "navigation",
+  "pushstate",
+  "popstate",
+  "pushState",
+  "popState",
+  "redirect",
+  "load"
+]);
+var hostOf = (raw) => {
+  if (typeof raw !== "string" || raw.length === 0) return null;
+  try {
+    return new URL(raw).hostname.toLowerCase().replace(/^www\./, "");
+  } catch {
+    return null;
+  }
+};
+var formatRelative = (ms) => {
+  const sign = ms < 0 ? "-" : "+";
+  const abs = Math.abs(ms);
+  const seconds = Math.floor(abs / 1e3);
+  const millis = abs % 1e3;
+  return `T${sign}${seconds}.${String(millis).padStart(3, "0")}s`;
+};
+var formatAbsolute = (ms) => {
+  const d = new Date(ms);
+  const hh = String(d.getUTCHours()).padStart(2, "0");
+  const mm = String(d.getUTCMinutes()).padStart(2, "0");
+  const ss = String(d.getUTCSeconds()).padStart(2, "0");
+  const mil = String(d.getUTCMilliseconds()).padStart(3, "0");
+  return `${hh}:${mm}:${ss}.${mil}`;
+};
+var formatPrefix = (timestampMs, baselineMs) => {
+  if (timestampMs === null) return "[unknown @ unknown]";
+  const rel = baselineMs !== null ? formatRelative(timestampMs - baselineMs) : "T+?";
+  const abs = formatAbsolute(timestampMs);
+  return `[${rel} @ ${abs}]`;
+};
+var oneLine = (s) => s.replace(/\s+/g, " ").trim();
+var truncate = (s, max) => s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+
+// ../diagnostic-workspace/src/paths.ts
+import * as path from "path";
+var WORKSPACE_PATHS = {
+  manifest: "manifest.json",
+  reportedFailure: "reported-failure.md",
+  summary: "summary.md",
+  ledger: "ledger.md",
+  ledgerIndex: "ledger-index.md",
+  steps: "steps",
+  // steps/<NNN>-<stepId>.md
+  timeline: "timeline",
+  timelineSteps: "timeline/steps.jsonl",
+  timelineActions: "timeline/actions.jsonl",
+  timelineNavigation: "timeline/navigation.jsonl",
+  timelineAssertions: "timeline/assertions.jsonl",
+  timelineCacheDecisions: "timeline/cache-decisions.jsonl",
+  thoughts: "thoughts",
+  thoughtsAll: "thoughts/all.jsonl",
+  thoughtsByStep: "thoughts/by-step",
+  // thoughts/by-step/<stepId>.md
+  browser: "browser",
+  browserTraceZip: "browser/trace.zip",
+  browserActions: "browser/actions.jsonl",
+  browserDoms: "browser/doms",
+  // browser/doms/<NNNN>-<timestamp>.html
+  browserFrames: "browser/frames",
+  // browser/frames/<NNNN>-<timestamp>.png
+  browserA11y: "browser/a11y",
+  // browser/a11y/<NNNN>-<timestamp>.yaml
+  browserResources: "browser/resources",
+  logs: "logs",
+  logsNetwork: "logs/network.jsonl",
+  logsNetworkErrors: "logs/network-errors.jsonl",
+  logsConsole: "logs/console.jsonl",
+  logsConsoleErrors: "logs/console-errors.jsonl",
+  logsSentry: "logs/sentry-logs.jsonl",
+  logsSentrySpans: "logs/sentry-spans.jsonl",
+  workflow: "workflow",
+  workflowDefinition: "workflow/definition.json",
+  workflowSnapshot: "workflow/snapshot.json",
+  workflowNodes: "workflow/nodes",
+  // workflow/nodes/<nodeId>.json
+  variables: "variables",
+  variablesInputs: "variables/inputs.json",
+  variablesLineage: "variables/lineage.jsonl",
+  history: "history",
+  historyRecentRuns: "history/recent-runs.jsonl",
+  historyLastGreen: "history/last-green",
+  notes: "notes"
+};
+var WORKSPACE_DIRS = [
+  WORKSPACE_PATHS.steps,
+  WORKSPACE_PATHS.timeline,
+  WORKSPACE_PATHS.thoughts,
+  WORKSPACE_PATHS.thoughtsByStep,
+  WORKSPACE_PATHS.browser,
+  WORKSPACE_PATHS.browserDoms,
+  WORKSPACE_PATHS.browserFrames,
+  WORKSPACE_PATHS.browserA11y,
+  WORKSPACE_PATHS.browserResources,
+  WORKSPACE_PATHS.logs,
+  WORKSPACE_PATHS.workflow,
+  WORKSPACE_PATHS.workflowNodes,
+  WORKSPACE_PATHS.variables,
+  WORKSPACE_PATHS.history,
+  WORKSPACE_PATHS.notes
+];
+var resolveWorkspacePath = (root, relative) => path.join(root, relative);
+var stepRollupRelativePath = (orderIndex, stepId) => path.join(WORKSPACE_PATHS.steps, `${String(orderIndex).padStart(3, "0")}-${stepId}.md`);
+var thoughtsByStepRelativePath = (stepId) => path.join(WORKSPACE_PATHS.thoughtsByStep, `${stepId}.md`);
+var workflowNodeRelativePath = (nodeId) => path.join(WORKSPACE_PATHS.workflowNodes, `${nodeId}.json`);
+var actionArtifactBasename = (actionIndex, absoluteTsMs, ext) => `${String(actionIndex).padStart(4, "0")}-${absoluteTsMs}.${ext}`;
+
+// ../diagnostic-workspace/src/manifest-builder.ts
+import * as fs from "fs/promises";
+var writeManifest = async (input) => {
+  const startedMs = input.startedAt ? Date.parse(input.startedAt) : null;
+  const finishedMs = input.finishedAt ? Date.parse(input.finishedAt) : null;
+  const durationMs = startedMs !== null && finishedMs !== null ? finishedMs - startedMs : null;
+  const manifest = {
+    runId: input.runId,
+    workflowId: input.workflowId,
+    orgId: input.orgId,
+    status: input.status,
+    startedAt: input.startedAt,
+    finishedAt: input.finishedAt,
+    durationMs,
+    errorMessage: input.errorMessage,
+    workflowName: input.workflowName,
+    failedStepId: input.failedStepId,
+    failedNodeId: input.failedNodeId,
+    failedStepName: input.failedStepName,
+    traceStorageKey: input.traceStorageKey,
+    diagnosticsStorageKey: input.diagnosticsStorageKey,
+    videoStorageKey: input.videoStorageKey,
+    materializedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    partial: input.partial
+  };
+  await fs.writeFile(
+    resolveWorkspacePath(input.workspaceRoot, WORKSPACE_PATHS.manifest),
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf-8"
+  );
+  return manifest;
+};
+
+// ../diagnostic-workspace/src/reported-failure-builder.ts
+import * as fs2 from "fs/promises";
+var writeReportedFailure = async (input) => {
+  const lines = [];
+  lines.push("# Reported Failure");
+  lines.push("");
+  lines.push(
+    "**This is the test runner's hypothesis. Verify with evidence before trusting it \u2014 the root cause is often upstream of the visible failure.**"
+  );
+  lines.push("");
+  lines.push(`Run status: \`${input.runStatus}\``);
+  lines.push("");
+  if (input.runStatus !== "failed") {
+    lines.push(
+      `> The run did not end in a \`failed\` status. The test runner did not designate a failed step.`
+    );
+    lines.push("");
+  } else if (!input.failedStepName) {
+    lines.push(
+      `> The run is \`failed\` but no failed step was identified. Investigate the run-level error message and walk the timeline.`
+    );
+    lines.push("");
+  } else {
+    const ordinal = input.failedStepOrderIndex !== null ? ` (step ${input.failedStepOrderIndex})` : "";
+    lines.push(`Failed step${ordinal}: **${input.failedStepName}**`);
+    lines.push("");
+  }
+  if (input.errorMessage) {
+    lines.push("## Error message");
+    lines.push("");
+    lines.push("```");
+    lines.push(input.errorMessage);
+    lines.push("```");
+    lines.push("");
+  }
+  lines.push("## What to do next");
+  lines.push("");
+  lines.push(
+    "1. Read `summary.md` for the run-level overview and step table."
+  );
+  lines.push(
+    "2. Open the failed step's rollup at `steps/<NNN>-<stepId>.md` to gather evidence at the failure point."
+  );
+  lines.push(
+    "3. Walk backwards through prior `steps/*.md` rollups \u2014 the divergence often happens upstream."
+  );
+  lines.push("");
+  await fs2.writeFile(
+    resolveWorkspacePath(input.workspaceRoot, WORKSPACE_PATHS.reportedFailure),
+    `${lines.join("\n")}
+`,
+    "utf-8"
+  );
+};
+
+// ../diagnostic-workspace/src/jsonl-writers.ts
+import * as fs3 from "fs/promises";
+var writeJsonl = (absolutePath, lines) => fs3.writeFile(
+  absolutePath,
+  lines.length === 0 ? "" : `${lines.map((l) => JSON.stringify(l)).join("\n")}
+`,
+  "utf-8"
+);
+var writeJson = (absolutePath, value) => fs3.writeFile(absolutePath, `${JSON.stringify(value, null, 2)}
+`, "utf-8");
+var writeText = (absolutePath, text) => fs3.writeFile(absolutePath, text, "utf-8");
+var isoToMs = (iso) => {
+  if (!iso) return null;
+  const parsed = Date.parse(iso);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+var isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var writeTimelineSteps = async (workspaceRoot, steps) => {
+  const lines = steps.slice().sort((a, b) => a.orderIndex - b.orderIndex).map((step) => {
+    const meta = isObject(step.metadataJson) ? step.metadataJson : {};
+    const startedMs = isoToMs(step.startedAt);
+    const finishedMs = isoToMs(step.finishedAt);
+    return {
+      id: step.id,
+      nodeId: step.nodeId,
+      orderIndex: step.orderIndex,
+      name: step.nodeName,
+      nodeType: step.nodeType,
+      status: step.status,
+      startedAt: step.startedAt,
+      finishedAt: step.finishedAt,
+      startedAtMs: startedMs,
+      finishedAtMs: finishedMs,
+      durationMs: startedMs !== null && finishedMs !== null ? finishedMs - startedMs : null,
+      errorMessage: step.errorMessage,
+      cacheOutcome: meta.cacheOutcome ?? null,
+      cacheHitSource: meta.cacheHitSource ?? null,
+      cacheProcessingStatus: meta.cacheProcessingStatus ?? null,
+      cacheOutcomeReason: meta.cacheOutcomeReason ?? null
+    };
+  });
+  await writeJsonl(
+    resolveWorkspacePath(workspaceRoot, WORKSPACE_PATHS.timelineSteps),
+    lines
+  );
+};
+var writeTimelineActionsAndNavigation = async (workspaceRoot, timeline) => {
+  const baselineMs = timeline.startTimestamp ? Date.parse(timeline.startTimestamp) : null;
+  const actions = timeline.entries.map((e) => ({
+    action: e.action,
+    target: e.target ?? null,
+    value: e.value ?? null,
+    url: e.url ?? null,
+    relativeTimestampMs: e.timestampMs,
+    timestampMs: baselineMs !== null ? baselineMs + e.timestampMs : null,
+    success: e.success,
+    isAnnotation: e.isAnnotation ?? false
+  }));
+  await writeJsonl(
+    resolveWorkspacePath(workspaceRoot, WORKSPACE_PATHS.timelineActions),
+    actions
+  );
+  const navRows = [];
+  let prevUrl = null;
+  for (const a of actions) {
+    const isNavAction = NAVIGATION_ACTIONS.has(a.action);
+    const urlChanged = a.url !== null && prevUrl !== null && a.url !== prevUrl;
+    if (!isNavAction && !urlChanged) {
+      if (a.url) prevUrl = a.url;
+      continue;
+    }
+    const fromHost = hostOf(prevUrl);
+    const toHost = hostOf(a.url);
+    navRows.push({
+      relativeTimestampMs: a.relativeTimestampMs,
+      timestampMs: a.timestampMs,
+      action: a.action,
+      from: prevUrl,
+      to: a.url,
+      crossHost: fromHost !== null && toHost !== null && fromHost !== toHost
+    });
+    if (a.url) prevUrl = a.url;
+  }
+  await writeJsonl(
+    resolveWorkspacePath(workspaceRoot, WORKSPACE_PATHS.timelineNavigation),
+    navRows
+  );
+};
+var writeAssertionsAndCacheDecisions = async (workspaceRoot, steps) => {
+  const sortedSteps = steps.slice().sort((a, b) => a.orderIndex - b.orderIndex);
+  const assertions = [];
+  const cacheDecisions = [];
+  for (const step of sortedSteps) {
+    const meta = isObject(step.metadataJson) ? step.metadataJson : {};
+    const startedMs = isoToMs(step.startedAt);
+    const rawAssertions = Array.isArray(meta.assertionResults) ? meta.assertionResults : [];
+    for (const r of rawAssertions) {
+      if (!isObject(r)) continue;
+      assertions.push({
+        stepId: step.id,
+        nodeId: step.nodeId,
+        orderIndex: step.orderIndex,
+        stepStatus: step.status,
+        timestampMs: startedMs,
+        assertionId: r.inlineAssertionId ?? r.assertionId ?? r.key ?? null,
+        condition: r.condition ?? null,
+        severity: r.severity ?? null,
+        nonBlocking: Boolean(r.nonBlocking),
+        passed: Boolean(r.passed),
+        reason: r.reason ?? null
+      });
+    }
+    cacheDecisions.push({
+      stepId: step.id,
+      nodeId: step.nodeId,
+      orderIndex: step.orderIndex,
+      stepStatus: step.status,
+      timestampMs: startedMs,
+      cacheOutcome: meta.cacheOutcome ?? null,
+      cacheHitSource: meta.cacheHitSource ?? null,
+      cacheProcessingStatus: meta.cacheProcessingStatus ?? null,
+      cacheOutcomeReason: meta.cacheOutcomeReason ?? null
+    });
+  }
+  await writeJsonl(
+    resolveWorkspacePath(workspaceRoot, WORKSPACE_PATHS.timelineAssertions),
+    assertions
+  );
+  await writeJsonl(
+    resolveWorkspacePath(workspaceRoot, WORKSPACE_PATHS.timelineCacheDecisions),
+    cacheDecisions
+  );
+};
+var writeThoughts = async (workspaceRoot, thoughts) => {
+  const sorted = thoughts.slice().sort((a, b) => a.orderIndex - b.orderIndex);
+  const allRows = sorted.map((t) => ({
+    id: t.id,
+    stepId: t.stepId,
+    nodeId: t.nodeId,
+    toolName: t.toolName,
+    orderIndex: t.orderIndex,
+    timestampMs: isoToMs(t.createdAt),
+    createdAt: t.createdAt,
+    content: t.content
+  }));
+  await writeJsonl(
+    resolveWorkspacePath(workspaceRoot, WORKSPACE_PATHS.thoughtsAll),
+    allRows
+  );
+  const byStep = /* @__PURE__ */ new Map();
+  for (const t of sorted) {
+    const key = t.stepId ?? "_no-step";
+    const list = byStep.get(key) ?? [];
+    list.push(t);
+    byStep.set(key, list);
+  }
+  const renderStep = ([stepId, stepThoughts]) => {
+    const md = [];
+    md.push(`# Thoughts for ${stepId === "_no-step" ? "(no step)" : `step ${stepId}`}`);
+    md.push("");
+    for (const t of stepThoughts) {
+      const tool = t.toolName ? ` [tool: ${t.toolName}]` : "";
+      md.push(`## ${t.createdAt}${tool}`);
+      md.push("");
+      md.push(t.content);
+      md.push("");
+    }
+    return {
+      relativePath: thoughtsByStepRelativePath(stepId),
+      body: `${md.join("\n")}
+`
+    };
+  };
+  const rendered = [...byStep.entries()].map(renderStep);
+  await Promise.all(
+    rendered.map(
+      ({ relativePath, body }) => writeText(resolveWorkspacePath(workspaceRoot, relativePath), body)
+    )
+  );
+};
+var normalizeTimestamp = (ts) => {
+  if (ts === null || ts === void 0) return null;
+  if (typeof ts === "number") return ts;
+  const parsed = Date.parse(ts);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+var writeLogs = async (workspaceRoot, network, consoleLogs) => {
+  const networkRows = network.map((e) => ({
+    timestampMs: normalizeTimestamp(e.timestamp ?? null),
+    url: e.url,
+    method: e.method,
+    status: e.status ?? null,
+    durationMs: e.durationMs ?? null,
+    requestBody: e.requestBody ?? null,
+    responseBody: e.responseBody ?? null,
+    contentType: e.contentType ?? null
+  }));
+  const networkErrors = networkRows.filter(
+    (r) => typeof r.status === "number" && r.status >= 400
+  );
+  await writeJsonl(
+    resolveWorkspacePath(workspaceRoot, WORKSPACE_PATHS.logsNetwork),
+    networkRows
+  );
+  await writeJsonl(
+    resolveWorkspacePath(workspaceRoot, WORKSPACE_PATHS.logsNetworkErrors),
+    networkErrors
+  );
+  const consoleRows = consoleLogs.map((e) => ({
+    timestampMs: normalizeTimestamp(e.timestamp),
+    type: e.type,
+    text: e.text,
+    location: e.location ?? null
+  }));
+  const consoleErrors = consoleRows.filter(
+    (r) => r.type === "error" || r.type === "warning"
+  );
+  await writeJsonl(
+    resolveWorkspacePath(workspaceRoot, WORKSPACE_PATHS.logsConsole),
+    consoleRows
+  );
+  await writeJsonl(
+    resolveWorkspacePath(workspaceRoot, WORKSPACE_PATHS.logsConsoleErrors),
+    consoleErrors
+  );
+};
+var writeVariables = async (workspaceRoot, runMetadata, steps) => {
+  const inputs = isObject(runMetadata) && isObject(runMetadata.workflowInputValues) ? runMetadata.workflowInputValues : {};
+  await writeJson(
+    resolveWorkspacePath(workspaceRoot, WORKSPACE_PATHS.variablesInputs),
+    inputs
+  );
+  const sortedSteps = steps.slice().sort((a, b) => a.orderIndex - b.orderIndex);
+  const lineageRows = [];
+  for (const step of sortedSteps) {
+    const meta = isObject(step.metadataJson) ? step.metadataJson : {};
+    const captures = Array.isArray(meta.variablesSet) ? meta.variablesSet : [];
+    const startedMs = isoToMs(step.startedAt);
+    for (const c of captures) {
+      if (!isObject(c)) continue;
+      lineageRows.push({
+        name: c.name ?? c.key ?? null,
+        value: c.value ?? null,
+        definedAtStepId: step.id,
+        definedAtNodeId: step.nodeId,
+        definedAtOrderIndex: step.orderIndex,
+        definedAtTimestampMs: startedMs
+      });
+    }
+  }
+  await writeJsonl(
+    resolveWorkspacePath(workspaceRoot, WORKSPACE_PATHS.variablesLineage),
+    lineageRows
+  );
+};
+var writeRecentRuns = async (workspaceRoot, runs) => {
+  const rows = runs.map((r) => ({
+    testRunId: r.id,
+    workflowRunId: r.workflowRunId,
+    status: r.status,
+    startedAt: r.startedAt,
+    finishedAt: r.finishedAt,
+    startedAtMs: isoToMs(r.startedAt),
+    finishedAtMs: isoToMs(r.finishedAt),
+    errorMessage: r.errorMessage
+  }));
+  await writeJsonl(
+    resolveWorkspacePath(workspaceRoot, WORKSPACE_PATHS.historyRecentRuns),
+    rows
+  );
+};
+
+// ../diagnostic-workspace/src/workflow-writer.ts
+import * as fs4 from "fs/promises";
+var writeWorkflowDefinition = async (input) => {
+  const sortedNodes = input.nodes.slice().sort((a, b) => a.orderIndex - b.orderIndex);
+  const definition = {
+    workflowId: input.workflowId,
+    name: input.workflowName,
+    nodes: sortedNodes.map((n) => ({
+      id: n.id,
+      nodeType: n.nodeType,
+      orderIndex: n.orderIndex,
+      summary: n.summary
+    })),
+    edges: input.edges.map((e) => ({
+      id: e.id,
+      source: e.source,
+      target: e.target
+    }))
+  };
+  await fs4.writeFile(
+    resolveWorkspacePath(input.workspaceRoot, WORKSPACE_PATHS.workflowDefinition),
+    `${JSON.stringify(definition, null, 2)}
+`,
+    "utf-8"
+  );
+  const snapshot = {
+    workflowId: input.workflowId,
+    name: input.workflowName,
+    nodes: sortedNodes.map((n) => ({
+      id: n.id,
+      nodeType: n.nodeType,
+      orderIndex: n.orderIndex,
+      configJson: n.configJson
+    })),
+    edges: input.edges.map((e) => ({ id: e.id, source: e.source, target: e.target }))
+  };
+  await fs4.writeFile(
+    resolveWorkspacePath(input.workspaceRoot, WORKSPACE_PATHS.workflowSnapshot),
+    `${JSON.stringify(snapshot, null, 2)}
+`,
+    "utf-8"
+  );
+  await Promise.all(
+    sortedNodes.map((node) => {
+      const filePath = resolveWorkspacePath(
+        input.workspaceRoot,
+        workflowNodeRelativePath(node.id)
+      );
+      const body = {
+        id: node.id,
+        nodeType: node.nodeType,
+        orderIndex: node.orderIndex,
+        summary: node.summary,
+        configJson: node.configJson
+      };
+      return fs4.writeFile(filePath, `${JSON.stringify(body, null, 2)}
+`, "utf-8");
+    })
+  );
+};
+
+// ../diagnostic-workspace/src/sentry-writer.ts
+import * as fs5 from "fs/promises";
+var writeJsonlWithSentinel = async (absolutePath, partial, rows) => {
+  const lines = [];
+  if (partial) lines.push(JSON.stringify(partial));
+  for (const r of rows) lines.push(JSON.stringify(r));
+  await fs5.writeFile(
+    absolutePath,
+    lines.length === 0 ? "" : `${lines.join("\n")}
+`,
+    "utf-8"
+  );
+};
+var writeSentryLogsAndSpans = async (input) => {
+  await writeJsonlWithSentinel(
+    resolveWorkspacePath(input.workspaceRoot, WORKSPACE_PATHS.logsSentry),
+    input.logs.partial,
+    input.logs.rows
+  );
+  await writeJsonlWithSentinel(
+    resolveWorkspacePath(input.workspaceRoot, WORKSPACE_PATHS.logsSentrySpans),
+    input.spans.partial,
+    input.spans.spans
+  );
+  return Boolean(input.logs.partial || input.spans.partial);
+};
+
+// ../diagnostic-workspace/src/trace-extractor.ts
+import * as fs6 from "fs/promises";
+var writeTrace = async (input) => {
+  if (!input.traceZipPath) {
+    await writePartialMarker(input.workspaceRoot, "no-trace");
+    return true;
+  }
+  const destTraceZip = resolveWorkspacePath(input.workspaceRoot, WORKSPACE_PATHS.browserTraceZip);
+  try {
+    await fs6.copyFile(input.traceZipPath, destTraceZip);
+  } catch {
+    await writePartialMarker(input.workspaceRoot, "trace-copy-failed");
+    return true;
+  }
+  let actions;
+  try {
+    actions = parseTraceActions(input.traceZipPath);
+  } catch {
+    await writePartialMarker(input.workspaceRoot, "trace-parse-failed");
+    return true;
+  }
+  await writeActionsJsonl(input.workspaceRoot, actions, input.runStartedAtMs);
+  return reconstructAndWriteArtifacts({
+    workspaceRoot: input.workspaceRoot,
+    tracePath: input.traceZipPath,
+    actions,
+    runStartedAtMs: input.runStartedAtMs
+  });
+};
+var writePartialMarker = async (workspaceRoot, reason) => {
+  await fs6.writeFile(
+    resolveWorkspacePath(workspaceRoot, WORKSPACE_PATHS.browserActions),
+    `${JSON.stringify({ partial: true, reason })}
+`,
+    "utf-8"
+  );
+};
+var reconstructAndWriteArtifacts = async (input) => {
+  const traceBase = input.actions.length > 0 ? input.actions[0].startTime : 0;
+  const computeAbsoluteTs = (action) => {
+    if (input.runStartedAtMs === null) return 0;
+    return input.runStartedAtMs + (action.startTime - traceBase);
+  };
+  let results;
+  try {
+    results = await reconstructSnapshots({
+      traceZipPath: input.tracePath,
+      filter: "after",
+      includeScreenshots: true,
+      includeHtml: true,
+      raw: false
+    });
+  } catch {
+    return true;
+  }
+  const byActionIndex = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    if (!byActionIndex.has(result.actionIndex)) {
+      byActionIndex.set(result.actionIndex, result);
+    }
+  }
+  const domsDir = resolveWorkspacePath(input.workspaceRoot, WORKSPACE_PATHS.browserDoms);
+  const framesDir = resolveWorkspacePath(input.workspaceRoot, WORKSPACE_PATHS.browserFrames);
+  const a11yDir = resolveWorkspacePath(input.workspaceRoot, WORKSPACE_PATHS.browserA11y);
+  const writeAction = async (i) => {
+    const action = input.actions[i];
+    const result = byActionIndex.get(i);
+    if (!result) return false;
+    const tsMs = computeAbsoluteTs(action);
+    try {
+      await Promise.all([
+        result.html ? fs6.writeFile(
+          `${domsDir}/${actionArtifactBasename(i, tsMs, "html")}`,
+          result.html,
+          "utf-8"
+        ) : Promise.resolve(),
+        result.screenshotBuffer ? fs6.writeFile(
+          `${framesDir}/${actionArtifactBasename(i, tsMs, "png")}`,
+          result.screenshotBuffer
+        ) : Promise.resolve(),
+        result.yaml ? fs6.writeFile(
+          `${a11yDir}/${actionArtifactBasename(i, tsMs, "yaml")}`,
+          result.yaml,
+          "utf-8"
+        ) : Promise.resolve()
+      ]);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const indexes = Array.from({ length: input.actions.length }, (_, i) => i);
+  const missingResults = indexes.filter((i) => !byActionIndex.has(i)).length;
+  const writeOutcomes = await Promise.all(indexes.map((i) => writeAction(i)));
+  const writeFailures = writeOutcomes.filter((ok) => !ok).length;
+  return missingResults > 0 || writeFailures > 0;
+};
+var writeActionsJsonl = async (workspaceRoot, actions, runStartedAtMs) => {
+  const traceBase = actions.length > 0 ? actions[0].startTime : 0;
+  const lines = actions.map((a, idx) => ({
+    actionIndex: idx,
+    callId: a.callId,
+    title: a.title,
+    startTimeRelativeMs: a.startTime - traceBase,
+    endTimeRelativeMs: a.endTime - traceBase,
+    timestampMs: runStartedAtMs !== null ? runStartedAtMs + (a.startTime - traceBase) : null,
+    params: a.params ?? null,
+    beforeSnapshot: a.beforeSnapshot ?? null,
+    afterSnapshot: a.afterSnapshot ?? null,
+    inputSnapshot: a.inputSnapshot ?? null,
+    pageId: a.pageId,
+    error: a.error ?? null,
+    point: a.point ?? null
+  }));
+  await fs6.writeFile(
+    resolveWorkspacePath(workspaceRoot, WORKSPACE_PATHS.browserActions),
+    lines.length === 0 ? "" : `${lines.map((l) => JSON.stringify(l)).join("\n")}
+`,
+    "utf-8"
+  );
+};
+
+// ../diagnostic-workspace/src/ledger-builder.ts
+import * as fs7 from "fs/promises";
+var writeLedger = async (input) => {
+  const baselineMs = input.runStartedAt ? Date.parse(input.runStartedAt) : null;
+  const events = [];
+  for (const step of input.steps) {
+    events.push({ kind: "step", step, timestampMs: step.startedAtMs });
+  }
+  for (const thought of input.thoughts) {
+    events.push({ kind: "thought", thought, stepId: thought.stepId });
+  }
+  for (const action of input.actions) {
+    events.push({ kind: "action", action });
+  }
+  for (const nav of input.navigation) {
+    events.push({ kind: "nav", nav });
+  }
+  for (const net of input.network) {
+    events.push({ kind: "network", net });
+  }
+  for (const con of input.consoleLogs) {
+    events.push({ kind: "console", con });
+  }
+  for (const assertion of input.assertions) {
+    events.push({ kind: "assertion", assertion });
+  }
+  events.sort((a, b) => {
+    const ta = eventTimestamp(a);
+    const tb = eventTimestamp(b);
+    if (ta === null && tb === null) return 0;
+    if (ta === null) return 1;
+    if (tb === null) return -1;
+    if (ta !== tb) return ta - tb;
+    const ra = eventRank(a);
+    const rb = eventRank(b);
+    return ra - rb;
+  });
+  const lines = [];
+  const indexEntries = [];
+  lines.push(`# Run Ledger \u2014 runId: ${input.runId} \u2014 workflow: ${input.workflowName} \u2014 status: ${input.runStatus}`);
+  if (baselineMs !== null) {
+    lines.push(`runStartedAt: ${input.runStartedAt}   (all T+ values are relative to this)`);
+  } else {
+    lines.push(`runStartedAt: (unknown \u2014 relative timestamps unavailable)`);
+  }
+  lines.push("");
+  if (input.runStatus === "failed" && input.reportedFailure.failedStepName) {
+    const ordinalPart = input.reportedFailure.failedStepOrderIndex !== null ? ` (step ${input.reportedFailure.failedStepOrderIndex})` : "";
+    lines.push(`## \u26A0 Reported failure`);
+    lines.push(`Step${ordinalPart}: **${input.reportedFailure.failedStepName}**`);
+    if (input.reportedFailure.errorMessage) {
+      lines.push("");
+      lines.push("```");
+      lines.push(input.reportedFailure.errorMessage);
+      lines.push("```");
+    }
+    lines.push("");
+    lines.push("**Verify before trusting \u2014 root cause may be upstream.**");
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+  for (const event of events) {
+    const ts = eventTimestamp(event);
+    const prefix = formatPrefix(ts, baselineMs);
+    if (event.kind === "step") {
+      const s = event.step;
+      const meta = [
+        `status: ${s.status}`,
+        s.durationMs !== null ? `dur ${s.durationMs}ms` : null,
+        s.cacheOutcome ? `cache: ${s.cacheOutcome}${s.cacheHitSource ? `/${s.cacheHitSource}` : ""}` : null
+      ].filter((x) => x !== null).join(", ");
+      const heading = `## ${prefix} Step ${s.orderIndex}: ${s.name ?? s.nodeId}  (${meta})`;
+      if (lines.length > 0 && lines[lines.length - 1] !== "") lines.push("");
+      indexEntries.push({
+        orderIndex: s.orderIndex,
+        name: s.name,
+        line: lines.length + 1
+        // 1-indexed
+      });
+      lines.push(heading);
+      if (s.errorMessage) {
+        lines.push(`${prefix} step.error: ${oneLine(s.errorMessage)}`);
+      }
+      continue;
+    }
+    if (event.kind === "thought") {
+      const t = event.thought;
+      const tool = t.toolName ? ` [${t.toolName}]` : "";
+      lines.push(`${prefix} thought${tool}: ${oneLine(t.content)}`);
+      continue;
+    }
+    if (event.kind === "action") {
+      const a = event.action;
+      const target = a.target ? ` ${oneLine(a.target)}` : "";
+      const url = a.url ? ` \u2192 ${a.url}` : "";
+      const status = a.success ? "" : " (failed)";
+      const annotation = a.isAnnotation ? " [annotation]" : "";
+      lines.push(`${prefix} action.${a.action}${annotation}:${target}${url}${status}`);
+      continue;
+    }
+    if (event.kind === "nav") {
+      const n = event.nav;
+      const cross = n.crossHost ? " \u26A0 cross-host" : "";
+      lines.push(`${prefix} nav.${n.action}: ${n.from ?? "?"} \u2192 ${n.to ?? "?"}${cross}`);
+      continue;
+    }
+    if (event.kind === "network") {
+      const n = event.net;
+      const status = n.status !== null ? ` ${n.status}` : "";
+      lines.push(`${prefix} network: ${n.method} ${n.url}${status}`);
+      continue;
+    }
+    if (event.kind === "console") {
+      const c = event.con;
+      lines.push(`${prefix} console.${c.type}: ${oneLine(c.text)}`);
+      continue;
+    }
+    if (event.kind === "assertion") {
+      const a = event.assertion;
+      const tag = a.passed ? "assertion.passed" : "assertion.failed";
+      const severity = a.severity ? ` [${a.severity}${a.nonBlocking ? " nonBlocking" : ""}]` : "";
+      const cond = a.condition ? oneLine(a.condition) : "(no condition)";
+      const reason = a.reason ? ` \u2014 ${oneLine(a.reason)}` : "";
+      lines.push(`${prefix} ${tag}${severity}: ${cond}${reason}`);
+      continue;
+    }
+  }
+  if (lines[lines.length - 1] !== "") lines.push("");
+  await fs7.writeFile(
+    resolveWorkspacePath(input.workspaceRoot, WORKSPACE_PATHS.ledger),
+    `${lines.join("\n")}`,
+    "utf-8"
+  );
+  const indexLines = [];
+  indexLines.push(`# Ledger Index \u2014 runId: ${input.runId}`);
+  indexLines.push("");
+  indexLines.push("Use `bash(\"sed -n '<a>,<b>p' ledger.md\")` to read a step's window.");
+  indexLines.push("");
+  if (indexEntries.length === 0) {
+    indexLines.push("(no steps recorded for this run)");
+  } else {
+    for (let i = 0; i < indexEntries.length; i++) {
+      const entry = indexEntries[i];
+      const next = indexEntries[i + 1];
+      const startLine = entry.line;
+      const endLine = next ? next.line - 1 : lines.length;
+      const name = entry.name ?? "(unnamed step)";
+      indexLines.push(`Step ${entry.orderIndex}: ${name} \u2014 lines ${startLine}-${endLine}`);
+    }
+  }
+  indexLines.push("");
+  await fs7.writeFile(
+    resolveWorkspacePath(input.workspaceRoot, WORKSPACE_PATHS.ledgerIndex),
+    `${indexLines.join("\n")}`,
+    "utf-8"
+  );
+};
+var eventTimestamp = (e) => {
+  switch (e.kind) {
+    case "step":
+      return e.timestampMs;
+    case "thought":
+      return e.thought.timestampMs;
+    case "action":
+      return e.action.timestampMs;
+    case "nav":
+      return e.nav.timestampMs;
+    case "network":
+      return e.net.timestampMs;
+    case "console":
+      return e.con.timestampMs;
+    case "assertion":
+      return e.assertion.timestampMs;
+  }
+};
+var eventRank = (e) => {
+  switch (e.kind) {
+    case "step":
+      return 0;
+    case "nav":
+      return 1;
+    case "action":
+      return 2;
+    case "thought":
+      return 3;
+    case "network":
+      return 4;
+    case "console":
+      return 5;
+    case "assertion":
+      return 6;
+  }
+};
+
+// ../diagnostic-workspace/src/step-rollup-builder.ts
+import * as fs8 from "fs/promises";
+var writeStepRollups = async (input) => {
+  const baselineMs = input.runStartedAt ? Date.parse(input.runStartedAt) : null;
+  const sortedSteps = input.steps.slice().sort((a, b) => a.orderIndex - b.orderIndex);
+  const thoughtsByStepId = /* @__PURE__ */ new Map();
+  for (const t of input.thoughts) {
+    if (!t.stepId) continue;
+    const list = thoughtsByStepId.get(t.stepId) ?? [];
+    list.push(t);
+    thoughtsByStepId.set(t.stepId, list);
+  }
+  const assertionsByStepId = /* @__PURE__ */ new Map();
+  for (const a of input.assertions) {
+    const list = assertionsByStepId.get(a.stepId) ?? [];
+    list.push(a);
+    assertionsByStepId.set(a.stepId, list);
+  }
+  const bounds = computeStepBounds(sortedSteps);
+  const writes = [];
+  for (let i = 0; i < sortedSteps.length; i++) {
+    const step = sortedSteps[i];
+    const window = bounds[i];
+    const lines = [];
+    const startPrefix = formatPrefix(step.startedAtMs, baselineMs);
+    const finishPrefix = formatPrefix(step.finishedAtMs, baselineMs);
+    lines.push(
+      `# Step ${step.orderIndex}: ${step.name ?? step.nodeId}`
+    );
+    lines.push("");
+    lines.push(`- nodeId: \`${step.nodeId}\``);
+    if (step.nodeType) lines.push(`- nodeType: \`${step.nodeType}\``);
+    lines.push(`- status: **${step.status}**`);
+    lines.push(`- started: ${startPrefix}`);
+    lines.push(`- finished: ${finishPrefix}`);
+    if (step.durationMs !== null) lines.push(`- duration: ${step.durationMs}ms`);
+    if (step.cacheOutcome) {
+      const src = step.cacheHitSource ? `/${step.cacheHitSource}` : "";
+      lines.push(`- cache: ${step.cacheOutcome}${src}`);
+    }
+    if (step.errorMessage) {
+      lines.push("");
+      lines.push("## Error message");
+      lines.push("");
+      lines.push("```");
+      lines.push(step.errorMessage);
+      lines.push("```");
+    }
+    const stepThoughts = (thoughtsByStepId.get(step.id) ?? []).slice().sort(
+      (a, b) => a.timestampMs - b.timestampMs
+    );
+    if (stepThoughts.length > 0) {
+      lines.push("");
+      lines.push("## Agent thoughts");
+      lines.push("");
+      for (const t of stepThoughts) {
+        const tool = t.toolName ? ` [${t.toolName}]` : "";
+        lines.push(`${formatPrefix(t.timestampMs, baselineMs)} thought${tool}: ${oneLine(t.content)}`);
+      }
+    }
+    const stepAssertions = (assertionsByStepId.get(step.id) ?? []).slice();
+    if (stepAssertions.length > 0) {
+      lines.push("");
+      lines.push("## Assertions");
+      lines.push("");
+      for (const a of stepAssertions) {
+        const tag = a.passed ? "passed" : "FAILED";
+        const severity = a.severity ? ` [${a.severity}${a.nonBlocking ? " nonBlocking" : ""}]` : "";
+        const cond = a.condition ?? "(no condition)";
+        const reason = a.reason ? ` \u2014 ${oneLine(a.reason)}` : "";
+        lines.push(`- ${tag}${severity}: ${oneLine(cond)}${reason}`);
+      }
+    }
+    const inWindow = (ts) => {
+      if (ts === null) return false;
+      if (window.startMs !== null && ts < window.startMs) return false;
+      if (window.endMs !== null && ts >= window.endMs) return false;
+      return true;
+    };
+    const windowActions = input.actions.filter((a) => inWindow(a.timestampMs)).slice().sort(byTs);
+    if (windowActions.length > 0) {
+      lines.push("");
+      lines.push("## Action timeline (in step window)");
+      lines.push("");
+      for (const a of windowActions) {
+        const target = a.target ? ` ${oneLine(a.target)}` : "";
+        const url = a.url ? ` \u2192 ${a.url}` : "";
+        const fail = a.success ? "" : " (failed)";
+        lines.push(`${formatPrefix(a.timestampMs, baselineMs)} action.${a.action}:${target}${url}${fail}`);
+      }
+    }
+    const windowNav = input.navigation.filter((n) => inWindow(n.timestampMs)).slice().sort(byTs);
+    if (windowNav.length > 0) {
+      lines.push("");
+      lines.push("## Navigation (in step window)");
+      lines.push("");
+      for (const n of windowNav) {
+        const cross = n.crossHost ? " \u26A0 cross-host" : "";
+        lines.push(
+          `${formatPrefix(n.timestampMs, baselineMs)} nav.${n.action}: ${n.from ?? "?"} \u2192 ${n.to ?? "?"}${cross}`
+        );
+      }
+    }
+    const windowNet = input.network.filter((n) => inWindow(n.timestampMs)).slice().sort(byTs);
+    if (windowNet.length > 0) {
+      lines.push("");
+      lines.push("## Network (in step window)");
+      lines.push("");
+      for (const n of windowNet) {
+        const status = n.status !== null ? ` ${n.status}` : "";
+        lines.push(`${formatPrefix(n.timestampMs, baselineMs)} ${n.method} ${n.url}${status}`);
+      }
+    }
+    const windowCon = input.consoleLogs.filter((c) => inWindow(c.timestampMs)).slice().sort(byTs);
+    if (windowCon.length > 0) {
+      lines.push("");
+      lines.push("## Console (in step window)");
+      lines.push("");
+      for (const c of windowCon) {
+        lines.push(`${formatPrefix(c.timestampMs, baselineMs)} console.${c.type}: ${oneLine(c.text)}`);
+      }
+    }
+    lines.push("");
+    lines.push("## Evidence files");
+    lines.push("");
+    lines.push(`- Thoughts: \`${thoughtsByStepRelativePath(step.id)}\``);
+    lines.push(`- Workflow node: \`${workflowNodeRelativePath(step.nodeId)}\``);
+    lines.push(
+      `- Browser snapshots (if available): grep this step's timestamp in \`${WORKSPACE_PATHS.browserActions}\`, then \`browser/doms/...\` / \`browser/frames/...\` / \`browser/a11y/...\``
+    );
+    lines.push("");
+    writes.push({
+      relativePath: stepRollupRelativePath(step.orderIndex, step.id),
+      body: lines.join("\n")
+    });
+  }
+  await Promise.all(
+    writes.map(
+      ({ relativePath, body }) => fs8.writeFile(resolveWorkspacePath(input.workspaceRoot, relativePath), body, "utf-8")
+    )
+  );
+};
+var computeStepBounds = (sorted) => {
+  const bounds = [];
+  for (let i = 0; i < sorted.length; i++) {
+    const step = sorted[i];
+    const next = sorted[i + 1];
+    const startMs = step.startedAtMs;
+    let endMs = step.finishedAtMs;
+    if (endMs === null && next?.startedAtMs !== void 0) endMs = next.startedAtMs;
+    bounds.push({ startMs, endMs });
+  }
+  return bounds;
+};
+var byTs = (a, b) => {
+  if (a.timestampMs === null && b.timestampMs === null) return 0;
+  if (a.timestampMs === null) return 1;
+  if (b.timestampMs === null) return -1;
+  return a.timestampMs - b.timestampMs;
+};
+
+// ../diagnostic-workspace/src/summary-builder.ts
+import * as fs9 from "fs/promises";
+var MAX_NOTABLE_EVENTS = 5;
+var MAX_HISTORY_LOOKBACK = 10;
+var isCleanPassStatus = (s) => s === "passed" || s === "success";
+var isFlakyPassStatus = (s) => s === "flaky_success";
+var isPassStatus = (s) => isCleanPassStatus(s) || isFlakyPassStatus(s);
+var isFailStatus = (s) => s === "failed" || s === "timeout" || s === "degraded";
+var classifyHistoryRegime = (others) => {
+  const seq = others.map((r) => r.status).filter((s) => isPassStatus(s) || isFailStatus(s));
+  if (seq.length < 2) return "NEW";
+  const passes = seq.filter(isPassStatus).length;
+  if (passes === 0) return "PERSISTENT_FAIL";
+  const fails = seq.filter(isFailStatus).length;
+  const hasFlaky = seq.some(isFlakyPassStatus);
+  let cleanGreenStreak = 0;
+  for (const s of seq) {
+    if (isCleanPassStatus(s)) cleanGreenStreak++;
+    else break;
+  }
+  if (fails === 0 && !hasFlaky || cleanGreenStreak >= 3) return "STABLE_REGRESSION";
+  return "FLAKY";
+};
+var writeSummary = async (input) => {
+  const baselineMs = input.runStartedAt ? Date.parse(input.runStartedAt) : null;
+  const finishedMs = input.runFinishedAt ? Date.parse(input.runFinishedAt) : null;
+  const durationMs = baselineMs !== null && finishedMs !== null ? finishedMs - baselineMs : null;
+  const lines = [];
+  lines.push(
+    `# Run ${input.runId} \u2014 workflow "${input.workflowName}" \u2014 status: ${input.runStatus}`
+  );
+  const durationStr = durationMs !== null ? `${(durationMs / 1e3).toFixed(3)}s` : "unknown";
+  lines.push(
+    `runStartedAt: ${input.runStartedAt ?? "unknown"}   duration: ${durationStr}`
+  );
+  lines.push("");
+  if (input.runStatus === "failed") {
+    lines.push("## Reported failure");
+    if (input.reportedFailure.failedStepName) {
+      const ordinal = input.reportedFailure.failedStepOrderIndex !== null ? ` (step ${input.reportedFailure.failedStepOrderIndex})` : "";
+      const err = input.reportedFailure.errorMessage ? ` \u2014 ${oneLine(input.reportedFailure.errorMessage)}` : "";
+      lines.push(
+        `Step${ordinal}: **${input.reportedFailure.failedStepName}**${err}`
+      );
+    } else if (input.reportedFailure.errorMessage) {
+      lines.push(`Run-level error: ${oneLine(input.reportedFailure.errorMessage)}`);
+    } else {
+      lines.push("(no failed step identified \u2014 investigate run-level state)");
+    }
+    lines.push("**Hypothesis. Verify before trusting \u2014 root cause may be upstream.**");
+    lines.push("");
+  }
+  const sortedSteps = input.steps.slice().sort((a, b) => a.orderIndex - b.orderIndex);
+  const counts = countByStatus(sortedSteps);
+  const summaryLine = `${sortedSteps.length} total \u2014 ${formatCounts(counts)}`;
+  lines.push(`## Steps  (${summaryLine})`);
+  const renderedSteps = sortedSteps.map((s) => formatStepRow(s, baselineMs));
+  const visibleSteps = renderedSteps.length > 30 ? [
+    ...renderedSteps.slice(0, 25),
+    `   \u2026  (${renderedSteps.length - 30} more steps elided \u2014 see ledger.md)`,
+    ...renderedSteps.slice(-5)
+  ] : renderedSteps;
+  for (const row of visibleSteps) lines.push(row);
+  lines.push("");
+  const networkErrors = input.network.filter(
+    (n) => typeof n.status === "number" && n.status >= 400
+  );
+  const consoleErrors = input.consoleLogs.filter(
+    (c) => c.type === "error" || c.type === "warning"
+  );
+  if (networkErrors.length > 0 || consoleErrors.length > 0) {
+    lines.push("## Errors observed");
+    const ne = networkErrors.length;
+    const ce = consoleErrors.length;
+    if (ne > 0) {
+      const sample = networkErrors[0];
+      lines.push(
+        `- ${ne}\xD7 network ${sample.status ?? "?"}: ${sample.method} ${sample.url}${sample.timestampMs !== null ? `   ${formatRelativePrefix(sample.timestampMs, baselineMs)}` : ""}${ne > 1 ? ` (+${ne - 1} more \u2014 see logs/network-errors.jsonl)` : ""}`
+      );
+    }
+    if (ce > 0) {
+      const sample = consoleErrors[0];
+      lines.push(
+        `- ${ce}\xD7 console.${sample.type}: ${truncate(oneLine(sample.text), 100)}${sample.timestampMs !== null ? `   ${formatRelativePrefix(sample.timestampMs, baselineMs)}` : ""}${ce > 1 ? ` (+${ce - 1} more \u2014 see logs/console-errors.jsonl)` : ""}`
+      );
+    }
+    lines.push("");
+  }
+  const notables = [];
+  const crossHost = input.navigation.filter((n) => n.crossHost);
+  for (const n of crossHost.slice(0, MAX_NOTABLE_EVENTS)) {
+    notables.push(
+      `- cross-host nav: ${n.from ?? "?"} \u2192 ${n.to ?? "?"}${n.timestampMs !== null ? `   ${formatRelativePrefix(n.timestampMs, baselineMs)}` : ""}`
+    );
+  }
+  const failedStep = sortedSteps.find((s) => s.status === "failed");
+  if (failedStep && failedStep.cacheOutcome) {
+    notables.push(
+      `- failed step cache outcome: ${failedStep.cacheOutcome}${failedStep.cacheHitSource ? `/${failedStep.cacheHitSource}` : ""}`
+    );
+  }
+  if (notables.length > 0) {
+    lines.push("## Notable events");
+    for (const n of notables) lines.push(n);
+    lines.push("");
+  }
+  const historyHint = buildHistoryHint(
+    input.recentRuns,
+    input.runId,
+    input.lastGreenComparison ?? null
+  );
+  if (historyHint.length > 0) {
+    lines.push("## History");
+    for (const h of historyHint) lines.push(h);
+    lines.push("");
+  }
+  lines.push("## Drill-down");
+  const failedRollup = input.reportedFailure.failedStepId && failedStep ? stepRollupRelativePath(failedStep.orderIndex, failedStep.id) : null;
+  if (failedRollup) {
+    lines.push(`- Failed step rollup:  \`${failedRollup}\``);
+  }
+  lines.push(`- Per-step rollups:    \`${WORKSPACE_PATHS.steps}/*.md\` (ls steps/ for the full list)`);
+  lines.push(`- Full ledger TOC:     \`${WORKSPACE_PATHS.ledgerIndex}\` (read before windowing into ledger.md)`);
+  lines.push(`- Screenshots:         \`${WORKSPACE_PATHS.browserFrames}/<NNNN>-...png\` (read with vision)`);
+  lines.push(`- Workflow nodes:      \`${WORKSPACE_PATHS.workflowNodes}/<nodeId>.json\``);
+  lines.push("");
+  await fs9.writeFile(
+    resolveWorkspacePath(input.workspaceRoot, WORKSPACE_PATHS.summary),
+    lines.join("\n"),
+    "utf-8"
+  );
+};
+var STATUS_GLYPH = {
+  success: "\u2713",
+  passed: "\u2713",
+  failed: "\u2717",
+  skipped: "-",
+  pending: "\xB7",
+  running: "\u22EF",
+  waiting: "\u22EF",
+  canceled: "\u2298"
+};
+var formatStepRow = (s, baselineMs) => {
+  const glyph = STATUS_GLYPH[s.status] ?? "?";
+  const ord = String(s.orderIndex).padStart(3, " ");
+  const tplus = s.startedAtMs !== null && baselineMs !== null ? formatRelative(s.startedAtMs - baselineMs).padStart(11, " ") : "          ?";
+  const name = s.name ?? "(unnamed)";
+  const namePadded = truncate(name, 35).padEnd(35, " ");
+  const dur = s.status === "failed" ? `FAILED${s.errorMessage ? ` \u2014 ${truncate(oneLine(s.errorMessage), 40)}` : ""}` : s.status === "skipped" ? "skipped" : s.durationMs !== null ? `${s.durationMs}ms` : "?";
+  const cache = s.cacheOutcome ? `   cache: ${s.cacheOutcome}${s.cacheHitSource ? `/${s.cacheHitSource}` : ""}` : "";
+  return ` ${ord}  ${glyph}  ${tplus}  ${namePadded}  ${dur}${cache}`;
+};
+var countByStatus = (steps) => {
+  const m = /* @__PURE__ */ new Map();
+  for (const s of steps) m.set(s.status, (m.get(s.status) ?? 0) + 1);
+  return m;
+};
+var formatCounts = (counts) => {
+  const order = ["success", "passed", "failed", "skipped", "pending", "running", "waiting", "canceled"];
+  const parts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const key of order) {
+    if (counts.has(key)) {
+      const count = counts.get(key);
+      const emphasis = key === "failed" && count > 0 ? `**${count} ${key.toUpperCase()}**` : `${count} ${key}`;
+      parts.push(emphasis);
+      seen.add(key);
+    }
+  }
+  for (const [k, v] of counts) {
+    if (!seen.has(k)) parts.push(`${v} ${k}`);
+  }
+  return parts.join(", ");
+};
+var buildHistoryHint = (runs, currentRunId, lastGreenComparison) => {
+  const lookback = runs.slice(0, MAX_HISTORY_LOOKBACK);
+  if (lookback.length <= 1) return [];
+  const others = lookback.filter((r) => r.workflowRunId !== currentRunId);
+  if (others.length === 0) return [];
+  const passed = others.filter((r) => isPassStatus(r.status)).length;
+  const failed = others.filter((r) => isFailStatus(r.status)).length;
+  const lastGreen = others.find((r) => isPassStatus(r.status));
+  const regime = classifyHistoryRegime(others);
+  const out = [];
+  out.push(
+    `${passed} of last ${others.length} ran passed; ${failed} failed.  Regime: ${regime}.`
+  );
+  if (lastGreen) {
+    out.push(
+      `Most recent green: testRunId=${lastGreen.testRunId}${lastGreen.startedAt ? ` (${lastGreen.startedAt.slice(0, 10)})` : ""}`
+    );
+    const greenRunId = lastGreen.workflowRunId ?? lastGreen.testRunId;
+    out.push(
+      `Comparison is REQUIRED \u2014 materialize via: canary workflow debug materialize ${greenRunId} --out history/last-green/`
+    );
+  }
+  const authoredUnchanged = lastGreenComparison?.authoredUnchanged ?? null;
+  const greenDate = lastGreen?.startedAt ? ` (${lastGreen.startedAt.slice(0, 10)})` : "";
+  if (regime === "STABLE_REGRESSION" && lastGreen) {
+    if (authoredUnchanged === true) {
+      out.push(
+        `AUTHORED TEST UNCHANGED since last green${greenDate} \u2014 the authored workflow is byte-identical across this pass\u2192fail boundary, so this CANNOT be test_underspecified. A pass\u2192fail here means APP BEHAVIOR CHANGED: classify app_changed (or software_bug if the delta is clearly a defect), name the concrete behavior delta, and note in openQuestions that intent could not be verified from the sandbox.`
+      );
+    } else if (authoredUnchanged === false) {
+      out.push(
+        `AUTHORED TEST CHANGED since last green${greenDate} \u2014 the test definition was edited. Compare to judge whether the new instructions are ambiguous (test_underspecified) before blaming the app.`
+      );
+    } else {
+      out.push(
+        `Stably green before this break \u2014 comparison REQUIRED. If the authored workflow is unchanged vs the green run, a pass\u2192fail means APP BEHAVIOR CHANGED (app_changed), not the test.`
+      );
+    }
+  } else if (regime === "FLAKY") {
+    out.push(
+      `This test is FLAKY (pass/fail oscillated over the window) \u2014 a single green\u2192red does NOT imply an app change. Weigh agent_confusion / intermittent dependency_issue / data_collision. Comparison may still help, but do not force an app_changed verdict without a clear, persistent behavior delta.`
+    );
+  }
+  return out;
+};
+var formatRelativePrefix = (timestampMs, baselineMs) => baselineMs !== null ? `[${formatRelative(timestampMs - baselineMs)}]` : "[T+?]";
+
+// ../diagnostic-workspace/src/assemble-workspace.ts
+var assembleWorkspace = async (input) => {
+  const { runData, workspaceRoot, traceZipPath } = input;
+  await fs10.mkdir(workspaceRoot, { recursive: true, mode: 448 });
+  for (const dir of WORKSPACE_DIRS) {
+    await fs10.mkdir(resolveWorkspacePath(workspaceRoot, dir), { recursive: true, mode: 448 });
+  }
+  let partial = runData.partial;
+  await writeReportedFailure({
+    workspaceRoot,
+    runStatus: runData.status,
+    failedStepName: runData.failedStepName,
+    failedStepOrderIndex: runData.failedStepOrderIndex,
+    errorMessage: runData.errorMessage
+  });
+  await Promise.all([
+    writeTimelineSteps(workspaceRoot, runData.steps),
+    writeTimelineActionsAndNavigation(workspaceRoot, runData.timeline),
+    writeAssertionsAndCacheDecisions(workspaceRoot, runData.steps),
+    writeThoughts(workspaceRoot, runData.thoughts),
+    writeLogs(workspaceRoot, runData.networkLogs, runData.consoleLogs),
+    writeVariables(workspaceRoot, runData.metadataJson, runData.steps),
+    writeRecentRuns(workspaceRoot, recentRunsToWriterShape(runData.recentRuns)),
+    writeWorkflowDefinition({
+      workspaceRoot,
+      workflowId: runData.workflowId,
+      workflowName: runData.workflowName,
+      nodes: runData.nodes,
+      edges: runData.edges
+    })
+  ]);
+  const sentryPartial = await writeSentryLogsAndSpans({
+    workspaceRoot,
+    logs: runData.sentryLogs,
+    spans: runData.sentrySpans
+  });
+  if (sentryPartial) partial = true;
+  const tracePartial = await writeTrace({
+    workspaceRoot,
+    traceZipPath,
+    runStartedAtMs: runData.startedAt ? Date.parse(runData.startedAt) : null
+  });
+  if (tracePartial) partial = true;
+  const eventProjection = projectEvents(runData);
+  await writeLedger({
+    workspaceRoot,
+    runId: runData.runId,
+    workflowId: runData.workflowId,
+    workflowName: runData.workflowName,
+    runStatus: runData.status,
+    runStartedAt: runData.startedAt,
+    reportedFailure: {
+      failedStepName: runData.failedStepName,
+      failedStepOrderIndex: runData.failedStepOrderIndex,
+      errorMessage: runData.errorMessage
+    },
+    steps: eventProjection.steps,
+    thoughts: eventProjection.thoughts,
+    actions: eventProjection.actions,
+    navigation: eventProjection.navigation,
+    network: eventProjection.network,
+    consoleLogs: eventProjection.consoleLogs,
+    assertions: eventProjection.assertions
+  });
+  await writeStepRollups({
+    workspaceRoot,
+    runStartedAt: runData.startedAt,
+    steps: eventProjection.steps,
+    thoughts: eventProjection.thoughts,
+    actions: eventProjection.actions,
+    navigation: eventProjection.navigation,
+    network: eventProjection.network,
+    consoleLogs: eventProjection.consoleLogs,
+    assertions: eventProjection.assertions
+  });
+  await writeSummary({
+    workspaceRoot,
+    runId: runData.runId,
+    workflowName: runData.workflowName,
+    runStatus: runData.status,
+    runStartedAt: runData.startedAt,
+    runFinishedAt: runData.finishedAt,
+    reportedFailure: {
+      failedStepId: runData.failedStepId,
+      failedStepName: runData.failedStepName,
+      failedStepOrderIndex: runData.failedStepOrderIndex,
+      errorMessage: runData.errorMessage
+    },
+    steps: eventProjection.steps.map((s) => ({
+      id: s.id,
+      orderIndex: s.orderIndex,
+      name: s.name,
+      status: s.status,
+      startedAtMs: s.startedAtMs,
+      durationMs: s.durationMs,
+      cacheOutcome: s.cacheOutcome,
+      cacheHitSource: s.cacheHitSource,
+      errorMessage: s.errorMessage
+    })),
+    network: eventProjection.network,
+    consoleLogs: eventProjection.consoleLogs,
+    navigation: eventProjection.navigation,
+    recentRuns: runData.recentRuns,
+    lastGreenComparison: runData.lastGreenComparison
+  });
+  await writeManifest({
+    workspaceRoot,
+    runId: runData.runId,
+    workflowId: runData.workflowId,
+    orgId: runData.orgId,
+    status: runData.status,
+    startedAt: runData.startedAt,
+    finishedAt: runData.finishedAt,
+    errorMessage: runData.errorMessage,
+    workflowName: runData.workflowName,
+    failedStepId: runData.failedStepId,
+    failedNodeId: runData.failedNodeId,
+    failedStepName: runData.failedStepName,
+    traceStorageKey: runData.traceStorageKey,
+    diagnosticsStorageKey: runData.diagnosticsStorageKey,
+    videoStorageKey: runData.videoStorageKey,
+    partial
+  });
+  return {
+    root: workspaceRoot,
+    runId: runData.runId,
+    orgId: runData.orgId,
+    materializedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    runStartedAt: runData.startedAt
+  };
+};
+var isPlainObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var stringField = (v) => typeof v === "string" && v.length > 0 ? v : null;
+var normalizeTs = (ts) => {
+  if (ts === null || ts === void 0) return null;
+  if (typeof ts === "number") return ts;
+  const parsed = Date.parse(ts);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+var projectEvents = (runData) => {
+  const baselineMs = runData.timeline.startTimestamp ? Date.parse(runData.timeline.startTimestamp) : null;
+  const steps = runData.steps.map((s) => {
+    const meta = isPlainObject(s.metadataJson) ? s.metadataJson : {};
+    const startedAtMs = s.startedAt ? Date.parse(s.startedAt) : null;
+    const finishedAtMs = s.finishedAt ? Date.parse(s.finishedAt) : null;
+    return {
+      id: s.id,
+      nodeId: s.nodeId,
+      orderIndex: s.orderIndex,
+      name: s.nodeName,
+      nodeType: s.nodeType,
+      status: s.status,
+      startedAtMs,
+      finishedAtMs,
+      durationMs: startedAtMs !== null && finishedAtMs !== null ? finishedAtMs - startedAtMs : null,
+      errorMessage: s.errorMessage,
+      cacheOutcome: stringField(meta.cacheOutcome),
+      cacheHitSource: stringField(meta.cacheHitSource)
+    };
+  });
+  const thoughts = runData.thoughts.map((t) => ({
+    stepId: t.stepId,
+    timestampMs: Date.parse(t.createdAt),
+    toolName: t.toolName,
+    content: t.content
+  }));
+  const actions = runData.timeline.entries.map((e) => ({
+    action: e.action,
+    target: e.target ?? null,
+    url: e.url ?? null,
+    timestampMs: baselineMs !== null ? baselineMs + e.timestampMs : null,
+    success: e.success,
+    isAnnotation: e.isAnnotation ?? false
+  }));
+  const navigation = [];
+  let prevUrl = null;
+  for (const a of actions) {
+    const isNav = NAVIGATION_ACTIONS.has(a.action);
+    const urlChanged = a.url !== null && prevUrl !== null && a.url !== prevUrl;
+    if (!isNav && !urlChanged) {
+      if (a.url) prevUrl = a.url;
+      continue;
+    }
+    navigation.push({
+      timestampMs: a.timestampMs,
+      action: a.action,
+      from: prevUrl,
+      to: a.url,
+      crossHost: hostOf(prevUrl) !== null && hostOf(a.url) !== null && hostOf(prevUrl) !== hostOf(a.url)
+    });
+    if (a.url) prevUrl = a.url;
+  }
+  const network = runData.networkLogs.map((n) => ({
+    timestampMs: normalizeTs(n.timestamp ?? null),
+    url: n.url,
+    method: n.method,
+    status: n.status ?? null
+  }));
+  const consoleLogs = runData.consoleLogs.map((c) => ({
+    timestampMs: normalizeTs(c.timestamp),
+    type: c.type,
+    text: c.text
+  }));
+  const assertions = [];
+  for (const s of runData.steps) {
+    const meta = isPlainObject(s.metadataJson) ? s.metadataJson : {};
+    const raw = Array.isArray(meta.assertionResults) ? meta.assertionResults : [];
+    for (const r of raw) {
+      if (!isPlainObject(r)) continue;
+      assertions.push({
+        stepId: s.id,
+        timestampMs: s.startedAt ? Date.parse(s.startedAt) : null,
+        condition: stringField(r.condition),
+        severity: stringField(r.severity),
+        nonBlocking: Boolean(r.nonBlocking),
+        passed: Boolean(r.passed),
+        reason: stringField(r.reason)
+      });
+    }
+  }
+  return { steps, thoughts, actions, navigation, network, consoleLogs, assertions };
+};
+var recentRunsToWriterShape = (runs) => runs.map((r) => ({
+  id: r.testRunId,
+  workflowRunId: r.workflowRunId,
+  status: r.status,
+  startedAt: r.startedAt,
+  finishedAt: r.finishedAt,
+  errorMessage: r.errorMessage
+}));
+export {
+  WORKSPACE_DIRS,
+  WORKSPACE_PATHS,
+  assembleWorkspace,
+  classifyHistoryRegime,
+  resolveWorkspacePath,
+  writeLedger,
+  writeManifest,
+  writeStepRollups,
+  writeSummary
+};
+//# sourceMappingURL=src-LB4HBTJQ.js.map