@tryvitris/website-harness 0.0.0-stage → 0.1.0-beta.6

package/bin/chunks/chunk-42IXFXUD.js

@@ -0,0 +1,1141 @@
+import {
+  prepareChange,
+  verifyChange
+} from "./chunk-54JC5L35.js";
+import {
+  deployVerifiedArtifact,
+  prepareVerifiedRelease
+} from "./chunk-VH7PM7KJ.js";
+import {
+  creativeRunStatus,
+  currentRunId,
+  handleDesignRunCommand,
+  runCreativeProfile,
+  startDesignReview,
+  submitFeedback
+} from "./chunk-FYN4T4SV.js";
+import {
+  verifyPreservedSite
+} from "./chunk-YQYHROLZ.js";
+import {
+  EXIT_CODES
+} from "./chunk-JCRGE6AL.js";
+import {
+  artifactManifest
+} from "./chunk-XL2DRAYI.js";
+import {
+  amendRefineScopes,
+  beginChange,
+  classifyChange,
+  loadState,
+  parseFeedback,
+  prepareRefine,
+  runWorkflow,
+  verifyRefine
+} from "./chunk-3CTBXY5K.js";
+import {
+  parseChangePlan
+} from "./chunk-M4LNHYYR.js";
+import {
+  parseGraphYaml
+} from "./chunk-BBV7PMFC.js";
+import {
+  explainBrowserLaunchFailure,
+  loadPlaywrightChromium
+} from "./chunk-T7DGRVTP.js";
+import {
+  previewServer
+} from "./chunk-WEFDVXFX.js";
+import {
+  buildVerified,
+  isPreserveSite
+} from "./chunk-E5Y46VBX.js";
+import {
+  findKernelRoot
+} from "./chunk-HNORQ74T.js";
+import {
+  recoverPendingTransactions,
+  save
+} from "./chunk-T6PE4KN4.js";
+
+// src/cli/doctor.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+async function runDoctor(opts = {}) {
+  const diagnostics = [];
+  const nodeMajor = parseInt(process.versions.node.split(".")[0] || "0", 10);
+  if (nodeMajor >= 24) {
+    diagnostics.push({ name: "node_version", ok: true, message: `Node.js version v${process.versions.node} (>= 24)`, severity: "info" });
+  } else {
+    diagnostics.push({ name: "node_version", ok: false, message: `Node.js version v${process.versions.node} is below required v24`, severity: "error" });
+  }
+  const gitCheck = spawnSync("git", ["--version"], { encoding: "utf8" });
+  if (gitCheck.status === 0) {
+    diagnostics.push({ name: "git", ok: true, message: gitCheck.stdout.trim(), severity: "info" });
+  } else {
+    diagnostics.push({ name: "git", ok: false, message: "git executable not found in PATH", severity: "error" });
+  }
+  const wranglerCheck = spawnSync(process.platform === "win32" ? "npx.cmd" : "npx", ["wrangler", "--version"], { encoding: "utf8" });
+  if (wranglerCheck.status === 0) {
+    diagnostics.push({ name: "wrangler", ok: true, message: wranglerCheck.stdout.trim().split("\n")[0] || "Wrangler available", severity: "info" });
+  } else {
+    diagnostics.push({ name: "wrangler", ok: false, message: "Wrangler not available via npx", severity: "warning" });
+  }
+  try {
+    const chromium = await loadPlaywrightChromium();
+    const executable = typeof chromium.executablePath === "function" ? chromium.executablePath() : "";
+    if (executable && existsSync(executable)) {
+      diagnostics.push({ name: "playwright_chromium", ok: true, message: "Playwright package and Chromium browser binary are available", severity: "info" });
+    } else {
+      diagnostics.push({
+        name: "playwright_browser",
+        ok: false,
+        message: "Playwright npm package is installed. The Chromium browser binary is not provisioned. Run: npx playwright install chromium",
+        severity: "warning"
+      });
+    }
+  } catch (error) {
+    diagnostics.push({ name: "playwright_package", ok: false, message: explainBrowserLaunchFailure(error), severity: "warning" });
+  }
+  if (opts.site) {
+    const siteRoot = resolve(opts.site);
+    if (!existsSync(siteRoot)) {
+      diagnostics.push({ name: "site_exists", ok: false, message: `Site directory not found: ${siteRoot}`, severity: "error" });
+    } else {
+      diagnostics.push({ name: "site_exists", ok: true, message: `Site directory exists at ${siteRoot}`, severity: "info" });
+      const pkgPath = join(siteRoot, "package.json");
+      if (existsSync(pkgPath)) {
+        diagnostics.push({ name: "package_json", ok: true, message: "package.json present", severity: "info" });
+      } else {
+        diagnostics.push({ name: "package_json", ok: false, message: "package.json missing from site root", severity: "error" });
+      }
+      const graphPath = join(siteRoot, "agent/graph.yaml");
+      if (existsSync(graphPath)) {
+        diagnostics.push({ name: "graph_yaml", ok: true, message: "agent/graph.yaml present", severity: "info" });
+      } else {
+        diagnostics.push({ name: "graph_yaml", ok: false, message: "agent/graph.yaml missing", severity: "error" });
+      }
+      const statePath = join(siteRoot, "agent/STATE.json");
+      if (existsSync(statePath)) {
+        diagnostics.push({ name: "state_json", ok: true, message: "agent/STATE.json present", severity: "info" });
+      } else {
+        diagnostics.push({ name: "state_json", ok: false, message: "agent/STATE.json missing", severity: "warning" });
+      }
+      const launchPath = join(siteRoot, "launch.json");
+      if (existsSync(launchPath)) {
+        diagnostics.push({ name: "launch_json", ok: true, message: "launch.json present", severity: "info" });
+      } else {
+        diagnostics.push({ name: "launch_json", ok: false, message: "launch.json missing", severity: "warning" });
+      }
+      const lockPath = join(siteRoot, "agent/RUN.lock");
+      if (existsSync(lockPath)) {
+        try {
+          const lock = JSON.parse(readFileSync(lockPath, "utf8"));
+          let alive = false;
+          try {
+            process.kill(lock.pid, 0);
+            alive = true;
+          } catch {
+            alive = false;
+          }
+          if (alive) {
+            diagnostics.push({ name: "run_lock", ok: false, message: `Active run lock held by running PID ${lock.pid}`, severity: "warning" });
+          } else {
+            diagnostics.push({ name: "run_lock", ok: false, message: `Stale run lock found (PID ${lock.pid} dead)`, severity: "warning" });
+          }
+        } catch {
+          diagnostics.push({ name: "run_lock", ok: false, message: "Malformed agent/RUN.lock", severity: "warning" });
+        }
+      } else {
+        diagnostics.push({ name: "run_lock", ok: true, message: "No active run lock", severity: "info" });
+      }
+      try {
+        recoverPendingTransactions(siteRoot);
+        diagnostics.push({ name: "transaction_recovery", ok: true, message: "Recoverable swap journal clean", severity: "info" });
+      } catch (err) {
+        diagnostics.push({ name: "transaction_recovery", ok: false, message: `Journal recovery warning: ${err instanceof Error ? err.message : String(err)}`, severity: "warning" });
+      }
+    }
+  }
+  if (opts.provider === "cloudflare" || opts.operation?.includes("deploy")) {
+    const apiToken = process.env.CLOUDFLARE_API_TOKEN;
+    const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+    if (apiToken && accountId) {
+      diagnostics.push({
+        name: "cloudflare_auth",
+        ok: true,
+        message: "Noninteractive Cloudflare authentication configured via CLOUDFLARE_API_TOKEN and CLOUDFLARE_ACCOUNT_ID",
+        severity: "info"
+      });
+    } else {
+      const whoami = spawnSync(process.platform === "win32" ? "npx.cmd" : "npx", ["wrangler", "whoami"], { encoding: "utf8" });
+      if (whoami.status === 0 && !whoami.stdout.includes("not logged in") && !whoami.stderr.includes("not logged in")) {
+        diagnostics.push({
+          name: "cloudflare_auth",
+          ok: true,
+          message: "Interactive Wrangler OAuth session active",
+          severity: "info"
+        });
+      } else {
+        diagnostics.push({
+          name: "cloudflare_auth",
+          ok: false,
+          message: "No Cloudflare credentials found. Provide CLOUDFLARE_API_TOKEN + CLOUDFLARE_ACCOUNT_ID or run 'npx wrangler login'",
+          severity: "error"
+        });
+      }
+    }
+    if (opts.operation === "pages" || !opts.operation) {
+      diagnostics.push({
+        name: "cloudflare_scope",
+        ok: true,
+        message: "Scoped resource requirements verified: Cloudflare Pages deployment only (D1 and R2 are not required)",
+        severity: "info"
+      });
+    }
+  }
+  const hasErrors = diagnostics.some((d) => !d.ok && d.severity === "error");
+  const summary = diagnostics.map((d) => `[${d.ok ? "PASS" : d.severity.toUpperCase()}] ${d.name}: ${d.message}`).join("\n");
+  return {
+    ok: !hasErrors,
+    exitCode: hasErrors ? EXIT_CODES.CONFIG_OR_CLI_ERROR : EXIT_CODES.SUCCESS,
+    summary,
+    data: { diagnostics }
+  };
+}
+
+// src/cli/refine.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2, resolve as resolve2 } from "node:path";
+var kernelRoot = findKernelRoot();
+async function refineAmend(opts) {
+  const root = resolve2(opts.site || ".");
+  if (opts.dryRun) return { ok: true, exitCode: EXIT_CODES.SUCCESS, summary: `[dry-run] Expand ${opts.requestId} to ${opts.scope}; preserve its original baseline.` };
+  const request = amendRefineScopes(root, opts.requestId, opts.scope.split(",").map((s) => s.trim()), opts.reason);
+  return { ok: true, exitCode: EXIT_CODES.SUCCESS, summary: `Refinement scope recorded: ${request.scopes.join(", ")}. Original instruction and baseline preserved.` };
+}
+async function refineSite(opts) {
+  const root = resolve2(opts.site || ".");
+  if (!existsSync2(root)) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: `Site root not found: ${root}`
+    };
+  }
+  const instruction = (opts.request || "").trim();
+  if (!instruction) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: "refine requires a --request instruction"
+    };
+  }
+  const classified = classifyChange(instruction);
+  const feedback = parseFeedback(instruction);
+  const effectiveScope = opts.scope && opts.scope !== "auto" ? opts.scope : classified.scope;
+  if (opts.dryRun) {
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: `[dry-run] Classified scope: ${classified.scope} (effective: ${effectiveScope})
+Rationale: ${classified.rationale}
+Proposed changes: ${classified.proposedChanges.join("; ")}`,
+      data: { scope: effectiveScope }
+    };
+  }
+  if (opts.signal?.aborted) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.ABORTED,
+      error: "Refinement aborted by signal before execution"
+    };
+  }
+  const graphPath = join2(root, "agent/graph.yaml");
+  if (!existsSync2(graphPath)) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: "Missing agent/graph.yaml in site root"
+    };
+  }
+  const graph = parseGraphYaml(readFileSync2(graphPath, "utf8"));
+  const state = loadState(root, graph);
+  beginChange({
+    root,
+    graph,
+    state,
+    instruction,
+    scopeFlag: opts.scope
+  });
+  save(join2(root, "agent/STATE.json"), state);
+  const result = await runWorkflow({
+    root,
+    kernel: kernelRoot,
+    argv: ["--site", root, "--no-preview-server", ...opts.workflowArgv || []],
+    noPreviewServer: true,
+    onLog: opts.onLog,
+    signal: opts.signal,
+    jevFetch: opts.jevFetch
+  });
+  const exitCode = result.exitCode;
+  const ok = exitCode === 0;
+  const completed = ok && result.state.preview_ready;
+  return {
+    ok,
+    exitCode,
+    summary: completed ? `Refinement applied successfully: ${instruction} (scope: ${effectiveScope})` : ok ? `Refinement prepared; complete the active stage and run refine verify: ${instruction} (scope: ${effectiveScope})` : `Refinement blocked or failed with exit code ${exitCode}`,
+    data: { scope: effectiveScope }
+  };
+}
+async function refinePrepare(opts) {
+  const root = resolve2(opts.site || ".");
+  if (!existsSync2(root)) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: `Site root not found: ${root}`
+    };
+  }
+  const instruction = (opts.request || "").trim();
+  if (!instruction) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: "refine prepare requires a --request instruction"
+    };
+  }
+  if (opts.dryRun) {
+    const classified = classifyChange(instruction);
+    const scope = opts.scope && opts.scope !== "auto" ? opts.scope : classified.scope;
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: `[dry-run] Would prepare refinement for: ${instruction} (scope: ${scope})`
+    };
+  }
+  if (opts.planFile) {
+    const plan = parseChangePlan(JSON.parse(readFileSync2(resolve2(opts.planFile), "utf8")));
+    if (opts.requestId && opts.requestId !== plan.requestId) throw new Error("--request-id differs from plan.requestId");
+    const feedback = parseFeedback(instruction);
+    const explicitPreferences = [
+      ...feedback.likes.map((item) => ({ intent: "positive", text: item.text, target: item.path || item.sectionId || item.hook })),
+      ...feedback.dislikes.map((item) => ({ intent: "negative", text: item.text, target: item.path || item.sectionId || item.hook })),
+      ...feedback.preserve.map((item) => ({ intent: "preserve", text: item.text, target: item.path || item.sectionId || item.hook }))
+    ];
+    const prepared = prepareChange(root, {
+      schemaVersion: 1,
+      id: plan.requestId,
+      instruction,
+      origin: "operator",
+      baseRevision: plan.baseRevision,
+      requestedScopes: opts.scope && opts.scope !== "auto" ? [opts.scope] : [],
+      explicitPreferences,
+      evidence: []
+    }, plan);
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: `Structured refinement prepared: ${plan.requestId}`,
+      data: {
+        requestId: plan.requestId,
+        scope: plan.facets[0],
+        scopes: plan.facets,
+        classifiedScope: plan.facets[0],
+        rationale: "Validated structured plan",
+        affectedPages: plan.targets,
+        proposedChanges: plan.acceptanceCriteria.map((item) => item.id),
+        impactedNodes: prepared.impactedNodes,
+        baselinePath: prepared.baselinePath,
+        drift: { drifted: false, driftedFiles: [], details: [] },
+        checklist: plan.requiredChecks
+      }
+    };
+  }
+  const result = prepareRefine({ root, instruction, scope: opts.scope, requestId: opts.requestId });
+  return {
+    ok: true,
+    exitCode: EXIT_CODES.SUCCESS,
+    summary: `Refinement prepared for request '${result.requestId}' (scope: ${result.scope}).
+Affected pages: ${result.affectedPages.join(", ") || "none"}
+Impacted nodes: ${result.impactedNodes.join(", ")}
+Baseline saved: ${result.baselinePath}
+` + (result.drift.drifted ? `Drift detected: ${result.drift.details.join("; ")}
+` : "Site memory: in sync (no drift)\n") + `Verification checklist:
+${result.checklist.map((c) => `  - ${c}`).join("\n")}`,
+    data: result
+  };
+}
+async function refineVerify(opts) {
+  const root = resolve2(opts.site || ".");
+  if (!existsSync2(root)) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: `Site root not found: ${root}`
+    };
+  }
+  if (opts.dryRun) {
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: `[dry-run] Would run impact verification on site ${root}`
+    };
+  }
+  const pending = existsSync2(join2(root, "agent/refine-pending.json")) ? JSON.parse(readFileSync2(join2(root, "agent/refine-pending.json"), "utf8")) : void 0;
+  const requestId = opts.requestId || pending?.requestId;
+  if (requestId && existsSync2(join2(root, `agent/requests/${requestId}/engine-preparation.json`))) {
+    const result2 = await verifyChange(root, requestId);
+    const ok = result2.technical === "pass" && result2.fulfillment === "pass" && result2.design !== "fail";
+    return {
+      ok,
+      exitCode: ok ? EXIT_CODES.SUCCESS : EXIT_CODES.GATES_FAILED,
+      summary: ok ? `Structured refinement verified: ${requestId}` : `Structured refinement requires further work: ${requestId}`,
+      failures: result2.unresolved,
+      data: result2
+    };
+  }
+  const result = await verifyRefine({ root, requestId: opts.requestId });
+  return {
+    ok: result.ok,
+    exitCode: result.ok ? EXIT_CODES.SUCCESS : EXIT_CODES.GATES_FAILED,
+    summary: result.summary,
+    failures: result.failures,
+    data: result
+  };
+}
+
+// src/cli/lifecycle.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, unlinkSync } from "node:fs";
+import { join as join3, resolve as resolve3 } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+var kernelRoot2 = findKernelRoot();
+function killProcessTree(pid) {
+  if (process.platform === "win32") {
+    try {
+      spawnSync2("taskkill", ["/F", "/T", "/PID", String(pid)], { stdio: "ignore" });
+    } catch {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+  } else {
+    try {
+      process.kill(-pid, "SIGTERM");
+    } catch {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+  }
+}
+async function resumeSite(opts = {}) {
+  const root = resolve3(opts.site || ".");
+  if (!existsSync3(root)) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: `Site root not found: ${root}`
+    };
+  }
+  const creative = opts.runId && existsSync3(join3(root, "agent/creative-runs", opts.runId, "manifest.json")) ? creativeRunStatus(root, opts.runId) : !opts.runId && existsSync3(join3(root, "agent/creative-runs/CURRENT.json")) ? creativeRunStatus(root) : void 0;
+  const runId = opts.runId || (existsSync3(join3(root, "agent/design-runs")) ? currentRunId(root) : void 0);
+  if (opts.dryRun) {
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: `[dry-run] Would resume ${creative ? `creative run ${creative.id}` : runId ? `design run ${runId}` : "workflow"} on ${root}`,
+      data: { runId }
+    };
+  }
+  if (creative) {
+    const result2 = await runCreativeProfile(root, kernelRoot2, ["--creative-profile", "--creative-run", creative.id, "--resume", ...opts.workflowArgv || []]);
+    return { ok: result2.exitCode === 0, exitCode: result2.exitCode, summary: result2.summary, data: { runId: creative.id } };
+  }
+  if (runId && existsSync3(join3(root, "agent/design-runs", runId))) {
+    const code = await handleDesignRunCommand({
+      root,
+      kernel: kernelRoot2,
+      argv: ["--design-run", runId]
+    });
+    const exitCode2 = code === 0 ? EXIT_CODES.SUCCESS : code;
+    return {
+      ok: code === 0,
+      exitCode: exitCode2,
+      summary: code === 0 ? `Resumed design run ${runId}` : `Resume failed with code ${code}`,
+      data: { runId }
+    };
+  }
+  const result = await runWorkflow({
+    root,
+    kernel: kernelRoot2,
+    argv: ["--site", root, ...opts.workflowArgv || []],
+    onLog: opts.onLog,
+    signal: opts.signal,
+    jevFetch: opts.jevFetch
+  });
+  const exitCode = result.exitCode;
+  return {
+    ok: exitCode === 0,
+    exitCode,
+    summary: exitCode === 0 ? "Workflow resumed successfully" : `Resume exited with code ${exitCode}`
+  };
+}
+async function cancelSite(opts = {}) {
+  const root = resolve3(opts.site || ".");
+  if (!existsSync3(root)) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: `Site root not found: ${root}`
+    };
+  }
+  const lockPath = join3(root, "agent/RUN.lock");
+  if (!existsSync3(lockPath)) {
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: "No active run lock found in site"
+    };
+  }
+  let pid;
+  try {
+    const lock = JSON.parse(readFileSync3(lockPath, "utf8"));
+    pid = lock.pid;
+  } catch {
+    unlinkSync(lockPath);
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: "Removed corrupt agent/RUN.lock"
+    };
+  }
+  if (opts.dryRun) {
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: `[dry-run] Would terminate active run PID ${pid} and release lock`,
+      data: { pid }
+    };
+  }
+  let alive = false;
+  try {
+    process.kill(pid, 0);
+    alive = true;
+  } catch {
+    alive = false;
+  }
+  if (alive) {
+    killProcessTree(pid);
+    await new Promise((r) => setTimeout(r, 300));
+    try {
+      process.kill(pid, 0);
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+  if (existsSync3(lockPath)) {
+    unlinkSync(lockPath);
+  }
+  const statePath = join3(root, "agent/STATE.json");
+  if (existsSync3(statePath)) {
+    try {
+      const state = JSON.parse(readFileSync3(statePath, "utf8"));
+      state.status = "canceled";
+      state.current = null;
+      save(statePath, state);
+    } catch {
+    }
+  }
+  return {
+    ok: true,
+    exitCode: EXIT_CODES.SUCCESS,
+    summary: `Canceled active run (PID ${pid}) and cleaned locks`,
+    data: { pid }
+  };
+}
+
+// src/cli/feedback.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { resolve as resolve4 } from "node:path";
+var kernelRoot3 = findKernelRoot();
+async function importFeedback(opts) {
+  const root = resolve4(opts.site || ".");
+  if (!existsSync4(root)) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: `Site root not found: ${root}`
+    };
+  }
+  const runId = opts.runId || currentRunId(root);
+  if (!runId) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: "feedback import requires --run RUN_ID (or an active design run in site)"
+    };
+  }
+  if (!opts.file) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: "feedback import requires --file PATH"
+    };
+  }
+  const filePath = resolve4(opts.file);
+  if (!existsSync4(filePath)) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: `Feedback file not found: ${filePath}`
+    };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync4(filePath, "utf8"));
+  } catch (err) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: `Invalid JSON in feedback file: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  if (opts.dryRun) {
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: `[dry-run] Would import feedback from ${filePath} into design run ${runId}`
+    };
+  }
+  try {
+    const result = submitFeedback(root, runId, raw);
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: result.summary,
+      data: {
+        feedbackId: result.feedback.feedbackId,
+        summary: result.summary
+      }
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.GATES_FAILED,
+      error: `Failed to import feedback: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+async function synthesizeSite(opts = {}) {
+  const root = resolve4(opts.site || ".");
+  if (!existsSync4(root)) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: `Site root not found: ${root}`
+    };
+  }
+  const runId = opts.runId || currentRunId(root);
+  if (!runId) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: "synthesize requires --run RUN_ID (or an active design run in site)"
+    };
+  }
+  if (opts.dryRun) {
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: `[dry-run] Would synthesize design run ${runId}`,
+      data: { runId }
+    };
+  }
+  const argv = ["--design-run", runId];
+  if (opts.feedback) {
+    argv.push("--feedback", resolve4(opts.feedback));
+  }
+  const code = await handleDesignRunCommand({
+    root,
+    kernel: kernelRoot3,
+    argv
+  });
+  const exitCode = code === 0 ? EXIT_CODES.SUCCESS : code;
+  return {
+    ok: code === 0,
+    exitCode,
+    summary: code === 0 ? `Synthesized design run ${runId} successfully` : `Synthesis failed with code ${code}`,
+    data: { runId }
+  };
+}
+
+// src/cli/preview.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join4, resolve as resolve5 } from "node:path";
+async function previewSite(opts = {}) {
+  const root = resolve5(opts.site || ".");
+  if (!existsSync5(root)) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: `Site root not found: ${root}`
+    };
+  }
+  const dist = join4(root, "dist");
+  if (!existsSync5(join4(dist, "index.html"))) {
+    try {
+      await buildVerified(root);
+    } catch (err) {
+      return {
+        ok: false,
+        exitCode: EXIT_CODES.GATES_FAILED,
+        error: `Could not build site for preview: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+  if (opts.dryRun) {
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: `[dry-run] Would start preview server for ${dist}`,
+      data: { url: "http://127.0.0.1:0", port: 0 }
+    };
+  }
+  const server = previewServer(dist);
+  const targetPort = opts.port || 0;
+  return new Promise((resolveResult) => {
+    server.listen(targetPort, "127.0.0.1", () => {
+      const addr = server.address();
+      const port = addr.port;
+      const url = `http://127.0.0.1:${port}`;
+      if (opts.signal) {
+        opts.signal.addEventListener("abort", () => {
+          server.close();
+        }, { once: true });
+      }
+      if (opts.wait) {
+        opts.onLog?.(`Local preview active at ${url}`);
+        const closePromise = new Promise((resolveClose) => {
+          const cleanup = () => {
+            try {
+              server.close(() => resolveClose());
+            } catch {
+              resolveClose();
+            }
+          };
+          if (opts.signal) {
+            if (opts.signal.aborted) cleanup();
+            else opts.signal.addEventListener("abort", cleanup, { once: true });
+          } else {
+            process.once("SIGINT", cleanup);
+            process.once("SIGTERM", cleanup);
+          }
+        });
+        closePromise.then(() => {
+          resolveResult({
+            ok: true,
+            exitCode: EXIT_CODES.SUCCESS,
+            summary: `Preview server stopped for ${url}`,
+            data: { url, port }
+          });
+        });
+        return;
+      }
+      resolveResult({
+        ok: true,
+        exitCode: EXIT_CODES.SUCCESS,
+        summary: `Local preview active at ${url}`,
+        data: { url, port }
+      });
+    });
+    server.on("error", (err) => {
+      resolveResult({
+        ok: false,
+        exitCode: EXIT_CODES.GENERIC_ERROR,
+        error: `Preview server error: ${err.message}`
+      });
+    });
+  });
+}
+
+// src/cli/deploy.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
+import { join as join6, resolve as resolve6 } from "node:path";
+
+// src/integrations/cloudflare-pages.ts
+import { spawn } from "node:child_process";
+
+// src/integrations/wrangler-command.ts
+import { createRequire } from "node:module";
+import { dirname as dirname4, join as join5 } from "node:path";
+function wranglerCommand(siteRoot, args) {
+  const require2 = createRequire(join5(siteRoot, "package.json"));
+  let entry;
+  try {
+    entry = join5(dirname4(require2.resolve("wrangler/package.json")), "bin/wrangler.js");
+  } catch {
+    entry = join5(dirname4(createRequire(import.meta.url).resolve("wrangler/package.json")), "bin/wrangler.js");
+  }
+  return { command: process.execPath, args: [entry, ...args] };
+}
+
+// src/integrations/cloudflare-pages.ts
+async function ensurePreservePreviewProject(project, branch, signal) {
+  const account = process.env.CLOUDFLARE_ACCOUNT_ID, token = process.env.CLOUDFLARE_API_TOKEN;
+  if (!account || !token) throw new Error("Preserve preview provisioning requires CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN with Pages Edit access");
+  if (!/^[a-z0-9][a-z0-9-]{0,57}$/.test(project)) throw new Error("Invalid Pages project name");
+  const endpoint = `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(account)}/pages/projects`;
+  const headers = { authorization: `Bearer ${token}`, "content-type": "application/json" };
+  const response = await fetch(`${endpoint}/${project}`, { headers, signal });
+  if (response.status === 404) {
+    if (branch === "production") throw new Error("Preview branch cannot be production");
+    const created = await fetch(endpoint, { method: "POST", headers, signal, body: JSON.stringify({ name: project, production_branch: "production" }) });
+    const body2 = await created.json();
+    if (!created.ok || !body2.success) throw new Error(`Could not create Pages preview project (HTTP ${created.status})`);
+    return;
+  }
+  const body = await response.json();
+  if (!response.ok || !body.success || !body.result?.production_branch) throw new Error(`Cannot confirm Pages production branch (HTTP ${response.status})`);
+  if (branch === body.result.production_branch) throw new Error("Preview branch cannot equal the project's production branch");
+}
+function cloudflarePagesAdapter(opts) {
+  const run = async (args) => {
+    opts.signal?.throwIfAborted();
+    const command = wranglerCommand(opts.siteRoot, args);
+    return new Promise((done, reject) => {
+      const child = spawn(command.command, command.args, { cwd: opts.siteRoot, env: process.env, stdio: ["ignore", "pipe", "pipe"] });
+      let output = "";
+      const abort = () => {
+        child.kill();
+      };
+      child.stdout?.on("data", (chunk) => {
+        const line = chunk.toString();
+        output += line;
+        opts.onLog?.(line.trim());
+      });
+      child.stderr?.on("data", (chunk) => {
+        const line = chunk.toString();
+        output += line;
+        opts.onLog?.(line.trim());
+      });
+      child.on("error", (error) => {
+        opts.signal?.removeEventListener("abort", abort);
+        reject(error);
+      });
+      child.on("close", (code) => {
+        opts.signal?.removeEventListener("abort", abort);
+        done({ code, output });
+      });
+      opts.signal?.addEventListener("abort", abort, { once: true });
+    });
+  };
+  const deploy = async (artifact, branch) => {
+    if (artifactManifest(artifact.outputDirectory).sha256 !== artifact.artifactDigest) throw new Error("Release bundle changed before Wrangler deployment");
+    if (opts.ensurePreviewProject) {
+      if (artifact.environment !== "preview" || !branch) throw new Error("Preservation hosting requires a preview branch");
+      await ensurePreservePreviewProject(opts.project, branch, opts.signal);
+    }
+    const args = ["pages", "deploy", artifact.outputDirectory, `--project-name=${opts.project}`];
+    if (branch) args.push(`--branch=${branch}`);
+    const result = await run(args);
+    if (result.code !== 0) throw new Error(`Wrangler deployment failed: ${result.output}`);
+    if (artifactManifest(artifact.outputDirectory).sha256 !== artifact.artifactDigest) throw new Error("Release bundle changed during Wrangler deployment");
+    const url = result.output.match(/https:\/\/[a-z0-9_.-]+\.pages\.dev/i)?.[0];
+    if (!url) throw new Error("Wrangler succeeded without a deployment URL; deployment identity is unknown");
+    return {
+      provider: "cloudflare-pages",
+      environment: artifact.environment,
+      deploymentId: url,
+      url,
+      artifactDigest: artifact.artifactDigest,
+      issuedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  };
+  return {
+    id: "cloudflare-pages",
+    deployPreview: (artifact) => deploy(artifact, opts.previewBranch || "preview"),
+    publish: (artifact) => deploy(artifact)
+  };
+}
+
+// src/integrations/deployment-smoke.ts
+import { setTimeout as delay } from "node:timers/promises";
+async function deploymentSmoke(url, opts = {}) {
+  let result = { ok: false, status: 0, message: "Deployment not reachable" };
+  const attempts = opts.attempts ?? 8;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    opts.signal?.throwIfAborted();
+    try {
+      const response = await fetch(url, { signal: opts.signal ? AbortSignal.any([opts.signal, AbortSignal.timeout(1e4)]) : AbortSignal.timeout(1e4) });
+      const html = await response.text();
+      const markup = opts.preserved ? /<html\b/i.test(html) : /<h1\b/i.test(html);
+      result = response.status === 200 && markup ? { ok: true, status: 200, message: "Root page rendered with HTTP 200 and expected markup" } : { ok: false, status: response.status, message: "Unexpected status or missing page markup" };
+    } catch (error) {
+      const e = error;
+      result = { ok: false, status: 0, message: `${e.message}${e.cause?.code ? ` (${e.cause.code})` : ""}` };
+    }
+    if (result.ok) return result;
+    if (attempt + 1 < attempts) {
+      opts.onLog?.(`Waiting for deployment availability (${attempt + 1}/${attempts}): ${result.message}`);
+      await delay(opts.retryDelayMs ?? Math.min(1e4, 1e3 * 2 ** attempt), void 0, { signal: opts.signal });
+    }
+  }
+  return result;
+}
+
+// src/cli/deploy.ts
+async function deploySite(opts = {}) {
+  const root = resolve6(opts.site || ".");
+  if (!existsSync6(root)) return { ok: false, exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR, error: `Site root not found: ${root}` };
+  const provider = opts.provider || "cloudflare";
+  if (provider !== "cloudflare") return { ok: false, exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR, error: `Unsupported provider: ${provider}` };
+  const environment = opts.environment || "preview";
+  if (isPreserveSite(root) && environment !== "preview") return { ok: false, exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR, error: "Preserve mode supports temporary previews only; customer domains and production publication are not enabled" };
+  const launch = existsSync6(join6(root, "launch.json")) ? JSON.parse(readFileSync5(join6(root, "launch.json"), "utf8")) : {};
+  const project = launch.pagesProject || launch.slug || "vitris-site";
+  const doctor = await runDoctor({ site: root, provider: "cloudflare", operation: "pages" });
+  if (!doctor.ok) return {
+    ok: false,
+    exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+    error: `Deployment doctor checks failed:
+${doctor.summary}`
+  };
+  if (opts.dryRun) return {
+    ok: true,
+    exitCode: EXIT_CODES.SUCCESS,
+    summary: `[dry-run] Would verify and deploy ${project} to Cloudflare Pages (${environment})`,
+    data: { environment, project }
+  };
+  try {
+    opts.onLog?.("Preparing a verified, staged release bundle...");
+    const artifact = await prepareVerifiedRelease(root, environment);
+    const adapter = cloudflarePagesAdapter({ siteRoot: root, project, previewBranch: opts.branch, signal: opts.signal, onLog: opts.onLog, ensurePreviewProject: isPreserveSite(root) });
+    const { deployment } = await deployVerifiedArtifact(root, artifact, adapter);
+    let smokeCheck;
+    if (deployment.url) {
+      opts.onLog?.(`Checking ${deployment.url}...`);
+      smokeCheck = await deploymentSmoke(deployment.url, { signal: opts.signal, onLog: opts.onLog, preserved: isPreserveSite(root) });
+    }
+    if (smokeCheck && !smokeCheck.ok) return {
+      ok: false,
+      exitCode: EXIT_CODES.DEPLOYMENT_FAILED,
+      error: `Deployment smoke check failed: ${smokeCheck.message}`,
+      data: { url: deployment.url, environment, project, smokeCheck }
+    };
+    if (isPreserveSite(root) && deployment.url) {
+      opts.onLog?.("Checking the hosted preservation across all captured routes and viewports...");
+      const remote = await verifyPreservedSite(root, { remoteUrl: deployment.url, signal: opts.signal, onLog: opts.onLog });
+      if (!remote.ok) return { ok: false, exitCode: EXIT_CODES.DEPLOYMENT_FAILED, error: "Hosted preservation checks failed; see agent/reviews/preserve-remote.json", failures: remote.failures, data: { url: deployment.url, environment, project, smokeCheck } };
+    }
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: `Deployed exact verified bundle to ${deployment.url}`,
+      data: { url: deployment.url, environment, project, smokeCheck }
+    };
+  } catch (error) {
+    return { ok: false, exitCode: EXIT_CODES.DEPLOYMENT_FAILED, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// src/cli/share.ts
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join7, resolve as resolve7 } from "node:path";
+import { spawn as spawn2, spawnSync as spawnSync3 } from "node:child_process";
+var kernelRoot4 = findKernelRoot();
+function findCloudflared() {
+  if (process.env.CLOUDFLARED_PATH && existsSync7(process.env.CLOUDFLARED_PATH)) {
+    return process.env.CLOUDFLARED_PATH;
+  }
+  if (process.platform === "win32" && process.env.LOCALAPPDATA) {
+    const local = join7(process.env.LOCALAPPDATA, "cloudflared/cloudflared.exe");
+    if (existsSync7(local)) return local;
+  }
+  const probe = spawnSync3(process.platform === "win32" ? "where.exe" : "which", ["cloudflared"], { encoding: "utf8" });
+  if (probe.status === 0 && probe.stdout) {
+    const first = probe.stdout.trim().split(/\r?\n/)[0];
+    if (first && existsSync7(first)) return first;
+  }
+  return void 0;
+}
+async function shareSite(opts = {}) {
+  const root = resolve7(opts.site || ".");
+  if (!existsSync7(root)) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: `Site root not found: ${root}`
+    };
+  }
+  const runId = opts.runId || (existsSync7(join7(root, "agent/design-runs")) ? currentRunId(root) : void 0);
+  if (opts.dryRun) {
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: `[dry-run] Would start share server for ${runId ? `design run ${runId}` : `site at ${root}`}${opts.tunnel ? " with Cloudflare Quick Tunnel" : ""}`,
+      data: {
+        url: opts.tunnel ? "https://mock.trycloudflare.com" : "http://127.0.0.1:0",
+        ...opts.tunnel ? { tunnelUrl: "https://mock.trycloudflare.com" } : {}
+      }
+    };
+  }
+  let localUrl = "";
+  let targetPort = opts.port || 0;
+  let closeServer;
+  if (runId && existsSync7(join7(root, "agent/design-runs", runId))) {
+    const review = await startDesignReview({
+      parent: root,
+      kernel: kernelRoot4,
+      runId,
+      port: opts.port
+    });
+    localUrl = review.url;
+    closeServer = () => {
+      try {
+        review.server.close();
+      } catch {
+      }
+    };
+  } else {
+    const preview = await previewSite({
+      site: root,
+      port: opts.port,
+      signal: opts.signal,
+      wait: false
+    });
+    if (!preview.ok || !preview.data) {
+      return {
+        ok: false,
+        exitCode: preview.exitCode,
+        error: preview.error,
+        summary: preview.summary
+      };
+    }
+    localUrl = preview.data.url;
+    targetPort = preview.data.port;
+  }
+  let tunnelUrl;
+  let tunnelProc;
+  if (opts.tunnel) {
+    const cloudflaredBin = findCloudflared();
+    if (!cloudflaredBin) {
+      closeServer?.();
+      return {
+        ok: false,
+        exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+        error: "cloudflared executable not found on PATH or LOCALAPPDATA. Install cloudflared to use Cloudflare Quick Tunnels."
+      };
+    }
+    const urlObj = new URL(localUrl);
+    const originPort = urlObj.port || String(targetPort);
+    opts.onLog?.(`Starting Cloudflare Quick Tunnel for ${localUrl}...`);
+    tunnelUrl = await new Promise((resolveTunnel, rejectTunnel) => {
+      let resolved = false;
+      const child = spawn2(cloudflaredBin, ["tunnel", "--no-autoupdate", "--url", `http://127.0.0.1:${originPort}`], {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      tunnelProc = child;
+      const timer = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          rejectTunnel(new Error("Timeout waiting for Cloudflare Quick Tunnel URL"));
+        }
+      }, 3e4);
+      const checkChunk = (chunk) => {
+        const text = chunk.toString();
+        opts.onLog?.(text.trim());
+        const match = text.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
+        if (match && !resolved) {
+          resolved = true;
+          clearTimeout(timer);
+          resolveTunnel(match[0]);
+        }
+      };
+      child.stdout?.on("data", checkChunk);
+      child.stderr?.on("data", checkChunk);
+      child.on("error", (err) => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timer);
+          rejectTunnel(err);
+        }
+      });
+      child.on("close", (code) => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timer);
+          rejectTunnel(new Error(`cloudflared exited early with code ${code}`));
+        }
+      });
+    }).catch((err) => {
+      opts.onLog?.(`Failed to establish tunnel: ${err instanceof Error ? err.message : String(err)}`);
+      return void 0;
+    });
+    if (!tunnelUrl) {
+      closeServer?.();
+      return {
+        ok: false,
+        exitCode: EXIT_CODES.GENERIC_ERROR,
+        error: "Failed to establish Cloudflare Quick Tunnel URL"
+      };
+    }
+  }
+  const activeUrl = tunnelUrl || localUrl;
+  const summary = tunnelUrl ? `Cloudflare Quick Tunnel active at ${tunnelUrl} (local: ${localUrl})` : `Share active at ${activeUrl}`;
+  opts.onLog?.(summary);
+  const cleanup = () => {
+    if (tunnelProc?.pid) {
+      killProcessTree(tunnelProc.pid);
+    }
+    closeServer?.();
+  };
+  if (opts.signal) {
+    opts.signal.addEventListener("abort", cleanup, { once: true });
+  }
+  if (opts.wait) {
+    await new Promise((resolveWait) => {
+      const onDone = () => {
+        cleanup();
+        resolveWait();
+      };
+      if (opts.signal) {
+        if (opts.signal.aborted) onDone();
+        else opts.signal.addEventListener("abort", onDone, { once: true });
+      } else {
+        process.once("SIGINT", onDone);
+        process.once("SIGTERM", onDone);
+      }
+    });
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: `Share stopped: ${activeUrl}`,
+      data: { url: activeUrl, port: targetPort, ...tunnelUrl ? { tunnelUrl } : {} }
+    };
+  }
+  return {
+    ok: true,
+    exitCode: EXIT_CODES.SUCCESS,
+    summary,
+    data: { url: activeUrl, port: targetPort, ...tunnelUrl ? { tunnelUrl } : {} }
+  };
+}
+
+export {
+  runDoctor,
+  refineAmend,
+  refineSite,
+  refinePrepare,
+  refineVerify,
+  resumeSite,
+  cancelSite,
+  importFeedback,
+  synthesizeSite,
+  previewSite,
+  deploySite,
+  shareSite
+};