visual-remote 0.3.0 → 0.3.2

package/apps/cli/dist/index.js

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { realpathSync } from "node:fs";
+import { realpathSync as realpathSync2 } from "node:fs";
 import { resolve as resolve8 } from "node:path";
 import { pathToFileURL } from "node:url";
 import { Command, InvalidArgumentError } from "commander";
 
+// src/bridge.ts
+import { createConnection } from "node:net";
+
 // ../../packages/bridge-core/src/bridge/control-service.ts
 var ControlServiceError = class extends Error {
   statusCode;
@@ -161,6 +164,11 @@ function pairingTokensMatch(expected, candidate) {
   const candidateBytes = Buffer.from(candidate);
   return expectedBytes.length === candidateBytes.length && timingSafeEqual(expectedBytes, candidateBytes);
 }
+function createPairingUrl(baseUrl, token) {
+  const url = new URL(baseUrl);
+  url.hash = `visual-pair=${encodeURIComponent(token)}`;
+  return url.toString();
+}
 
 // ../../packages/bridge-core/src/runtime/ports.ts
 import { createServer } from "node:net";
@@ -284,7 +292,7 @@ function originAllowed(request, allowedOrigins) {
   }
 }
 function tokenAccess(token, controlToken, viewerSessions, now) {
-  if (token === void 0 || token.length === 0) return "control";
+  if (token === void 0 || token.length === 0) return void 0;
   if (pairingTokensMatch(controlToken, token)) return "control";
   const expiresAt = viewerSessions.get(token);
   if (expiresAt !== void 0) {
@@ -689,7 +697,12 @@ function createGatewayServer(options) {
         const access3 = requestAccess(request, options.pairingToken, viewerSessions);
         if (access3 === void 0) {
           response.setHeader("www-authenticate", "Bearer");
-          writeApiError(response, 401, "unauthorized", "A valid viewer token is required");
+          writeApiError(
+            response,
+            401,
+            "unauthorized",
+            "A valid control or viewer token is required"
+          );
           return;
         }
         try {
@@ -958,131 +971,124 @@ var AgentCanceledError = class extends Error {
   }
 };
 
-// ../../packages/bridge-core/src/agents/codex-event-parser.ts
+// ../../packages/bridge-core/src/agents/claude-event-parser.ts
 function asRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 function asText(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function sessionId(record) {
-  const thread = asRecord(record.thread);
-  return asText(record.thread_id) ?? asText(record.threadId) ?? asText(record.session_id) ?? asText(record.sessionId) ?? (thread ? asText(thread.id) : void 0);
-}
-function itemFiles(item) {
-  const changes = Array.isArray(item.changes) ? item.changes : [];
-  const files = changes.flatMap((change) => {
-    const record = asRecord(change);
-    if (!record) return [];
-    return [asText(record.path) ?? asText(record.file_path) ?? asText(record.filePath)].filter(
-      (path) => path !== void 0
-    );
-  });
-  const direct = asText(item.path) ?? asText(item.file_path) ?? asText(item.filePath);
-  if (direct) files.push(direct);
-  return [...new Set(files)];
-}
-function parseCodexJsonLine(line) {
-  const trimmed = line.trim();
-  if (!trimmed) return [];
-  let value;
-  try {
-    value = JSON.parse(trimmed);
-  } catch {
-    return [{ type: "warning", text: trimmed }];
-  }
-  const record = asRecord(value);
-  if (!record) return [{ type: "message", text: trimmed }];
-  const type = asText(record.type) ?? "unknown";
-  const events = [];
-  const foundSession = sessionId(record);
-  if (foundSession) events.push({ type: "session", sessionId: foundSession });
-  if (type === "thread.started" || type === "thread.created") return events;
-  if (type === "turn.started") return [...events, { type: "phase", name: "turn.started" }];
-  if (type === "turn.completed") {
-    const result = asRecord(record.result);
-    const summary = asText(record.summary) ?? (result ? asText(result.summary) : void 0);
-    return [...events, summary ? { type: "complete", summary } : { type: "complete" }];
-  }
-  if (type === "turn.failed" || type === "error") {
-    const error = asRecord(record.error);
-    const text = asText(record.message) ?? (error ? asText(error.message) : void 0) ?? "Codex reported an error";
-    return [...events, { type: "error", text }];
-  }
-  const item = asRecord(record.item);
-  if (type === "item.started" && item) {
-    const itemType = asText(item.type) ?? "item";
-    const summary = asText(item.command) ?? asText(item.text);
-    const start = summary ? { type: "tool_start", name: itemType, summary } : { type: "tool_start", name: itemType };
-    return [...events, start];
-  }
-  if (type === "item.completed" && item) {
-    const itemType = asText(item.type) ?? "item";
-    if (itemType === "agent_message") {
-      const text = asText(item.text) ?? asText(item.message);
-      return text ? [...events, { type: "message", text }] : events;
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function contentBlocks(record) {
+  const message = asRecord(record.message);
+  return Array.isArray(message?.content) ? message.content.flatMap((block) => {
+    const parsed = asRecord(block);
+    return parsed === void 0 ? [] : [parsed];
+  }) : [];
+}
+function toolSummary(name, input) {
+  return asText(input.description) ?? asText(input.command) ?? asText(input.file_path) ?? asText(input.path) ?? (name === "Bash" ? "Run command" : void 0);
+}
+function filePath(input) {
+  return asText(input.file_path) ?? asText(input.path) ?? asText(input.notebook_path);
+}
+var ClaudeEventParser = class {
+  #defaultCwd;
+  #tools = /* @__PURE__ */ new Map();
+  #sessionId;
+  constructor(defaultCwd = "") {
+    this.#defaultCwd = defaultCwd;
+  }
+  parse(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return [];
+    let value;
+    try {
+      value = JSON.parse(trimmed);
+    } catch {
+      return [{ type: "warning", text: trimmed }];
+    }
+    const record = asRecord(value);
+    if (!record) return [{ type: "message", text: trimmed }];
+    const events = [];
+    const foundSession = asText(record.session_id) ?? asText(record.sessionId);
+    if (foundSession !== void 0 && foundSession !== this.#sessionId) {
+      this.#sessionId = foundSession;
+      events.push({ type: "session", sessionId: foundSession });
+    }
+    const type = asText(record.type) ?? "unknown";
+    if (type === "system") {
+      const subtype = asText(record.subtype);
+      if (subtype) events.push({ type: "phase", name: subtype });
+      return events;
+    }
+    if (type === "assistant") {
+      for (const block of contentBlocks(record)) {
+        if (block.type === "text") {
+          const text = asText(block.text);
+          if (text) events.push({ type: "message", text });
+          continue;
+        }
+        if (block.type !== "tool_use") continue;
+        const name = asText(block.name) ?? "tool";
+        const id = asText(block.id);
+        const input = asRecord(block.input) ?? {};
+        if (id) this.#tools.set(id, name);
+        const summary = toolSummary(name, input);
+        events.push(
+          summary ? { type: "tool_start", name, summary } : { type: "tool_start", name }
+        );
+        const command = name === "Bash" ? asText(input.command) : void 0;
+        if (command) {
+          events.push({ type: "command", command, cwd: this.#defaultCwd });
+        }
+        const path = filePath(input);
+        if (path && ["Edit", "Write", "NotebookEdit"].includes(name)) {
+          events.push({ type: "file_hint", path });
+        }
+      }
+      return events;
+    }
+    if (type === "user") {
+      for (const block of contentBlocks(record)) {
+        if (block.type !== "tool_result") continue;
+        const id = asText(block.tool_use_id);
+        const name = (id ? this.#tools.get(id) : void 0) ?? "tool";
+        if (id) this.#tools.delete(id);
+        events.push({ type: "tool_end", name, ok: block.is_error !== true });
+      }
+      return events;
     }
-    if (itemType === "command_execution") {
-      const command = asText(item.command);
-      if (command) {
+    if (type === "result") {
+      const usage = asRecord(record.usage);
+      if (usage) {
+        const cachedInputTokens = asNumber(usage.cache_read_input_tokens);
         events.push({
-          type: "command",
-          command,
-          cwd: asText(item.cwd) ?? ""
+          type: "usage",
+          inputTokens: asNumber(usage.input_tokens) + asNumber(usage.cache_creation_input_tokens) + cachedInputTokens,
+          outputTokens: asNumber(usage.output_tokens),
+          ...cachedInputTokens > 0 ? { cachedInputTokens } : {}
         });
       }
+      const result = asText(record.result);
+      const subtype = asText(record.subtype);
+      if (record.is_error === true || subtype?.startsWith("error") === true) {
+        events.push({ type: "error", text: result ?? "Claude reported an error" });
+      } else {
+        events.push(result ? { type: "complete", summary: result } : { type: "complete" });
+      }
+      return events;
     }
-    for (const path of itemFiles(item)) events.push({ type: "file_hint", path });
-    const exitCode = typeof item.exit_code === "number" ? item.exit_code : void 0;
-    events.push({ type: "tool_end", name: itemType, ok: exitCode === void 0 || exitCode === 0 });
     return events;
   }
-  const message = asText(record.message);
-  if (message) events.push({ type: "message", text: message });
-  return events;
-}
-
-// ../../packages/bridge-core/src/agents/codex-adapter.ts
-import { spawn as spawn2 } from "node:child_process";
-
-// ../../packages/bridge-core/src/agents/async-queue.ts
-var AsyncQueue = class {
-  #values = [];
-  #waiters = [];
-  #ended = false;
-  #error;
-  push(value) {
-    if (this.#ended) return;
-    const waiter = this.#waiters.shift();
-    if (waiter) waiter.resolve({ value, done: false });
-    else this.#values.push(value);
-  }
-  end(error) {
-    if (this.#ended) return;
-    this.#ended = true;
-    this.#error = error;
-    for (const waiter of this.#waiters.splice(0)) {
-      if (error !== void 0) waiter.reject(error);
-      else waiter.resolve({ value: void 0, done: true });
-    }
-  }
-  [Symbol.asyncIterator]() {
-    return {
-      next: async () => {
-        const value = this.#values.shift();
-        if (value !== void 0) return { value, done: false };
-        if (this.#ended) {
-          if (this.#error !== void 0) throw this.#error;
-          return { value: void 0, done: true };
-        }
-        return await new Promise((resolve9, reject) => {
-          this.#waiters.push({ resolve: resolve9, reject });
-        });
-      }
-    };
-  }
 };
 
+// ../../packages/bridge-core/src/agents/claude-adapter.ts
+import { execFile, spawn as spawn2 } from "node:child_process";
+import { promisify } from "node:util";
+
 // ../../packages/bridge-core/src/runtime/managed-process.ts
 import { spawn } from "node:child_process";
 function replacePortPlaceholder(value, port) {
@@ -1184,65 +1190,527 @@ async function startManagedProcess(options) {
   if (executable === void 0) {
     throw new Error("Managed dev command is empty");
   }
-  const detached = process.platform !== "win32";
-  const child = spawn(
-    replacePortPlaceholder(executable, options.upstreamPort),
-    rawArguments.map((argument) => replacePortPlaceholder(argument, options.upstreamPort)),
-    {
-      cwd: options.cwd,
-      env: {
-        ...options.environment ?? process.env,
-        HOST: "0.0.0.0",
-        PORT: String(options.upstreamPort)
-      },
-      detached,
-      stdio: [
-        "inherit",
-        options.stdout === void 0 ? "inherit" : "pipe",
-        options.stderr === void 0 ? "inherit" : "pipe"
-      ],
-      windowsHide: true
+  const detached = process.platform !== "win32";
+  const child = spawn(
+    replacePortPlaceholder(executable, options.upstreamPort),
+    rawArguments.map((argument) => replacePortPlaceholder(argument, options.upstreamPort)),
+    {
+      cwd: options.cwd,
+      env: {
+        ...options.environment ?? process.env,
+        HOST: "0.0.0.0",
+        PORT: String(options.upstreamPort)
+      },
+      detached,
+      stdio: [
+        "inherit",
+        options.stdout === void 0 ? "inherit" : "pipe",
+        options.stderr === void 0 ? "inherit" : "pipe"
+      ],
+      windowsHide: true
+    }
+  );
+  const removeEmergencyExitHook = installEmergencyChildExitHook(child);
+  const exit = new Promise(
+    (resolve9) => {
+      child.once("exit", (code, signal) => {
+        resolve9({ code, signal });
+      });
+    }
+  );
+  if (child.stdout !== null && options.stdout !== void 0) {
+    child.stdout.pipe(options.stdout, { end: false });
+  }
+  if (child.stderr !== null && options.stderr !== void 0) {
+    child.stderr.pipe(options.stderr, { end: false });
+  }
+  try {
+    await new Promise((resolve9, reject) => {
+      child.once("spawn", resolve9);
+      child.once("error", reject);
+    });
+  } catch (error) {
+    removeEmergencyExitHook();
+    throw error;
+  }
+  let stopPromise;
+  return {
+    child,
+    exit,
+    stop() {
+      stopPromise ??= terminateChildProcessTree(
+        child,
+        options.killGraceMs
+      ).finally(removeEmergencyExitHook);
+      return stopPromise;
+    }
+  };
+}
+
+// ../../packages/bridge-core/src/agents/async-queue.ts
+var AsyncQueue = class {
+  #values = [];
+  #waiters = [];
+  #ended = false;
+  #error;
+  push(value) {
+    if (this.#ended) return;
+    const waiter = this.#waiters.shift();
+    if (waiter) waiter.resolve({ value, done: false });
+    else this.#values.push(value);
+  }
+  end(error) {
+    if (this.#ended) return;
+    this.#ended = true;
+    this.#error = error;
+    for (const waiter of this.#waiters.splice(0)) {
+      if (error !== void 0) waiter.reject(error);
+      else waiter.resolve({ value: void 0, done: true });
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: async () => {
+        const value = this.#values.shift();
+        if (value !== void 0) return { value, done: false };
+        if (this.#ended) {
+          if (this.#error !== void 0) throw this.#error;
+          return { value: void 0, done: true };
+        }
+        return await new Promise((resolve9, reject) => {
+          this.#waiters.push({ resolve: resolve9, reject });
+        });
+      }
+    };
+  }
+};
+
+// ../../packages/bridge-core/src/agents/claude-adapter.ts
+var execFileAsync = promisify(execFile);
+var INHERITED_ENVIRONMENT = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "SHELL",
+  "LANG",
+  "LC_ALL",
+  "TERM",
+  "TMPDIR",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "XDG_STATE_HOME",
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "HTTPS_PROXY",
+  "HTTP_PROXY",
+  "NO_PROXY",
+  "USERPROFILE",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "SystemRoot",
+  "COMSPEC",
+  "PATHEXT"
+];
+var EMPTY_MCP_CONFIG = JSON.stringify({ mcpServers: {} });
+var CLAUDE_SETTINGS = JSON.stringify({
+  permissions: {
+    disableBypassPermissionsMode: "disable",
+    deny: [
+      "Read(./.env)",
+      "Read(./.env.*)",
+      "Read(./**/*.pem)",
+      "Read(./**/*.key)",
+      "Edit(./.git/**)",
+      "Edit(./.visualdev/runtime/**)",
+      "Edit(./node_modules/**)"
+    ]
+  },
+  sandbox: {
+    enabled: true,
+    autoAllowBashIfSandboxed: true,
+    allowUnsandboxedCommands: false,
+    network: { strictAllowlist: true }
+  }
+});
+function processEnv(overrides) {
+  const environment = {};
+  for (const key of INHERITED_ENVIRONMENT) {
+    const value = process.env[key];
+    if (value !== void 0) environment[key] = value;
+  }
+  return { ...environment, ...overrides };
+}
+function splitLines(chunk, previous, onLine) {
+  const combined = previous + chunk.toString();
+  const lines = combined.split(/\r?\n/);
+  const remainder = lines.pop() ?? "";
+  for (const line of lines) onLine(line);
+  return remainder;
+}
+var ClaudeAdapter = class {
+  id = "claude";
+  #executable;
+  #killGraceMs;
+  #model;
+  #reasoningEffort;
+  #rtkExecutable;
+  #rtkVersion;
+  constructor(options = {}) {
+    this.#executable = options.executable ?? "claude";
+    this.#killGraceMs = options.killGraceMs ?? 2e3;
+    this.#model = options.model;
+    this.#reasoningEffort = options.reasoningEffort;
+    this.#rtkExecutable = options.rtkExecutable ?? "rtk";
+  }
+  #probeRtk(environment) {
+    if (this.#rtkExecutable === false) return Promise.resolve(void 0);
+    this.#rtkVersion ??= execFileAsync(this.#rtkExecutable, ["--version"], {
+      encoding: "utf8",
+      env: environment,
+      timeout: 1e3,
+      windowsHide: true,
+      maxBuffer: 16 * 1024
+    }).then(({ stdout }) => stdout.trim().split(/\r?\n/, 1)[0] || void 0).catch(() => void 0);
+    return this.#rtkVersion;
+  }
+  async #runtimePrompt(input, environment) {
+    if (this.#rtkExecutable === false) return input.prompt;
+    const guidance = await this.#probeRtk(environment).then(
+      (version) => version ? `RTK command proxy:
+- ${version} is installed and available in this runtime.
+- Prefix shell commands with RTK by default (for example: rtk git status, rtk rg <pattern>, rtk read <file>, rtk npm test).
+- Use the native command only when RTK has no suitable proxy or RTK execution fails. Do not spend time rediscovering or reinstalling RTK.` : `RTK command proxy:
+- RTK was not detected in this runtime. Use native repository commands directly and do not spend time searching for RTK.`
+    );
+    return `${input.prompt.trimEnd()}
+
+${guidance}
+`;
+  }
+  #baseArgs() {
+    return [
+      "-p",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--permission-mode",
+      "acceptEdits",
+      "--strict-mcp-config",
+      "--mcp-config",
+      EMPTY_MCP_CONFIG,
+      "--no-chrome",
+      "--tools",
+      "Read,Glob,Grep,Edit,Write,Bash",
+      "--settings",
+      CLAUDE_SETTINGS,
+      ...this.#model === void 0 ? [] : ["--model", this.#model],
+      ...this.#reasoningEffort === void 0 ? [] : ["--effort", this.#reasoningEffort]
+    ];
+  }
+  async probe() {
+    return await new Promise((resolve9) => {
+      const child = spawn2(this.#executable, ["--version"], {
+        stdio: ["ignore", "pipe", "ignore"],
+        shell: false
+      });
+      let output2 = "";
+      child.stdout?.on("data", (chunk) => {
+        output2 += chunk.toString();
+      });
+      child.once("error", () => {
+        resolve9({ available: false, supportsResume: true, structuredOutput: true });
+      });
+      child.once("close", (code) => {
+        const match = output2.match(/(\d+\.\d+\.\d+(?:[-+][^\s]+)?)/);
+        const capabilities = {
+          available: code === 0,
+          supportsResume: true,
+          structuredOutput: true
+        };
+        if (match?.[1]) capabilities.version = match[1];
+        resolve9(capabilities);
+      });
+    });
+  }
+  async *run(input, signal) {
+    yield* this.#execute(input, signal, this.#baseArgs());
+  }
+  async *resume(input, signal) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/.test(input.sessionId)) {
+      throw new Error("Refusing to resume an invalid Claude session id");
+    }
+    yield* this.#execute(
+      input,
+      signal,
+      [...this.#baseArgs(), "--resume", input.sessionId]
+    );
+  }
+  async *#execute(input, signal, args) {
+    const queue = new AsyncQueue();
+    const environment = processEnv(input.environment);
+    const prompt = await this.#runtimePrompt(input, environment);
+    const parser = new ClaudeEventParser(input.workspaceRoot);
+    const child = spawn2(this.#executable, args, {
+      cwd: input.workspaceRoot,
+      env: environment,
+      detached: process.platform !== "win32",
+      shell: false,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const removeEmergencyExitHook = installEmergencyChildExitHook(child);
+    let stdoutRemainder = "";
+    let stderrRemainder = "";
+    let timedOut = false;
+    let aborted = signal.aborted;
+    let termination;
+    const requestTermination = () => {
+      termination ??= terminateChildProcessTree(
+        child,
+        this.#killGraceMs
+      ).finally(removeEmergencyExitHook);
+      return termination;
+    };
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      void requestTermination();
+    }, Math.max(1, input.maxRunMs));
+    timeout.unref();
+    const abort = () => {
+      aborted = true;
+      void requestTermination();
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+    child.stdout.on("data", (chunk) => {
+      stdoutRemainder = splitLines(chunk, stdoutRemainder, (line) => {
+        for (const event of parser.parse(line)) queue.push(event);
+      });
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrRemainder = splitLines(chunk, stderrRemainder, (line) => {
+        if (line.trim()) queue.push({ type: "warning", text: line });
+      });
+    });
+    child.once("error", (error) => queue.end(error));
+    child.once("close", (code, closeSignal) => {
+      clearTimeout(timeout);
+      signal.removeEventListener("abort", abort);
+      void (async () => {
+        await requestTermination();
+        if (stdoutRemainder.trim()) {
+          for (const event of parser.parse(stdoutRemainder)) queue.push(event);
+        }
+        if (stderrRemainder.trim()) queue.push({ type: "warning", text: stderrRemainder });
+        if (timedOut) queue.end(new AgentTimeoutError());
+        else if (aborted) queue.end(new AgentCanceledError());
+        else if (code !== 0) {
+          queue.end(
+            new AgentProcessError(
+              `Claude exited with code ${String(code)}`,
+              code,
+              closeSignal
+            )
+          );
+        } else {
+          queue.end();
+        }
+      })().catch((error) => queue.end(error));
+    });
+    child.stdin.on("error", (error) => {
+      if (error.code !== "EPIPE") queue.end(error);
+    });
+    child.stdin.end(prompt);
+    try {
+      for await (const event of queue) yield event;
+    } finally {
+      clearTimeout(timeout);
+      signal.removeEventListener("abort", abort);
+      try {
+        if (child.exitCode === null && child.signalCode === null) {
+          await requestTermination();
+        } else if (termination) {
+          await termination;
+        }
+      } finally {
+        removeEmergencyExitHook();
+      }
+    }
+  }
+};
+
+// ../../packages/bridge-core/src/agents/codex-event-parser.ts
+function asRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function asText2(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function sessionId(record) {
+  const thread = asRecord2(record.thread);
+  return asText2(record.thread_id) ?? asText2(record.threadId) ?? asText2(record.session_id) ?? asText2(record.sessionId) ?? (thread ? asText2(thread.id) : void 0);
+}
+function itemFiles(item) {
+  const changes = Array.isArray(item.changes) ? item.changes : [];
+  const files = changes.flatMap((change) => {
+    const record = asRecord2(change);
+    if (!record) return [];
+    return [asText2(record.path) ?? asText2(record.file_path) ?? asText2(record.filePath)].filter(
+      (path) => path !== void 0
+    );
+  });
+  const direct = asText2(item.path) ?? asText2(item.file_path) ?? asText2(item.filePath);
+  if (direct) files.push(direct);
+  return [...new Set(files)];
+}
+function stringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : void 0;
+}
+function formatArgv(argv) {
+  return argv.map((argument) => /^[A-Za-z0-9_./:=@%+,-]+$/u.test(argument) ? argument : JSON.stringify(argument)).join(" ");
+}
+function isDirectExecItem(item) {
+  return item.type === "mcp_tool_call" && item.server === "visual_remote_exec" && item.tool === "run_readonly";
+}
+function directExecSummary(item) {
+  const arguments_ = asRecord2(item.arguments);
+  const commands = Array.isArray(arguments_?.commands) ? arguments_.commands : [];
+  const summaries = commands.flatMap((candidate) => {
+    const command = asRecord2(candidate);
+    const argv = stringArray(command?.argv);
+    return argv === void 0 ? [] : [formatArgv(argv)];
+  });
+  return summaries.length === 0 ? void 0 : summaries.join(" \xB7 ");
+}
+function directExecResults(item, defaultCwd) {
+  const result = asRecord2(item.result);
+  const structured = asRecord2(result?.structured_content ?? result?.structuredContent);
+  const results = Array.isArray(structured?.results) ? structured.results : [];
+  return results.flatMap((candidate) => {
+    const command = asRecord2(candidate);
+    const argv = stringArray(command?.argv);
+    if (argv === void 0) return [];
+    const exitCode = typeof command?.exitCode === "number" ? command.exitCode : void 0;
+    const durationMs = typeof command?.durationMs === "number" ? command.durationMs : void 0;
+    return [{
+      command: formatArgv(argv),
+      cwd: asText2(command?.cwd) ?? defaultCwd,
+      ok: exitCode === 0,
+      ...exitCode === void 0 ? {} : { exitCode },
+      ...durationMs === void 0 ? {} : { durationMs },
+      ...typeof command?.usedRtk === "boolean" ? { usedRtk: command.usedRtk } : {},
+      ...typeof command?.timedOut === "boolean" ? { timedOut: command.timedOut } : {},
+      ...typeof command?.truncated === "boolean" ? { truncated: command.truncated } : {}
+    }];
+  });
+}
+function normalizedUsage(record) {
+  const result = asRecord2(record.result);
+  const usage = asRecord2(record.usage) ?? (result ? asRecord2(result.usage) : void 0);
+  if (usage === void 0) return void 0;
+  const inputTokens = usage.input_tokens ?? usage.inputTokens;
+  const outputTokens = usage.output_tokens ?? usage.outputTokens;
+  const cachedInputTokens = usage.cached_input_tokens ?? usage.cachedInputTokens;
+  if (typeof inputTokens !== "number" || typeof outputTokens !== "number") {
+    return void 0;
+  }
+  return {
+    type: "usage",
+    inputTokens,
+    outputTokens,
+    ...typeof cachedInputTokens === "number" ? { cachedInputTokens } : {}
+  };
+}
+function parseCodexJsonLine(line, defaultCwd = "") {
+  const trimmed = line.trim();
+  if (!trimmed) return [];
+  let value;
+  try {
+    value = JSON.parse(trimmed);
+  } catch {
+    return [{ type: "warning", text: trimmed }];
+  }
+  const record = asRecord2(value);
+  if (!record) return [{ type: "message", text: trimmed }];
+  const type = asText2(record.type) ?? "unknown";
+  const events = [];
+  const foundSession = sessionId(record);
+  if (foundSession) events.push({ type: "session", sessionId: foundSession });
+  if (type === "thread.started" || type === "thread.created") return events;
+  if (type === "turn.started") return [...events, { type: "phase", name: "turn.started" }];
+  if (type === "turn.completed") {
+    const result = asRecord2(record.result);
+    const summary = asText2(record.summary) ?? (result ? asText2(result.summary) : void 0);
+    const usage = normalizedUsage(record);
+    return [
+      ...events,
+      ...usage === void 0 ? [] : [usage],
+      summary ? { type: "complete", summary } : { type: "complete" }
+    ];
+  }
+  if (type === "turn.failed" || type === "error") {
+    const error = asRecord2(record.error);
+    const text = asText2(record.message) ?? (error ? asText2(error.message) : void 0) ?? "Codex reported an error";
+    return [...events, { type: "error", text }];
+  }
+  const item = asRecord2(record.item);
+  if (type === "item.started" && item) {
+    const itemType = asText2(item.type) ?? "item";
+    const directExec = isDirectExecItem(item);
+    const summary = directExec ? directExecSummary(item) : asText2(item.command) ?? asText2(item.text);
+    const start = summary ? { type: "tool_start", name: directExec ? "direct_exec" : itemType, summary } : { type: "tool_start", name: directExec ? "direct_exec" : itemType };
+    return [...events, start];
+  }
+  if (type === "item.completed" && item) {
+    const itemType = asText2(item.type) ?? "item";
+    if (itemType === "agent_message") {
+      const text = asText2(item.text) ?? asText2(item.message);
+      return text ? [...events, { type: "message", text }] : events;
     }
-  );
-  const removeEmergencyExitHook = installEmergencyChildExitHook(child);
-  const exit = new Promise(
-    (resolve9) => {
-      child.once("exit", (code, signal) => {
-        resolve9({ code, signal });
+    if (itemType === "command_execution") {
+      const command = asText2(item.command);
+      if (command) {
+        events.push({
+          type: "command",
+          command,
+          cwd: asText2(item.cwd) ?? defaultCwd
+        });
+      }
+    }
+    const directResults = isDirectExecItem(item) ? directExecResults(item, defaultCwd) : [];
+    for (const result of directResults) {
+      events.push({
+        type: "command",
+        command: result.command,
+        cwd: result.cwd,
+        ...result.exitCode === void 0 ? {} : { exitCode: result.exitCode },
+        ...result.durationMs === void 0 ? {} : { durationMs: result.durationMs },
+        ...result.usedRtk === void 0 ? {} : { usedRtk: result.usedRtk },
+        ...result.timedOut === void 0 ? {} : { timedOut: result.timedOut },
+        ...result.truncated === void 0 ? {} : { truncated: result.truncated }
       });
     }
-  );
-  if (child.stdout !== null && options.stdout !== void 0) {
-    child.stdout.pipe(options.stdout, { end: false });
-  }
-  if (child.stderr !== null && options.stderr !== void 0) {
-    child.stderr.pipe(options.stderr, { end: false });
-  }
-  try {
-    await new Promise((resolve9, reject) => {
-      child.once("spawn", resolve9);
-      child.once("error", reject);
+    for (const path of itemFiles(item)) events.push({ type: "file_hint", path });
+    const exitCode = typeof item.exit_code === "number" ? item.exit_code : void 0;
+    events.push({
+      type: "tool_end",
+      name: isDirectExecItem(item) ? "direct_exec" : itemType,
+      ok: directResults.length > 0 ? directResults.every((result) => result.ok) : exitCode === void 0 || exitCode === 0
     });
-  } catch (error) {
-    removeEmergencyExitHook();
-    throw error;
+    return events;
   }
-  let stopPromise;
-  return {
-    child,
-    exit,
-    stop() {
-      stopPromise ??= terminateChildProcessTree(
-        child,
-        options.killGraceMs
-      ).finally(removeEmergencyExitHook);
-      return stopPromise;
-    }
-  };
+  const message = asText2(record.message);
+  if (message) events.push({ type: "message", text: message });
+  return events;
 }
 
 // ../../packages/bridge-core/src/agents/codex-adapter.ts
-var INHERITED_ENVIRONMENT = [
+import { execFile as execFile2, spawn as spawn3 } from "node:child_process";
+import { existsSync } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
+var INHERITED_ENVIRONMENT2 = [
   "PATH",
   "HOME",
   "USER",
@@ -1267,32 +1735,104 @@ var INHERITED_ENVIRONMENT = [
   "COMSPEC",
   "PATHEXT"
 ];
-function processEnv(overrides) {
+function processEnv2(overrides) {
   const environment = {};
-  for (const key of INHERITED_ENVIRONMENT) {
+  for (const key of INHERITED_ENVIRONMENT2) {
     const value = process.env[key];
     if (value !== void 0) environment[key] = value;
   }
   return { ...environment, ...overrides };
 }
-function splitLines(chunk, previous, onLine) {
+function splitLines2(chunk, previous, onLine) {
   const combined = previous + chunk.toString();
   const lines = combined.split(/\r?\n/);
   const remainder = lines.pop() ?? "";
   for (const line of lines) onLine(line);
   return remainder;
 }
+function defaultDirectExecMcpScript() {
+  const candidates = [
+    fileURLToPath2(new URL("./direct-exec-mcp.js", import.meta.url)),
+    fileURLToPath2(
+      new URL("../../../../apps/cli/dist/direct-exec-mcp.js", import.meta.url)
+    )
+  ];
+  return candidates.find((candidate) => existsSync(candidate));
+}
 var CodexAdapter = class {
   id = "codex";
   #executable;
   #killGraceMs;
+  #model;
+  #profile;
+  #reasoningEffort;
+  #rtkExecutable;
+  #directExecMcpScript;
+  #rtkVersion;
   constructor(options = {}) {
     this.#executable = options.executable ?? "codex";
     this.#killGraceMs = options.killGraceMs ?? 2e3;
+    this.#model = options.model;
+    this.#profile = options.profile;
+    this.#reasoningEffort = options.reasoningEffort;
+    this.#rtkExecutable = options.rtkExecutable ?? "rtk";
+    this.#directExecMcpScript = options.directExecMcpScript === false ? void 0 : options.directExecMcpScript ?? defaultDirectExecMcpScript();
+  }
+  #probeRtk(environment) {
+    if (this.#rtkExecutable === false) return Promise.resolve(void 0);
+    this.#rtkVersion ??= execFileAsync2(this.#rtkExecutable, ["--version"], {
+      encoding: "utf8",
+      env: environment,
+      timeout: 1e3,
+      windowsHide: true,
+      maxBuffer: 16 * 1024
+    }).then(({ stdout }) => stdout.trim().split(/\r?\n/, 1)[0] || void 0).catch(() => void 0);
+    return this.#rtkVersion;
+  }
+  async #runtimePrompt(input, environment) {
+    const commandGuidance = this.#rtkExecutable === false ? "" : await this.#probeRtk(environment).then((version) => version ? `RTK command proxy:
+- ${version} is installed and available in this runtime.
+- Prefix shell commands with RTK by default (for example: rtk git status, rtk rg <pattern>, rtk read <file>, rtk npm test).
+- Use the native command only when RTK has no suitable proxy or RTK execution fails. Do not spend time rediscovering or reinstalling RTK.` : `RTK command proxy:
+- RTK was not detected in this runtime. Use native repository commands directly and do not spend time searching for RTK.`);
+    const directExecGuidance = this.#directExecMcpScript === void 0 ? "" : `Direct read-only command runner:
+- Use the visual_remote_exec run_readonly MCP tool (mcp__visual_remote_exec__run_readonly) for repository inspection by default: pwd, version checks, file listing/reading/search, and read-only Git status/diff/log/show.
+- Send argv arrays, batch independent reads in one tool call, and keep cwd at the registered workspace unless a known subdirectory is required.
+- The tool executes without a shell and applies RTK automatically when supported.
+- Use command_execution only for edits, tests/builds, or commands that genuinely require shell syntax. Do not retry a policy-rejected command through another shell unless the requested work requires that non-read-only operation.`;
+    const guidance = [directExecGuidance, commandGuidance].filter(Boolean).join("\n\n");
+    return guidance.length === 0 ? input.prompt : `${input.prompt.trimEnd()}
+
+${guidance}
+`;
+  }
+  #directExecConfig(input) {
+    if (this.#directExecMcpScript === void 0) return [];
+    const serverArgs = [
+      this.#directExecMcpScript,
+      "--repo-root",
+      input.repoRoot,
+      "--workspace-root",
+      input.workspaceRoot,
+      ...this.#rtkExecutable === false ? ["--no-rtk"] : ["--rtk", this.#rtkExecutable]
+    ];
+    return [
+      "-c",
+      `mcp_servers.visual_remote_exec.command=${JSON.stringify(process.execPath)}`,
+      "-c",
+      `mcp_servers.visual_remote_exec.args=${JSON.stringify(serverArgs)}`
+    ];
+  }
+  #modelConfig() {
+    return [
+      ...this.#profile === void 0 ? [] : ["--profile", this.#profile],
+      ...this.#model === void 0 ? [] : ["--model", this.#model],
+      ...this.#reasoningEffort === void 0 ? [] : ["-c", `model_reasoning_effort=${JSON.stringify(this.#reasoningEffort)}`]
+    ];
   }
   async probe() {
     return await new Promise((resolve9) => {
-      const child = spawn2(this.#executable, ["--version"], {
+      const child = spawn3(this.#executable, ["--version"], {
         stdio: ["ignore", "pipe", "ignore"],
         shell: false
       });
@@ -1324,7 +1864,9 @@ var CodexAdapter = class {
       "-s",
       "workspace-write",
       "-C",
-      input.repoRoot,
+      input.workspaceRoot,
+      ...this.#modelConfig(),
+      ...this.#directExecConfig(input),
       "-"
     ];
     yield* this.#execute(input, signal, args);
@@ -1341,7 +1883,9 @@ var CodexAdapter = class {
       "-s",
       "workspace-write",
       "-C",
-      input.repoRoot,
+      input.workspaceRoot,
+      ...this.#modelConfig(),
+      ...this.#directExecConfig(input),
       "resume",
       input.sessionId,
       "-"
@@ -1350,9 +1894,11 @@ var CodexAdapter = class {
   }
   async *#execute(input, signal, args) {
     const queue = new AsyncQueue();
-    const child = spawn2(this.#executable, args, {
-      cwd: input.repoRoot,
-      env: processEnv(input.environment),
+    const environment = processEnv2(input.environment);
+    const prompt = await this.#runtimePrompt(input, environment);
+    const child = spawn3(this.#executable, args, {
+      cwd: input.workspaceRoot,
+      env: environment,
       detached: process.platform !== "win32",
       shell: false,
       stdio: ["pipe", "pipe", "pipe"]
@@ -1382,12 +1928,12 @@ var CodexAdapter = class {
     signal.addEventListener("abort", abort, { once: true });
     if (signal.aborted) abort();
     child.stdout.on("data", (chunk) => {
-      stdoutRemainder = splitLines(chunk, stdoutRemainder, (line) => {
-        for (const event of parseCodexJsonLine(line)) queue.push(event);
+      stdoutRemainder = splitLines2(chunk, stdoutRemainder, (line) => {
+        for (const event of parseCodexJsonLine(line, input.workspaceRoot)) queue.push(event);
       });
     });
     child.stderr.on("data", (chunk) => {
-      stderrRemainder = splitLines(chunk, stderrRemainder, (line) => {
+      stderrRemainder = splitLines2(chunk, stderrRemainder, (line) => {
         if (line.trim()) queue.push({ type: "warning", text: line });
       });
     });
@@ -1398,7 +1944,9 @@ var CodexAdapter = class {
       void (async () => {
         await requestTermination();
         if (stdoutRemainder.trim()) {
-          for (const event of parseCodexJsonLine(stdoutRemainder)) queue.push(event);
+          for (const event of parseCodexJsonLine(stdoutRemainder, input.workspaceRoot)) {
+            queue.push(event);
+          }
         }
         if (stderrRemainder.trim()) queue.push({ type: "warning", text: stderrRemainder });
         if (timedOut) queue.end(new AgentTimeoutError());
@@ -1419,7 +1967,7 @@ var CodexAdapter = class {
     child.stdin.on("error", (error) => {
       if (error.code !== "EPIPE") queue.end(error);
     });
-    child.stdin.end(input.prompt);
+    child.stdin.end(prompt);
     try {
       for await (const event of queue) yield event;
     } finally {
@@ -1438,6 +1986,9 @@ var CodexAdapter = class {
   }
 };
 
+// ../../packages/bridge-core/src/agents/direct-exec.ts
+var DEFAULT_OUTPUT_BYTES = 64 * 1024;
+
 // ../../packages/bridge-core/src/config/loader.ts
 import { readFile, realpath, stat as stat2 } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
@@ -1448,6 +1999,7 @@ import { ZodError } from "zod";
 import { z } from "zod";
 var servicePortSchema = z.number().int().min(10001).max(65535);
 var commandSchema = z.array(z.string().min(1)).min(1);
+var environmentVariableSchema = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/, "Expected an environment variable name");
 var readySchema = z.object({
   path: z.string().startsWith("/").default("/"),
   timeoutMs: z.number().int().positive().default(6e4)
@@ -1476,9 +2028,38 @@ var visualDevConfigSchema = z.object({
   }).strict(),
   agent: z.object({
     adapter: z.enum(["codex", "claude", "opencode"]),
+    model: z.string().trim().min(1).optional(),
+    reasoningEffort: z.enum(["minimal", "low", "medium", "high", "xhigh", "max"]).optional(),
+    profile: z.string().trim().regex(
+      /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/,
+      "Expected a Codex profile name"
+    ).optional(),
+    inheritEnv: z.array(environmentVariableSchema).default([]),
     maxRunMs: z.number().int().positive(),
     resumeMode: z.enum(["auto", "new"]).default("auto")
-  }).strict(),
+  }).strict().superRefine((agent, context) => {
+    if (agent.adapter === "claude" && agent.reasoningEffort === "minimal") {
+      context.addIssue({
+        code: "custom",
+        path: ["reasoningEffort"],
+        message: "minimal reasoning effort is only supported by the Codex adapter"
+      });
+    }
+    if (agent.adapter === "codex" && agent.reasoningEffort === "max") {
+      context.addIssue({
+        code: "custom",
+        path: ["reasoningEffort"],
+        message: "max reasoning effort is only supported by the Claude adapter"
+      });
+    }
+    if (agent.adapter !== "codex" && agent.profile !== void 0) {
+      context.addIssue({
+        code: "custom",
+        path: ["profile"],
+        message: "agent.profile is only supported by the Codex adapter"
+      });
+    }
+  }),
   queue: z.object({
     maxPending: z.number().int().positive()
   }).strict(),
@@ -1522,6 +2103,7 @@ function createDefaultConfig(projectId) {
     },
     agent: {
       adapter: "codex",
+      inheritEnv: [],
       maxRunMs: 9e5,
       resumeMode: "auto"
     },
@@ -1594,17 +2176,17 @@ function mergeConfigValues(base, override) {
   }
   return merged;
 }
-async function readYamlMapping(filePath, required) {
+async function readYamlMapping(filePath2, required) {
   let source;
   try {
-    source = await readFile(filePath, "utf8");
+    source = await readFile(filePath2, "utf8");
   } catch (error) {
     if (!required && typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
       return void 0;
     }
-    throw new VisualDevConfigError(`Unable to read config: ${filePath}`, {
+    throw new VisualDevConfigError(`Unable to read config: ${filePath2}`, {
       cause: error,
-      filePath
+      filePath: filePath2
     });
   }
   try {
@@ -1617,9 +2199,9 @@ async function readYamlMapping(filePath, required) {
     }
     return value;
   } catch (error) {
-    throw new VisualDevConfigError(`Invalid YAML in ${filePath}`, {
+    throw new VisualDevConfigError(`Invalid YAML in ${filePath2}`, {
       cause: error,
-      filePath
+      filePath: filePath2
     });
   }
 }
@@ -1758,10 +2340,10 @@ var RevertConflictError = class extends RepositorySafetyError {
 };
 
 // ../../packages/bridge-core/src/git/git-command.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 async function runGit(args, options) {
   return await new Promise((resolve9, reject) => {
-    const child = spawn3("git", [...args], {
+    const child = spawn4("git", [...args], {
       cwd: options.cwd,
       env: { ...process.env, ...options.env ?? {} },
       shell: false,
@@ -1867,6 +2449,20 @@ function isWithin(root, candidate) {
   const path = relative2(root, candidate);
   return path === "" || !path.startsWith(`..${sep2}`) && path !== ".." && !isAbsolute2(path);
 }
+function rebaseWorkspacePatterns(repoRoot, workspaceRoot, patterns) {
+  const repository = resolve2(repoRoot);
+  const workspace = resolve2(workspaceRoot);
+  if (!isWithin(repository, workspace)) {
+    throw new PathSafetyError(
+      "PATH_OUTSIDE_REPOSITORY",
+      workspaceRoot,
+      `Workspace is outside the repository: ${workspaceRoot}`
+    );
+  }
+  const prefix = repositoryRelative(repository, workspace);
+  if (!prefix) return [...patterns];
+  return patterns.map((pattern) => normalizeSlashes(`${prefix}/${pattern}`));
+}
 var PathPolicy = class {
   repoRoot;
   allowedPatterns;
@@ -2710,6 +3306,9 @@ var TERMINAL = /* @__PURE__ */ new Set(["accepted", "reverted", "failed", "cance
 function isActiveTaskStatus(status) {
   return status !== "queued" && status !== "review" && !TERMINAL.has(status);
 }
+function isWorkingTaskStatus(status) {
+  return status === "queued" || isActiveTaskStatus(status);
+}
 function isTerminalTaskStatus(status) {
   return TERMINAL.has(status);
 }
@@ -2764,14 +3363,18 @@ Follow-up context:
 - Previous request: ${options.parent.requestText}
 - Previous diff summary: ${options.parent.diffSummary || "No file changes"}
 ` : "";
-  return `You are editing the repository at: ${options.repoRoot}
-Workspace: ${options.workspaceRoot}
+  return `Target service context (authoritative):
+- Repository worktree: ${options.repoRoot}
+- Workspace: ${options.workspaceRoot}
+- Browser URL: ${options.context.page.url}
+${options.upstreamUrl ? `- Local upstream URL: ${options.upstreamUrl}
+` : ""}
+Treat the workspace above as the already-resolved service directory and the repository worktree as its safety boundary. Run project commands from the workspace; do not search parent directories or run directory-discovery commands to locate the project again.
 
 User request:
 ${options.context.request.text}
 
 Selected UI context:
-- URL: ${options.context.page.url}
 - Route: ${options.context.page.pathname}
 - Selection mode: ${options.context.selection.mode}
 ${targets || "- No concrete target; use the page context and repository search."}
@@ -2809,7 +3412,7 @@ import { relative as relative5, resolve as resolve6, sep as sep5 } from "node:pa
 // ../../packages/bridge-core/src/source/path-normalizer.ts
 import { access, readFile as readFile3, realpath as realpath6 } from "node:fs/promises";
 import { isAbsolute as isAbsolute3, relative as relative4, resolve as resolve5, sep as sep4 } from "node:path";
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 function toPosix(value) {
   return value.split(sep4).join("/").replaceAll("\\", "/");
 }
@@ -2844,7 +3447,7 @@ function isWithin2(root, candidate) {
 }
 async function gitFiles(repoRoot) {
   return await new Promise((resolvePromise, reject) => {
-    const child = spawn4(
+    const child = spawn5(
       "git",
       ["ls-files", "--cached", "--others", "--exclude-standard", "-z"],
       {
@@ -2914,8 +3517,8 @@ async function normalizeSourceLocation(input, repoRootInput) {
       candidates: matches.slice(0, 20)
     };
   }
-  const filePath = matches[0];
-  const absolutePath = resolve5(repoRoot, filePath);
+  const filePath2 = matches[0];
+  const absolutePath = resolve5(repoRoot, filePath2);
   const canonical = await realpath6(absolutePath);
   if (!isWithin2(repoRoot, canonical)) {
     return { input, confidence: "unknown", candidates: [] };
@@ -2923,7 +3526,7 @@ async function normalizeSourceLocation(input, repoRootInput) {
   const lineNumber = await boundedLine(canonical, input.lineNumber);
   return {
     input,
-    filePath,
+    filePath: filePath2,
     absolutePath: canonical,
     ...lineNumber === void 0 ? {} : { lineNumber },
     ...input.columnNumber === void 0 ? {} : { columnNumber: input.columnNumber },
@@ -3246,6 +3849,7 @@ function repositoryGuardMessage(result) {
 var TaskService = class {
   #projectId;
   #workspaceRoot;
+  #upstreamUrl;
   #adapter;
   #store;
   #git;
@@ -3269,6 +3873,7 @@ var TaskService = class {
   constructor(options) {
     this.#projectId = options.projectId;
     this.#workspaceRoot = resolve6(options.workspaceRoot ?? options.git.repoRoot);
+    this.#upstreamUrl = options.upstreamUrl;
     if (!isWithin3(options.git.repoRoot, this.#workspaceRoot)) {
       throw new TaskServiceError(
         "WORKSPACE_OUTSIDE_REPOSITORY",
@@ -3655,6 +4260,7 @@ var TaskService = class {
       const prompt = buildAgentPrompt({
         repoRoot: this.#git.repoRoot,
         workspaceRoot: this.#workspaceRoot,
+        ...this.#upstreamUrl === void 0 ? {} : { upstreamUrl: this.#upstreamUrl },
         contextBundlePath: contextPath,
         context,
         allowedPatterns: this.#git.pathPolicy.allowedPatterns,
@@ -3848,11 +4454,11 @@ var TaskService = class {
     for (const target of result.selection.targets) {
       const sanitize = async (location) => {
         try {
-          const filePath = await this.#git.pathPolicy.assertFilesystemPathAllowed(
+          const filePath2 = await this.#git.pathPolicy.assertFilesystemPathAllowed(
             location.filePath,
             false
           );
-          return { ...location, filePath };
+          return { ...location, filePath: filePath2 };
         } catch {
           return void 0;
         }
@@ -3887,6 +4493,18 @@ var TaskService = class {
 };
 
 // ../../packages/bridge-core/src/verification/browser-sessions.ts
+function errorSignature(event) {
+  return `${event.level}\0${event.message}`;
+}
+function samePage(left, right) {
+  try {
+    const leftUrl = new URL(left);
+    const rightUrl = new URL(right);
+    return leftUrl.origin === rightUrl.origin && leftUrl.pathname === rightUrl.pathname && leftUrl.search === rightUrl.search;
+  } catch {
+    return left === right;
+  }
+}
 var BrowserSessionManager = class {
   #sessions = /* @__PURE__ */ new Map();
   #maxConsoleEvents;
@@ -3962,7 +4580,13 @@ var BrowserSessionManager = class {
     return {
       browserSessionId: id,
       renderRevision: session.renderRevision,
-      startedAt: now.toISOString()
+      startedAt: now.toISOString(),
+      url: session.url,
+      knownErrorSignatures: [
+        ...new Set(
+          session.consoleEvents.filter((event) => event.level === "error" || event.level === "unhandled").map(errorSignature)
+        )
+      ]
     };
   }
   verify(baseline, options = {}) {
@@ -3975,10 +4599,16 @@ var BrowserSessionManager = class {
         summary: "Origin browser session is disconnected."
       };
     }
-    const newErrors = session.consoleEvents.filter(
-      (event) => event.createdAt >= baseline.startedAt && (event.level === "error" || event.level === "unhandled")
-    );
+    const knownErrors = new Set(baseline.knownErrorSignatures);
+    const newErrors = [
+      ...new Map(
+        session.consoleEvents.filter(
+          (event) => event.createdAt > baseline.startedAt && (event.level === "error" || event.level === "unhandled") && !knownErrors.has(errorSignature(event))
+        ).map((event) => [errorSignature(event), event])
+      ).values()
+    ];
     const renderChanged = session.renderRevision > baseline.renderRevision;
+    const pageUnchanged = samePage(baseline.url, session.url);
     const targetResult = options.taskId === void 0 ? void 0 : session.targetResults.filter(
       (result) => result.taskId === options.taskId && result.createdAt >= baseline.startedAt
     ).at(-1);
@@ -3991,6 +4621,15 @@ var BrowserSessionManager = class {
         summary: `${newErrors.length} new browser error${newErrors.length === 1 ? "" : "s"} detected.`
       };
     }
+    if (!pageUnchanged) {
+      return {
+        status: "partial",
+        renderChanged,
+        newErrors: [],
+        ...targetResult ? { targetResult } : {},
+        summary: "Origin browser navigated to a different page during verification."
+      };
+    }
     if (options.targetEvidenceRequired) {
       const targetChanged = targetResult?.state === "found-and-changed" && targetResult.targetCount > 0 && targetResult.foundCount === targetResult.targetCount && targetResult.changedCount > 0 && targetResult.renderRevision > baseline.renderRevision;
       if (targetChanged) {
@@ -4031,7 +4670,7 @@ var BrowserSessionManager = class {
 };
 
 // ../../packages/bridge-core/src/verification/commands.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 var MAX_OUTPUT_CHARS = 8e3;
 var KILL_GRACE_MS = 250;
 function appendOutput(current, chunk) {
@@ -4045,7 +4684,7 @@ async function runVerificationCommand(configured, cwd, signal) {
   }
   const startedAt = Date.now();
   return await new Promise((resolveResult, rejectResult) => {
-    const child = spawn5(executable, arguments_, {
+    const child = spawn6(executable, arguments_, {
       cwd,
       detached: process.platform !== "win32",
       shell: false,
@@ -4579,7 +5218,7 @@ ${output2}` : ""}`
       status: "ok",
       bridge: "online",
       projectId: options.project.id,
-      activeTask: taskService.list().find((task) => !["accepted", "reverted", "failed", "canceled", "unsafe"].includes(task.status))?.id ?? null
+      activeTask: taskService.list().find((task) => isWorkingTaskStatus(task.status))?.id ?? null
     }),
     project: () => ({
       id: options.project.id,
@@ -4620,33 +5259,70 @@ ${output2}` : ""}`
 }
 
 // ../../packages/bridge-core/src/bridge/default-control-service.ts
+function createAgentAdapter(agent) {
+  if (agent.adapter === "claude") {
+    if (agent.reasoningEffort === "minimal") {
+      throw new Error("Claude does not support minimal reasoning effort");
+    }
+    return new ClaudeAdapter({
+      ...agent.model === void 0 ? {} : { model: agent.model },
+      ...agent.reasoningEffort === void 0 ? {} : { reasoningEffort: agent.reasoningEffort }
+    });
+  }
+  if (agent.adapter === "codex") {
+    if (agent.reasoningEffort === "max") {
+      throw new Error("Codex does not support max reasoning effort");
+    }
+    return new CodexAdapter({
+      ...agent.model === void 0 ? {} : { model: agent.model },
+      ...agent.reasoningEffort === void 0 ? {} : { reasoningEffort: agent.reasoningEffort },
+      ...agent.profile === void 0 ? {} : { profile: agent.profile }
+    });
+  }
+  throw new Error(`Agent adapter ${agent.adapter} is not implemented in this build`);
+}
+function inheritedAgentEnvironment(names, environment) {
+  return Object.fromEntries(
+    names.flatMap((name) => {
+      const value = environment[name];
+      return value === void 0 ? [] : [[name, value]];
+    })
+  );
+}
 async function createDefaultControlService(context, environment = process.env) {
   const loaded = await loadVisualDevConfig(context.repoRoot, {
     ...context.configRoot === void 0 ? {} : { configRoot: context.configRoot }
   });
-  if (loaded.config.agent.adapter !== "codex") {
-    throw new Error(
-      `Agent adapter ${loaded.config.agent.adapter} is not implemented in this MVP build`
-    );
-  }
   const git = await GitTransactionManager.open(context.repoRoot, {
-    allowed: loaded.config.paths.allowed,
-    denied: loaded.config.paths.denied
+    allowed: rebaseWorkspacePatterns(
+      context.repoRoot,
+      context.workspaceRoot,
+      loaded.config.paths.allowed
+    ),
+    denied: rebaseWorkspacePatterns(
+      context.repoRoot,
+      context.workspaceRoot,
+      loaded.config.paths.denied
+    )
   });
   const storagePaths = await resolveStoragePaths(context.repoRoot, environment);
   const store = new SqliteTaskStore(storagePaths.databasePath);
   const taskService = new TaskService({
     projectId: context.projectId,
     workspaceRoot: context.workspaceRoot,
-    adapter: new CodexAdapter(),
+    upstreamUrl: context.upstreamUrl,
+    adapter: createAgentAdapter(loaded.config.agent),
     store,
     git,
     maxRunMs: loaded.config.agent.maxRunMs,
     maxPending: loaded.config.queue.maxPending,
     resumeMode: loaded.config.agent.resumeMode,
-    environment: {}
+    environment: inheritedAgentEnvironment(
+      loaded.config.agent.inheritEnv,
+      environment
+    )
   });
-  return createTaskControlService({
+  const controlService = createTaskControlService({
     taskService,
     hmrWaitMs: loaded.config.verification.hmrWaitMs,
     verificationCommands: loaded.config.verification.commands,
@@ -4658,10 +5334,32 @@ async function createDefaultControlService(context, environment = process.env) {
       upstreamUrl: context.upstreamUrl
     }
   });
+  const reportRuntimeState = () => {
+    const activeTask = taskService.list().find((task) => isWorkingTaskStatus(task.status));
+    context.onRuntimeState?.({
+      status: activeTask === void 0 ? "idle" : "working",
+      ...activeTask === void 0 ? {} : { activeTaskId: activeTask.id }
+    });
+  };
+  const unsubscribeRuntime = taskService.subscribe(reportRuntimeState);
+  reportRuntimeState();
+  return {
+    ...controlService,
+    close: async () => {
+      unsubscribeRuntime();
+      await controlService.close?.();
+    }
+  };
 }
 
 // ../../packages/bridge-core/src/runtime/registry.ts
 import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
+import {
+  readFileSync,
+  realpathSync,
+  rmSync,
+  unlinkSync
+} from "node:fs";
 import {
   mkdir as mkdir2,
   link,
@@ -4702,6 +5400,11 @@ async function repositoryKey(repositoryRoot) {
   const canonicalRoot = await realpath8(repositoryRoot);
   return createHash3("sha256").update(canonicalRoot).digest("hex");
 }
+function runtimeDirectoryForSync(repositoryRoot, options) {
+  const canonicalRoot = realpathSync(repositoryRoot);
+  const repoKey = createHash3("sha256").update(canonicalRoot).digest("hex");
+  return join3(runtimeRoot(options), repoKey);
+}
 async function runtimeDirectoryFor(repositoryRoot, options = {}) {
   return join3(runtimeRoot(options), await repositoryKey(repositoryRoot));
 }
@@ -4740,6 +5443,13 @@ async function readJson(path) {
     return void 0;
   }
 }
+function readJsonSync(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
 async function readInstance(repositoryRoot, options = {}) {
   const directory = await runtimeDirectoryFor(repositoryRoot, options);
   const value = await readJson(join3(directory, "instance.json"));
@@ -4757,6 +5467,21 @@ async function writeInstance(repositoryRoot, instance, options = {}) {
   });
   await rename(temporaryPath, path);
 }
+async function updateInstance(repositoryRoot, expectedPid, update, options = {}) {
+  const current = await readInstance(repositoryRoot, options);
+  if (current === void 0 || current.pid !== expectedPid) return void 0;
+  const next = {
+    ...current,
+    ...update.status === void 0 ? {} : { status: update.status }
+  };
+  if (update.activeTaskId === null) {
+    delete next.activeTaskId;
+  } else if (update.activeTaskId !== void 0) {
+    next.activeTaskId = update.activeTaskId;
+  }
+  await writeInstance(repositoryRoot, next, options);
+  return next;
+}
 async function removeInstance(repositoryRoot, expectedPid, options = {}) {
   const directory = await runtimeDirectoryFor(repositoryRoot, options);
   const path = join3(directory, "instance.json");
@@ -4768,6 +5493,17 @@ async function removeInstance(repositoryRoot, expectedPid, options = {}) {
   }
   await rm3(path, { force: true });
 }
+function removeInstanceSync(repositoryRoot, expectedPid, options = {}) {
+  const directory = runtimeDirectoryForSync(repositoryRoot, options);
+  const path = join3(directory, "instance.json");
+  if (expectedPid !== void 0) {
+    const current = readJsonSync(path);
+    if (!isBridgeInstanceRecord(current) || current.pid !== expectedPid) {
+      return;
+    }
+  }
+  rmSync(path, { force: true });
+}
 async function acquireWorktreeLock(repositoryRoot, options = {}) {
   const repoRoot = await realpath8(repositoryRoot);
   const repoKey = await repositoryKey(repoRoot);
@@ -4799,23 +5535,43 @@ async function acquireWorktreeLock(repositoryRoot, options = {}) {
         await rm3(candidatePath, { force: true });
       }
       let released = false;
+      let releasePromise;
       return {
         repoKey,
         runtimeDirectory,
         lockPath,
-        async release() {
+        release() {
           if (released) {
+            return Promise.resolve();
+          }
+          releasePromise ??= (async () => {
+            const current = await readJson(lockPath);
+            if (isLockRecord(current) && current.ownerId === ownerId) {
+              await unlink(lockPath).catch((error) => {
+                if (error.code !== "ENOENT") {
+                  throw error;
+                }
+              });
+            }
+            released = true;
+          })();
+          return releasePromise;
+        },
+        releaseSync() {
+          if (released || releasePromise !== void 0) {
             return;
           }
-          released = true;
-          const current = await readJson(lockPath);
+          const current = readJsonSync(lockPath);
           if (isLockRecord(current) && current.ownerId === ownerId) {
-            await unlink(lockPath).catch((error) => {
-              if (error.code !== "ENOENT") {
+            try {
+              unlinkSync(lockPath);
+            } catch (error) {
+              if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "ENOENT") {
                 throw error;
               }
-            });
+            }
           }
+          released = true;
         }
       };
     } catch (error) {
@@ -4835,10 +5591,10 @@ async function acquireWorktreeLock(repositoryRoot, options = {}) {
 }
 
 // ../../packages/bridge-core/src/runtime/repository.ts
-import { execFile } from "node:child_process";
+import { execFile as execFile3 } from "node:child_process";
 import { realpath as realpath9 } from "node:fs/promises";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
+import { promisify as promisify3 } from "node:util";
+var execFileAsync3 = promisify3(execFile3);
 var GitWorktreeNotFoundError = class extends Error {
   constructor(cwd, options = {}) {
     super(
@@ -4850,7 +5606,7 @@ var GitWorktreeNotFoundError = class extends Error {
 };
 async function discoverGitWorktreeRoot(cwd = process.cwd()) {
   try {
-    const { stdout } = await execFileAsync(
+    const { stdout } = await execFileAsync3(
       "git",
       ["-C", cwd, "rev-parse", "--show-toplevel"],
       {
@@ -4869,6 +5625,91 @@ async function discoverGitWorktreeRoot(cwd = process.cwd()) {
 }
 
 // src/bridge.ts
+var DEFAULT_UPSTREAM_MONITOR_INTERVAL_MS = 1e3;
+var DEFAULT_UPSTREAM_CONNECT_TIMEOUT_MS = 500;
+var DEFAULT_UPSTREAM_FAILURE_GRACE_MS = 5e3;
+function positiveMilliseconds(value, fallback) {
+  return value === void 0 || !Number.isFinite(value) || value <= 0 ? fallback : Math.max(1, Math.floor(value));
+}
+async function probeUpstream(upstreamUrl, timeoutMs) {
+  const upstream = new URL(upstreamUrl);
+  const hostname = upstream.hostname.startsWith("[") ? upstream.hostname.slice(1, -1) : upstream.hostname;
+  const port = Number(
+    upstream.port || (upstream.protocol === "https:" ? 443 : 80)
+  );
+  return await new Promise((resolve9) => {
+    let settled = false;
+    let timeout;
+    const socket = createConnection({ host: hostname, port });
+    socket.unref();
+    const finish = (reachable) => {
+      if (settled) return;
+      settled = true;
+      if (timeout !== void 0) clearTimeout(timeout);
+      socket.destroy();
+      resolve9(reachable);
+    };
+    socket.once("connect", () => finish(true));
+    socket.once("error", () => finish(false));
+    timeout = setTimeout(() => finish(false), timeoutMs);
+    timeout.unref();
+  });
+}
+function monitorUpstream(bridge, options) {
+  const intervalMs = positiveMilliseconds(
+    options.intervalMs,
+    DEFAULT_UPSTREAM_MONITOR_INTERVAL_MS
+  );
+  const connectTimeoutMs = positiveMilliseconds(
+    options.connectTimeoutMs,
+    DEFAULT_UPSTREAM_CONNECT_TIMEOUT_MS
+  );
+  const initialTimeoutMs = positiveMilliseconds(
+    options.initialTimeoutMs,
+    6e4
+  );
+  const failureGraceMs = positiveMilliseconds(
+    options.failureGraceMs,
+    DEFAULT_UPSTREAM_FAILURE_GRACE_MS
+  );
+  let connected = false;
+  let unavailableSince;
+  let stopped = false;
+  let timer;
+  const stop = () => {
+    stopped = true;
+    if (timer !== void 0) clearTimeout(timer);
+  };
+  const schedule = () => {
+    if (stopped) return;
+    timer = setTimeout(() => {
+      void check().catch(() => void 0);
+    }, intervalMs);
+    timer.unref();
+  };
+  const check = async () => {
+    if (stopped) return;
+    const reachable = await probeUpstream(bridge.upstreamUrl, connectTimeoutMs);
+    if (stopped) return;
+    const now = Date.now();
+    if (reachable) {
+      connected = true;
+      unavailableSince = void 0;
+      schedule();
+      return;
+    }
+    unavailableSince ??= now;
+    const timeoutMs = connected ? failureGraceMs : initialTimeoutMs;
+    if (now - unavailableSince >= timeoutMs) {
+      stop();
+      await bridge.close();
+      return;
+    }
+    schedule();
+  };
+  void bridge.closed.then(stop);
+  void check().catch(() => void 0);
+}
 function normalizeUpstream(value) {
   const url = new URL(value);
   if (url.protocol !== "http:" && url.protocol !== "https:") {
@@ -4905,10 +5746,30 @@ async function startBridgeCore(options, dependencies) {
   let gateway;
   let controlService;
   let registryWritten = false;
+  let registryUpdate = Promise.resolve();
+  let latestRuntimeState = { status: "idle" };
+  const updateRuntimeState = (status, activeTaskId) => {
+    latestRuntimeState = {
+      status,
+      ...activeTaskId === void 0 ? {} : { activeTaskId }
+    };
+    if (!registryWritten) return;
+    registryUpdate = registryUpdate.then(async () => {
+      await updateInstance(
+        loadedConfig.repoRoot,
+        process.pid,
+        {
+          status,
+          activeTaskId: activeTaskId ?? null
+        },
+        { environment }
+      );
+    }).catch(() => void 0);
+  };
   try {
     lock = options.lock ?? await acquireWorktreeLock(loadedConfig.repoRoot, { environment });
     const host = options.host ?? loadedConfig.config.gateway.host;
-    const configuredPublicUrl = options.publicUrl ?? loadedConfig.config.gateway.publicUrl;
+    const configuredPublicUrl = options.publicUrl ?? loadedConfig.config.gateway.publicUrl ?? options.fallbackPublicUrl;
     const publicUrl = configuredPublicUrl === void 0 ? void 0 : normalizePublicUrl(configuredPublicUrl);
     const gatewayPort = await findAvailablePort(startPort(loadedConfig, options.listen), host);
     const token = generatePairingToken();
@@ -4918,7 +5779,10 @@ async function startBridgeCore(options, dependencies) {
       repoRoot: loadedConfig.repoRoot,
       configRoot: loadedConfig.configRoot,
       workspaceRoot: loadedConfig.workspaceRoot,
-      upstreamUrl: options.upstreamUrl
+      upstreamUrl: options.upstreamUrl,
+      onRuntimeState: (state) => {
+        updateRuntimeState(state.status, state.activeTaskId);
+      }
     };
     controlService = await resolveControlService(dependencies, controlContext);
     const allowedOrigins = new Set(loadedConfig.config.security.allowedOrigins);
@@ -4933,20 +5797,33 @@ async function startBridgeCore(options, dependencies) {
       allowedOrigins: [...allowedOrigins]
     });
     const address = await gateway.start();
-    const openUrl = publicUrl ?? address.url;
+    const openUrl = createPairingUrl(publicUrl ?? address.url, token);
     const instance = {
       projectId: loadedConfig.config.project.id,
       repoRoot: loadedConfig.repoRoot,
       pid: process.pid,
       gatewayUrl: address.url,
       upstreamUrl: options.upstreamUrl,
-      status: "idle",
+      status: latestRuntimeState.status,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...latestRuntimeState.activeTaskId === void 0 ? {} : { activeTaskId: latestRuntimeState.activeTaskId },
       ...publicUrl === void 0 ? {} : { publicUrl }
     };
     await writeInstance(loadedConfig.repoRoot, instance, { environment });
     registryWritten = true;
-    let closed = false;
+    const emergencyExitCleanup = () => {
+      try {
+        removeInstanceSync(loadedConfig.repoRoot, process.pid, { environment });
+        lock?.releaseSync();
+      } catch {
+      }
+    };
+    process.once("exit", emergencyExitCleanup);
+    let resolveClosed = () => void 0;
+    const closed = new Promise((resolve9) => {
+      resolveClosed = resolve9;
+    });
+    let closePromise;
     return {
       mode: options.mode,
       projectId: loadedConfig.config.project.id,
@@ -4958,18 +5835,33 @@ async function startBridgeCore(options, dependencies) {
       openUrl,
       gateway,
       ...options.managedProcess === void 0 ? {} : { managedProcess: options.managedProcess },
-      async close() {
-        if (closed) {
-          return;
-        }
-        closed = true;
-        await Promise.allSettled([
-          gateway?.close(),
-          options.managedProcess?.stop(),
-          controlService?.close?.()
-        ]);
-        await removeInstance(loadedConfig.repoRoot, process.pid, { environment });
-        await lock?.release();
+      closed,
+      close() {
+        closePromise ??= (async () => {
+          process.off("exit", emergencyExitCleanup);
+          try {
+            await registryUpdate;
+            await updateInstance(
+              loadedConfig.repoRoot,
+              process.pid,
+              { status: "stopping", activeTaskId: null },
+              { environment }
+            );
+            await Promise.allSettled([
+              gateway?.close(),
+              options.managedProcess?.stop(),
+              controlService?.close?.()
+            ]);
+            await removeInstance(loadedConfig.repoRoot, process.pid, { environment });
+          } finally {
+            try {
+              await lock?.release();
+            } finally {
+              resolveClosed();
+            }
+          }
+        })();
+        return closePromise;
       }
     };
   } catch (error) {
@@ -4990,17 +5882,25 @@ async function startAttachBridge(options, dependencies = {}) {
   const repoRoot = await discoverGitWorktreeRoot(cwd);
   const configRoot = await discoverVisualDevConfigRoot(cwd, repoRoot);
   const loadedConfig = await loadVisualDevConfig(repoRoot, { configRoot });
-  return await startBridgeCore(
+  const bridge = await startBridgeCore(
     {
       mode: "attach",
       loadedConfig,
       upstreamUrl: normalizeUpstream(options.upstream),
       ...options.listen === void 0 ? {} : { listen: options.listen },
       ...options.host === void 0 ? {} : { host: options.host },
-      ...options.publicUrl === void 0 ? {} : { publicUrl: options.publicUrl }
+      ...options.publicUrl === void 0 ? {} : { publicUrl: options.publicUrl },
+      ...options.fallbackPublicUrl === void 0 ? {} : { fallbackPublicUrl: options.fallbackPublicUrl }
     },
     dependencies
   );
+  if (dependencies.upstreamMonitor !== false) {
+    monitorUpstream(bridge, {
+      initialTimeoutMs: loadedConfig.config.upstream.ready.timeoutMs,
+      ...dependencies.upstreamMonitor
+    });
+  }
+  return bridge;
 }
 async function startManagedBridge(options = {}, dependencies = {}) {
   const cwd = dependencies.cwd ?? process.cwd();
@@ -5102,6 +6002,7 @@ async function runBridgeUntilSignal(bridge, processLike = process, gracefulTimeo
     };
     for (const signal of signals) processLike.once(signal, shutdown);
     void bridge.managedProcess?.exit.then(shutdown);
+    void bridge.closed?.then(shutdown);
   });
 }
 function formatBridgeSummary(bridge) {
@@ -5120,9 +6021,9 @@ function formatBridgeSummary(bridge) {
 import { constants } from "node:fs";
 import { access as access2, stat as stat3 } from "node:fs/promises";
 import { delimiter, isAbsolute as isAbsolute5, join as join4, relative as relative6, resolve as resolve7 } from "node:path";
-import { execFile as execFile2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
-var execFileAsync2 = promisify2(execFile2);
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
+var execFileAsync4 = promisify4(execFile4);
 async function fileExists(path) {
   try {
     await stat3(path);
@@ -5136,7 +6037,7 @@ async function fileExists(path) {
 }
 async function isIgnored(repoRoot, path) {
   try {
-    await execFileAsync2("git", ["-C", repoRoot, "check-ignore", "--quiet", "--", path], {
+    await execFileAsync4("git", ["-C", repoRoot, "check-ignore", "--quiet", "--", path], {
       windowsHide: true
     });
     return true;
@@ -5178,6 +6079,7 @@ async function runDoctor(dependencies = {}) {
       repoRoot
     );
     const loaded = await loadVisualDevConfig(repoRoot, { configRoot });
+    const environment = dependencies.environment ?? process.env;
     checks.push({
       name: "config",
       status: loaded.loadedFiles.length === 0 ? "warning" : "pass",
@@ -5198,7 +6100,7 @@ async function runDoctor(dependencies = {}) {
       const available = executable !== void 0 && await executableAvailable(
         executable,
         loaded.workspaceRoot,
-        dependencies.environment ?? process.env
+        environment
       );
       checks.push({
         name: "dev-command",
@@ -5206,6 +6108,93 @@ async function runDoctor(dependencies = {}) {
         message: available ? `${executable} is executable.` : `${executable ?? "<empty>"} was not found or is not executable.`
       });
     }
+    const adapter = loaded.config.agent.adapter;
+    const adapterSupported = adapter === "codex" || adapter === "claude";
+    const agentAvailable = await executableAvailable(
+      adapter,
+      loaded.workspaceRoot,
+      environment
+    );
+    checks.push({
+      name: "agent",
+      status: adapterSupported && agentAvailable ? "pass" : "fail",
+      message: !adapterSupported ? `${adapter} is configured but is not implemented in this build.` : agentAvailable ? `${adapter} is executable.` : `${adapter} was not found or is not executable.`
+    });
+    if (loaded.config.agent.inheritEnv.length > 0) {
+      const missing = loaded.config.agent.inheritEnv.filter(
+        (name) => environment[name] === void 0
+      );
+      checks.push({
+        name: "agent-environment",
+        status: missing.length === 0 ? "pass" : "fail",
+        message: missing.length === 0 ? `${loaded.config.agent.inheritEnv.length} agent environment variable(s) are available.` : `Missing agent environment variable(s): ${missing.join(", ")}.`
+      });
+    }
+    if (adapter === "claude") {
+      const sandboxDependencies = await Promise.all(
+        ["bwrap", "socat"].map(async (executable) => ({
+          executable,
+          available: await executableAvailable(
+            executable,
+            loaded.workspaceRoot,
+            environment
+          )
+        }))
+      );
+      const missing = sandboxDependencies.filter(({ available }) => !available).map(({ executable }) => executable);
+      checks.push({
+        name: "claude-sandbox",
+        status: missing.length === 0 ? "pass" : "warning",
+        message: missing.length === 0 ? "Claude Bash sandbox dependencies are available." : `Claude Bash sandbox is unavailable without: ${missing.join(", ")}.`
+      });
+    }
+    const rtkAvailable = await executableAvailable(
+      "rtk",
+      loaded.workspaceRoot,
+      environment
+    );
+    checks.push({
+      name: "rtk",
+      status: rtkAvailable ? "pass" : "warning",
+      message: rtkAvailable ? "rtk is available for token-efficient command output." : "rtk was not found; agent commands will use their native output."
+    });
+    const verificationCommands = loaded.config.verification.commands;
+    if (verificationCommands.length === 0) {
+      checks.push({
+        name: "verification",
+        status: "warning",
+        message: "No verification commands are configured."
+      });
+    } else {
+      const availability = await Promise.all(
+        verificationCommands.map(async ({ command: command2, name }) => ({
+          name,
+          available: await executableAvailable(
+            command2[0] ?? "",
+            loaded.workspaceRoot,
+            environment
+          )
+        }))
+      );
+      const missing = availability.filter(({ available }) => !available).map(({ name }) => name);
+      checks.push({
+        name: "verification",
+        status: missing.length === 0 ? "pass" : "fail",
+        message: missing.length === 0 ? `${verificationCommands.length} verification command(s) are ready.` : `Missing executable for: ${missing.join(", ")}.`
+      });
+    }
+    const publicUrl = loaded.config.gateway.publicUrl;
+    checks.push({
+      name: "public-url",
+      status: publicUrl === void 0 ? "warning" : "pass",
+      message: publicUrl === void 0 ? "No gateway.publicUrl is configured; pairing links will use the local gateway URL." : `Pairing links will use ${publicUrl}.`
+    });
+    const allowedOrigins = loaded.config.security.allowedOrigins;
+    checks.push({
+      name: "allowed-origins",
+      status: allowedOrigins.length > 0 || publicUrl !== void 0 ? "pass" : "warning",
+      message: allowedOrigins.length > 0 ? `${allowedOrigins.length} browser origin(s) are explicitly allowed.` : publicUrl !== void 0 ? "The configured public URL origin will be allowed automatically." : "No browser origins are configured; add security.allowedOrigins before remote access."
+    });
   } catch (error) {
     checks.push({
       name: "config",
@@ -5223,7 +6212,7 @@ function formatDoctorChecks(checks) {
 }
 
 // src/init.ts
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import { readFile as readFile5, mkdir as mkdir3, realpath as realpath10, stat as stat4, writeFile as writeFile3 } from "node:fs/promises";
 import { basename as basename2, dirname as dirname4, join as join5, relative as relative7 } from "node:path";
 import { stringify as stringifyYaml } from "yaml";
@@ -5543,7 +6532,7 @@ function installCommand(request) {
 async function installPackage(request) {
   const { command, args } = installCommand(request);
   await new Promise((resolvePromise, reject) => {
-    const child = spawn6(command, args, {
+    const child = spawn7(command, args, {
       cwd: request.cwd,
       env: process.env,
       stdio: "inherit",
@@ -5666,15 +6655,124 @@ function formatBridgeStatus(status) {
     return "No Visual Bridge is running for this worktree.";
   }
   const { instance } = status;
-  return [
+  const rows = [
     `Project:  ${instance.projectId}`,
     `Status:   ${instance.status}`,
     `PID:      ${instance.pid}`,
     `Gateway:  ${instance.gatewayUrl}`,
     `Upstream: ${instance.upstreamUrl}`
-  ].join("\n");
+  ];
+  if (instance.publicUrl !== void 0) rows.push(`Public:   ${instance.publicUrl}`);
+  if (instance.activeTaskId !== void 0) {
+    rows.push(`Active:   ${instance.activeTaskId}`);
+  }
+  return rows.join("\n");
 }
 
+// ../../package.json
+var package_default = {
+  name: "visual-remote",
+  version: "0.3.2",
+  description: "Visual bridge from a running web UI to a coding agent in its Git worktree",
+  type: "module",
+  packageManager: "pnpm@10.34.5",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/elicie/visual-remote.git"
+  },
+  homepage: "https://github.com/elicie/visual-remote#readme",
+  bugs: {
+    url: "https://github.com/elicie/visual-remote/issues"
+  },
+  files: [
+    "apps/cli/dist/index.js",
+    "apps/cli/dist/direct-exec-mcp.js",
+    "apps/cli/dist/vite.js",
+    "apps/cli/dist/next.js",
+    "apps/cli/dist/next-client.js",
+    "apps/cli/vite.d.ts",
+    "apps/cli/next.d.ts",
+    "apps/cli/next-client.d.ts",
+    "packages/overlay/dist/client.js",
+    "packages/overlay/dist/viewer.js"
+  ],
+  bin: {
+    visual: "./apps/cli/dist/index.js",
+    "visual-remote": "./apps/cli/dist/index.js"
+  },
+  exports: {
+    "./vite": {
+      types: "./apps/cli/vite.d.ts",
+      import: "./apps/cli/dist/vite.js"
+    },
+    "./next": {
+      types: "./apps/cli/next.d.ts",
+      import: "./apps/cli/dist/next.js",
+      default: "./apps/cli/dist/next.js"
+    },
+    "./next/client": {
+      types: "./apps/cli/next-client.d.ts",
+      import: "./apps/cli/dist/next-client.js",
+      default: "./apps/cli/dist/next-client.js"
+    }
+  },
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org"
+  },
+  engines: {
+    node: ">=24"
+  },
+  scripts: {
+    build: "corepack pnpm run build:overlay && corepack pnpm run build:server",
+    "build:overlay": "corepack pnpm --filter @visual-remote/overlay build",
+    "build:server": "corepack pnpm --filter @visual-remote/cli build",
+    dev: "corepack pnpm run build:overlay && tsx apps/cli/src/index.ts",
+    test: "vitest run",
+    "test:e2e": "corepack pnpm build && corepack pnpm exec playwright test --config tests/e2e/playwright.config.ts",
+    "test:watch": "vitest",
+    typecheck: "corepack pnpm -r --if-present typecheck && tsc --noEmit -p tsconfig.tests.json",
+    prepack: "corepack pnpm build"
+  },
+  dependencies: {
+    commander: "^15.0.0",
+    "http-proxy": "^1.18.1",
+    ws: "^8.21.1",
+    yaml: "^2.9.0",
+    zod: "^4.4.3"
+  },
+  peerDependencies: {
+    vite: ">=5"
+  },
+  peerDependenciesMeta: {
+    vite: {
+      optional: true
+    }
+  },
+  devDependencies: {
+    "@playwright/test": "^1.62.1",
+    "@types/http-proxy": "^1.17.17",
+    "@types/node": "^26.1.2",
+    "@types/ws": "^8.18.1",
+    "@visual-remote/bridge-core": "workspace:*",
+    "@visual-remote/cli": "workspace:*",
+    "@visual-remote/gateway": "workspace:*",
+    "@visual-remote/overlay": "workspace:*",
+    "@visual-remote/protocol": "workspace:*",
+    esbuild: "^0.28.1",
+    next: "15.5.16",
+    react: "19.1.0",
+    "react-dom": "19.1.0",
+    tsx: "^4.23.1",
+    typescript: "^7.0.2",
+    vite: "^8.1.5",
+    vitest: "^4.1.10"
+  }
+};
+
+// src/version.ts
+var VISUAL_REMOTE_VERSION = package_default.version;
+
 // src/index.ts
 function parsePort(value) {
   const port = Number(value);
@@ -5697,7 +6795,7 @@ function setExitCode(dependencies, code) {
   }
 }
 function createCli(dependencies = {}) {
-  const program = new Command().name("visual").description("Visual Remote Dev Bridge").version("0.3.0");
+  const program = new Command().name("visual").description("Visual Remote Dev Bridge").version(VISUAL_REMOTE_VERSION);
   program.command("init").description("Configure Visual Remote for the current Vite or Next.js project").action(async () => {
     const result = await initializeVisualDev(dependencies);
     output(dependencies, formatInitResult(result));
@@ -5749,7 +6847,7 @@ async function main(argv = process.argv, dependencies = {}) {
 }
 function isDirectEntry(entryPath2) {
   try {
-    return pathToFileURL(realpathSync(resolve8(entryPath2))).href === import.meta.url;
+    return pathToFileURL(realpathSync2(resolve8(entryPath2))).href === import.meta.url;
   } catch {
     return false;
   }
@@ -5765,6 +6863,7 @@ if (entryPath !== void 0 && isDirectEntry(entryPath)) {
   });
 }
 export {
+  VISUAL_REMOTE_VERSION,
   createCli,
   formatBridgeStatus,
   formatBridgeSummary,