opensteer 0.8.13 → 0.8.15

package/dist/cli/bin.js

@@ -1,290 +1,1644 @@
 #!/usr/bin/env node
-import { assertProviderSupportsEngine, createOpensteerSemanticRuntime, OpensteerBrowserManager, dispatchSemanticOperation, loadEnvironment, normalizeOpensteerProviderMode, discoverLocalCdpBrowsers, inspectCdpEndpoint, resolveOpensteerRuntimeConfig, resolveOpensteerEngineName, resolveOpensteerProvider, resolveFilesystemWorkspacePath, requireCloudAppBaseUrl, CloudSessionProxy, FlowRecorderCollector, generateReplayScript, pathExists, readPersistedLocalBrowserSessionRecord, readPersistedCloudSessionRecord, OpensteerCloudClient, isProcessRunning } from '../chunk-BW2BH7HA.js';
-import process3 from 'process';
+import { assertProviderSupportsEngine, createOpensteerSemanticRuntime, dispatchSemanticOperation, loadEnvironment, normalizeOpensteerProviderMode, discoverLocalCdpBrowsers, inspectCdpEndpoint, OpensteerBrowserManager, resolveOpensteerRuntimeConfig, resolveOpensteerEngineName, resolveOpensteerProvider, resolveFilesystemWorkspacePath, requireCloudAppBaseUrl, CloudSessionProxy, FlowRecorderCollector, generateReplayScript, pathExists, readPersistedLocalBrowserSessionRecord, readPersistedCloudSessionRecord, OpensteerCloudClient, isProcessRunning } from '../chunk-DFQCK2U6.js';
+import process4 from 'process';
+import { mkdir, writeFile } from 'fs/promises';
+import path2 from 'path';
 import { spawn } from 'child_process';
+import os from 'os';
 import { existsSync } from 'fs';
-import path from 'path';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
-import { mkdir, writeFile } from 'fs/promises';
-import os from 'os';
 
 // package.json
 var package_default = {
-  version: "0.8.13"};
+  version: "0.8.14"};
 
 // src/cli/env-loader.ts
 async function loadCliEnvironment(cwd) {
   loadEnvironment(cwd);
 }
-var OPENSTEER_GITHUB_SOURCE = "steerlabs/opensteer";
-function createOpensteerSkillsInvocation(input) {
-  const cliArgs = ["add", input.skillSourcePath];
-  if (input.options.all === true) {
-    cliArgs.push("--all");
-  } else {
-    const selectedSkills = resolveSelectedSkills(input.options);
-    for (const skill of selectedSkills) {
-      cliArgs.push("--skill", skill);
-    }
-  }
-  for (const agent of input.options.agents ?? []) {
-    cliArgs.push("--agent", agent);
-  }
-  if (input.options.global === true) {
-    cliArgs.push("--global");
-  }
-  if (input.options.yes === true) {
-    cliArgs.push("--yes");
-  }
-  if (input.options.copy === true) {
-    cliArgs.push("--copy");
-  }
-  if (input.options.list === true) {
-    cliArgs.push("--list");
-  }
-  return {
-    cliPath: input.skillsCliPath,
-    cliArgs
-  };
-}
-function resolveOpensteerSkillsCliPath() {
-  const require2 = createRequire(import.meta.url);
-  const skillsPackagePath = require2.resolve("skills/package.json");
-  const skillsPackageDir = path.dirname(skillsPackagePath);
-  const cliPath = path.join(skillsPackageDir, "bin", "cli.mjs");
-  if (!existsSync(cliPath)) {
-    throw new Error(`skills CLI entrypoint was not found at "${cliPath}".`);
-  }
-  return cliPath;
+
+// src/cli/help.ts
+function getHelpText() {
+  return `Opensteer CLI
+
+Session:
+  open <url> [--workspace <id>] [--headless] [--provider local|cloud]
+  close
+  status
+
+Navigation:
+  goto <url> [--capture-network <label>]
+
+DOM:
+  snapshot [action|extraction]
+  click <element> [--button left|middle|right] [--persist <key>] [--capture-network <label>]
+  hover <element> [--persist <key>] [--capture-network <label>]
+  input <element> <text> [--press-enter] [--persist <key>] [--capture-network <label>]
+  scroll <direction> <amount> [--element <n>] [--persist <key>] [--capture-network <label>]
+  extract <schema> [--persist <key>]
+  evaluate <script>
+  init-script <script>
+
+Tabs:
+  tab list
+  tab new [url]
+  tab <n>
+  tab close [n]
+
+Network:
+  network query [--capture <label>] [--url <pattern>] [--hostname <host>] [--path <path>] [--method <m>] [--status <code>] [--type <resourceType>] [--json] [--before <id>] [--after <id>] [--limit <n>]
+    --json filters to JSON and GraphQL responses only
+  network detail <recordId>
+  replay <recordId> [--query key=value ...] [--header key=value ...] [--body <json>] [--variables <json>]
+  fetch <url> [--method <m>] [--header key=value ...] [--query key=value ...] [--body <json>] [--body-text <text>] [--transport auto|direct|matched-tls|page] [--cookies] [--follow-redirects]
+
+Browser State:
+  cookies [domain]
+  storage [domain]
+  state [domain]
+
+Computer:
+  computer click <x> <y> [--button left|right|middle] [--count <n>] [--modifiers Shift,Control,Alt,Meta] [--capture-network <label>]
+  computer type <text> [--capture-network <label>]
+  computer key <key> [--modifiers Shift,Control,Alt,Meta] [--capture-network <label>]
+  computer scroll <x> <y> --dx <n> --dy <n> [--capture-network <label>]
+  computer move <x> <y> [--capture-network <label>]
+  computer drag <x1> <y1> <x2> <y2> [--steps <n>] [--capture-network <label>]
+  computer screenshot [--format png|jpeg|webp]
+  computer wait <ms>
+
+Advanced:
+  captcha solve --provider 2captcha|capsolver --api-key <key> [--type recaptcha-v2|hcaptcha|turnstile] [--site-key <key>] [--page-url <url>] [--timeout <ms>]
+  scripts capture [--url-filter <pattern>] [--persist] [--inline] [--external] [--dynamic] [--workers]
+  scripts beautify <artifactId> [--persist]
+  scripts deobfuscate <artifactId> [--persist]
+  scripts sandbox <artifactId> [--fidelity minimal|standard|full] [--timeout <ms>] [--clock real|manual] [--cookies <json>] [--globals <json>] [--ajax-routes <json>]
+  interaction capture [--key <name>] [--duration <ms>] [--script <js>] [--include-storage] [--include-session-storage] [--include-indexed-db] [--global-names <list>] [--case-id <id>] [--notes <text>] [--tags <list>]
+  interaction get <traceId>
+  interaction replay <traceId>
+  interaction diff <leftTraceId> <rightTraceId>
+  artifact read <artifactId>
+
+Options:
+  --workspace <id>        Required for stateful commands (or set OPENSTEER_WORKSPACE)
+  --capture-network <l>   Record network traffic during an action
+  --help, --version
+`;
 }
-function resolveOpensteerLocalSkillSourcePath() {
-  let ancestor = path.dirname(fileURLToPath(import.meta.url));
-  for (let index = 0; index < 6; index += 1) {
-    const candidate = path.join(ancestor, "skills");
-    const skillManifest = path.join(candidate, "opensteer", "SKILL.md");
-    if (existsSync(skillManifest)) {
-      return candidate;
+
+// src/cli/commands.ts
+var OPERATION_ALIASES = /* @__PURE__ */ new Map([
+  ["open", "session.open"],
+  ["close", "session.close"],
+  ["goto", "page.goto"],
+  ["snapshot", "page.snapshot"],
+  ["evaluate", "page.evaluate"],
+  ["init-script", "page.add-init-script"],
+  ["click", "dom.click"],
+  ["hover", "dom.hover"],
+  ["input", "dom.input"],
+  ["scroll", "dom.scroll"],
+  ["extract", "dom.extract"],
+  ["tab", "page.activate"],
+  ["tab list", "page.list"],
+  ["tab new", "page.new"],
+  ["tab close", "page.close"],
+  ["network query", "network.query"],
+  ["network detail", "network.detail"],
+  ["replay", "network.replay"],
+  ["fetch", "session.fetch"],
+  ["cookies", "session.cookies"],
+  ["storage", "session.storage"],
+  ["state", "session.state"],
+  ["computer click", "computer.execute"],
+  ["computer type", "computer.execute"],
+  ["computer key", "computer.execute"],
+  ["computer scroll", "computer.execute"],
+  ["computer move", "computer.execute"],
+  ["computer drag", "computer.execute"],
+  ["computer screenshot", "computer.execute"],
+  ["computer wait", "computer.execute"],
+  ["captcha solve", "captcha.solve"],
+  ["scripts capture", "scripts.capture"],
+  ["scripts beautify", "scripts.beautify"],
+  ["scripts deobfuscate", "scripts.deobfuscate"],
+  ["scripts sandbox", "scripts.sandbox"],
+  ["interaction capture", "interaction.capture"],
+  ["interaction get", "interaction.get"],
+  ["interaction diff", "interaction.diff"],
+  ["interaction replay", "interaction.replay"],
+  ["artifact read", "artifact.read"]
+]);
+function resolveOperation(command) {
+  for (let length = Math.min(3, command.length); length >= 1; length -= 1) {
+    const key = command.slice(0, length).join(" ");
+    const operation = OPERATION_ALIASES.get(key);
+    if (operation) {
+      return operation;
     }
-    ancestor = path.resolve(ancestor, "..");
   }
-  throw new Error("Unable to find the packaged Opensteer skill source directory.");
+  return void 0;
 }
-async function checkOpensteerGitHubReachable() {
-  try {
-    const response = await fetch(`https://github.com/${OPENSTEER_GITHUB_SOURCE}`, {
-      method: "HEAD",
-      signal: AbortSignal.timeout(3e3),
-      redirect: "manual"
-    });
-    return response.status < 500;
-  } catch {
-    return false;
+function resolveCommandLength(tokens) {
+  if (tokens.length === 0) {
+    return 0;
   }
-}
-async function runOpensteerSkillsInstaller(options = {}, overrideDeps = {}) {
-  const deps = {
-    resolveSkillsCliPath: resolveOpensteerSkillsCliPath,
-    resolveLocalSkillSourcePath: resolveOpensteerLocalSkillSourcePath,
-    checkGitHubReachable: checkOpensteerGitHubReachable,
-    spawnInvocation: spawnOpensteerSkillsInvocation,
-    ...overrideDeps
-  };
-  const useGitHub = await deps.checkGitHubReachable();
-  const skillSourcePath = useGitHub ? OPENSTEER_GITHUB_SOURCE : deps.resolveLocalSkillSourcePath();
-  const invocation = createOpensteerSkillsInvocation({
-    options,
-    skillsCliPath: deps.resolveSkillsCliPath(),
-    skillSourcePath
-  });
-  return deps.spawnInvocation(invocation);
-}
-async function spawnOpensteerSkillsInvocation(invocation) {
-  return await new Promise((resolvePromise, rejectPromise) => {
-    const child = spawn(process.execPath, [invocation.cliPath, ...invocation.cliArgs], {
-      cwd: process.cwd(),
-      env: process.env,
-      stdio: "inherit"
-    });
-    child.once("error", (error) => {
-      rejectPromise(error);
-    });
-    child.once("exit", (code) => {
-      resolvePromise(typeof code === "number" ? code : 1);
-    });
-  });
-}
-function resolveSelectedSkills(options) {
-  if (options.skills !== void 0 && options.skills.length > 0) {
-    return options.skills;
+  if (tokens[0] === "browser") {
+    return Math.min(tokens.length, 2);
   }
-  if (options.list === true) {
-    return [];
+  if (tokens[0] === "skills") {
+    return Math.min(tokens.length, 2);
   }
-  return ["opensteer"];
-}
-async function collectOpensteerStatus(input) {
-  const output = {
-    provider: {
-      current: input.provider.mode,
-      source: mapProviderSource(input.provider.source),
-      ...input.cloudConfig === void 0 ? {} : { cloudBaseUrl: input.cloudConfig.baseUrl }
-    },
-    ...input.workspace === void 0 ? {} : { workspace: input.workspace }
-  };
-  if (input.workspace === void 0) {
-    return output;
+  if (tokens[0] === "status" || tokens[0] === "record") {
+    return 1;
   }
-  const rootPath = resolveFilesystemWorkspacePath({
-    rootDir: input.rootDir,
-    workspace: input.workspace
-  });
-  const localRecord = await readWorkspaceLocalRecord(rootPath);
-  const cloudRecord = await readWorkspaceCloudRecord(rootPath);
-  return {
-    ...output,
-    rootPath,
-    lanes: {
-      local: describeLocalLane(localRecord, input.provider.mode === "local"),
-      cloud: await describeCloudLane({
-        record: cloudRecord,
-        current: input.provider.mode === "cloud",
-        cloudConfig: input.cloudConfig
-      })
+  for (let length = Math.min(3, tokens.length); length >= 1; length -= 1) {
+    if (OPERATION_ALIASES.has(tokens.slice(0, length).join(" "))) {
+      return length;
     }
-  };
-}
-function renderOpensteerStatus(status) {
-  const lines = [
-    "Provider resolution",
-    `  current: ${status.provider.current}`,
-    `  source: ${status.provider.source}`
-  ];
-  if (status.provider.cloudBaseUrl !== void 0) {
-    lines.push(`  control api: ${status.provider.cloudBaseUrl}`);
-  }
-  if (status.workspace !== void 0) {
-    lines.push(`  workspace: ${status.workspace}`);
-  }
-  if (status.lanes === void 0) {
-    return `${lines.join("\n")}
-`;
-  }
-  lines.push("", "Live sessions");
-  for (const lane of [status.lanes.local, status.lanes.cloud]) {
-    lines.push(
-      formatLaneRow({
-        marker: lane.current ? "*" : " ",
-        provider: lane.provider,
-        status: lane.status,
-        summary: lane.summary ?? "none",
-        detail: lane.detail
-      })
-    );
-  }
-  return `${lines.join("\n")}
-`;
-}
-async function readWorkspaceLocalRecord(rootPath) {
-  if (!await pathExists(rootPath)) {
-    return void 0;
   }
-  return readPersistedLocalBrowserSessionRecord(rootPath);
+  return Math.min(tokens.length, 1);
 }
-async function readWorkspaceCloudRecord(rootPath) {
-  if (!await pathExists(rootPath)) {
-    return void 0;
+
+// src/cli/parse.ts
+var CLI_OPTION_SPECS = {
+  workspace: { kind: "value" },
+  url: { kind: "value" },
+  output: { kind: "value" },
+  engine: { kind: "value" },
+  provider: { kind: "value" },
+  "cloud-base-url": { kind: "value" },
+  "cloud-api-key": { kind: "value" },
+  "cloud-app-base-url": { kind: "value" },
+  "cloud-profile-id": { kind: "value" },
+  "cloud-profile-reuse-if-active": { kind: "boolean" },
+  json: { kind: "boolean" },
+  agent: { kind: "value", multiple: true },
+  skill: { kind: "value", multiple: true },
+  global: { kind: "boolean" },
+  yes: { kind: "boolean" },
+  copy: { kind: "boolean" },
+  all: { kind: "boolean" },
+  list: { kind: "boolean" },
+  "attach-endpoint": { kind: "value" },
+  "attach-header": { kind: "value", multiple: true },
+  "fresh-tab": { kind: "boolean" },
+  headless: { kind: "boolean" },
+  "executable-path": { kind: "value" },
+  arg: { kind: "value", multiple: true },
+  "timeout-ms": { kind: "value" },
+  context: { kind: "value" },
+  "source-user-data-dir": { kind: "value" },
+  "source-profile-directory": { kind: "value" },
+  element: { kind: "value" },
+  persist: { kind: "optional-value" },
+  button: { kind: "value" },
+  count: { kind: "value" },
+  modifiers: { kind: "value" },
+  "press-enter": { kind: "boolean" },
+  "capture-network": { kind: "value" },
+  capture: { kind: "value" },
+  hostname: { kind: "value" },
+  path: { kind: "value" },
+  method: { kind: "value" },
+  status: { kind: "value" },
+  type: { kind: "value" },
+  before: { kind: "value" },
+  after: { kind: "value" },
+  limit: { kind: "value" },
+  query: { kind: "value", multiple: true },
+  header: { kind: "value", multiple: true },
+  body: { kind: "value" },
+  "body-text": { kind: "value" },
+  variables: { kind: "value" },
+  dx: { kind: "value" },
+  dy: { kind: "value" },
+  steps: { kind: "value" },
+  format: { kind: "value" },
+  transport: { kind: "value" },
+  cookies: { kind: "optional-value" },
+  "follow-redirects": { kind: "boolean" },
+  "api-key": { kind: "value" },
+  "site-key": { kind: "value" },
+  "page-url": { kind: "value" },
+  timeout: { kind: "value" },
+  "url-filter": { kind: "value" },
+  inline: { kind: "boolean" },
+  external: { kind: "boolean" },
+  dynamic: { kind: "boolean" },
+  workers: { kind: "boolean" },
+  fidelity: { kind: "value" },
+  clock: { kind: "value" },
+  globals: { kind: "value" },
+  "ajax-routes": { kind: "value" },
+  key: { kind: "value" },
+  duration: { kind: "value" },
+  script: { kind: "value" },
+  "include-storage": { kind: "boolean" },
+  "include-session-storage": { kind: "boolean" },
+  "include-indexed-db": { kind: "boolean" },
+  "global-names": { kind: "value" },
+  "case-id": { kind: "value" },
+  notes: { kind: "value" },
+  tags: { kind: "value" }
+};
+function parseCommandLine(argv) {
+  const leadingTokens = [];
+  let index = 0;
+  while (index < argv.length && !argv[index].startsWith("--")) {
+    leadingTokens.push(argv[index]);
+    index += 1;
   }
-  return readPersistedCloudSessionRecord(rootPath);
-}
-function describeLocalLane(record, current) {
-  if (record === void 0 || !isProcessRunning(record.pid)) {
-    return {
-      provider: "local",
-      status: "idle",
-      current,
-      summary: "none"
-    };
+  const commandLength = resolveCommandLength(leadingTokens);
+  const command = leadingTokens.slice(0, commandLength);
+  const rest = leadingTokens.slice(commandLength);
+  const rawOptions = /* @__PURE__ */ new Map();
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === "--") {
+      rest.push(...argv.slice(index + 1));
+      break;
+    }
+    if (!token.startsWith("--")) {
+      rest.push(token);
+      index += 1;
+      continue;
+    }
+    const separator = token.indexOf("=");
+    const key = token.slice(2, separator === -1 ? void 0 : separator);
+    const spec = CLI_OPTION_SPECS[key];
+    if (spec === void 0) {
+      throw new Error(`Unknown option: --${key}.`);
+    }
+    if (separator !== -1) {
+      rawOptions.set(key, [...rawOptions.get(key) ?? [], token.slice(separator + 1)]);
+      index += 1;
+      continue;
+    }
+    const next = argv[index + 1];
+    if (spec.kind === "boolean") {
+      if (next === void 0 || next.startsWith("--")) {
+        rawOptions.set(key, [...rawOptions.get(key) ?? [], "true"]);
+        index += 1;
+        continue;
+      }
+      rawOptions.set(key, [...rawOptions.get(key) ?? [], next]);
+      index += 2;
+      continue;
+    }
+    if (spec.kind === "optional-value") {
+      if (next === void 0 || next.startsWith("--")) {
+        rawOptions.set(key, [...rawOptions.get(key) ?? [], "true"]);
+        index += 1;
+        continue;
+      }
+      rawOptions.set(key, [...rawOptions.get(key) ?? [], next]);
+      index += 2;
+      continue;
+    }
+    if (next === void 0 || next.startsWith("--")) {
+      throw new Error(
+        `Option "--${key}" requires a value.${next?.startsWith("--") === true ? ` Use "--${key}=<value>" when the value begins with "--".` : ``}`
+      );
+    }
+    rawOptions.set(key, [...rawOptions.get(key) ?? [], next]);
+    index += 2;
+  }
+  const workspace = readSingle(rawOptions, "workspace") ?? process4.env.OPENSTEER_WORKSPACE;
+  const requestedEngineName = readSingle(rawOptions, "engine");
+  const attachEndpoint = readSingle(rawOptions, "attach-endpoint");
+  const attachHeaders = parseKeyValueList(rawOptions.get("attach-header"));
+  const freshTab = readOptionalBoolean(rawOptions, "fresh-tab");
+  const headless = readOptionalBoolean(rawOptions, "headless");
+  const executablePath = readSingle(rawOptions, "executable-path");
+  const launchArgs = rawOptions.get("arg");
+  const timeoutMs = readOptionalNumber(rawOptions, "timeout-ms");
+  const browser = attachEndpoint === void 0 ? void 0 : {
+    mode: "attach",
+    endpoint: attachEndpoint,
+    ...attachHeaders === void 0 ? {} : { headers: attachHeaders },
+    ...freshTab === void 0 ? {} : { freshTab }
+  };
+  const launch = {
+    ...headless === void 0 ? {} : { headless },
+    ...executablePath === void 0 ? {} : { executablePath },
+    ...launchArgs === void 0 ? {} : { args: launchArgs },
+    ...timeoutMs === void 0 ? {} : { timeoutMs }
+  };
+  const providerValue = shouldParseRuntimeProvider(command) ? readSingle(rawOptions, "provider") : void 0;
+  const provider = providerValue === void 0 ? void 0 : normalizeOpensteerProviderMode(providerValue, "--provider");
+  const url = readSingle(rawOptions, "url");
+  const output = readSingle(rawOptions, "output");
+  const cloudBaseUrl = readSingle(rawOptions, "cloud-base-url");
+  const cloudApiKey = readSingle(rawOptions, "cloud-api-key");
+  const cloudAppBaseUrl = readSingle(rawOptions, "cloud-app-base-url");
+  const cloudProfileId = readSingle(rawOptions, "cloud-profile-id");
+  const cloudProfileReuseIfActive = readOptionalBoolean(rawOptions, "cloud-profile-reuse-if-active");
+  const json = readOptionalBoolean(rawOptions, "json");
+  const agents = rawOptions.get("agent");
+  const skills = rawOptions.get("skill");
+  const global = readOptionalBoolean(rawOptions, "global");
+  const yes = readOptionalBoolean(rawOptions, "yes");
+  const copy = readOptionalBoolean(rawOptions, "copy");
+  const all = readOptionalBoolean(rawOptions, "all");
+  const list = readOptionalBoolean(rawOptions, "list");
+  const context = readJsonObject(rawOptions, "context");
+  const sourceUserDataDir = readSingle(rawOptions, "source-user-data-dir");
+  const sourceProfileDirectory = readSingle(rawOptions, "source-profile-directory");
+  const options = {
+    ...workspace === void 0 ? {} : { workspace },
+    ...url === void 0 ? {} : { url },
+    ...output === void 0 ? {} : { output },
+    ...requestedEngineName === void 0 ? {} : { requestedEngineName },
+    ...provider === void 0 ? {} : { provider },
+    ...cloudBaseUrl === void 0 ? {} : { cloudBaseUrl },
+    ...cloudApiKey === void 0 ? {} : { cloudApiKey },
+    ...cloudAppBaseUrl === void 0 ? {} : { cloudAppBaseUrl },
+    ...cloudProfileId === void 0 ? {} : { cloudProfileId },
+    ...cloudProfileReuseIfActive === void 0 ? {} : { cloudProfileReuseIfActive },
+    ...json === void 0 ? {} : { json },
+    ...agents === void 0 ? {} : { agents },
+    ...skills === void 0 ? {} : { skills },
+    ...global === void 0 ? {} : { global },
+    ...yes === void 0 ? {} : { yes },
+    ...copy === void 0 ? {} : { copy },
+    ...all === void 0 ? {} : { all },
+    ...list === void 0 ? {} : { list },
+    ...browser === void 0 ? {} : { browser },
+    ...Object.keys(launch).length === 0 ? {} : { launch },
+    ...context === void 0 ? {} : { context },
+    ...attachEndpoint === void 0 ? {} : { attachEndpoint },
+    ...attachHeaders === void 0 ? {} : { attachHeaders },
+    ...sourceUserDataDir === void 0 ? {} : { sourceUserDataDir },
+    ...sourceProfileDirectory === void 0 ? {} : { sourceProfileDirectory }
+  };
+  return {
+    command,
+    rest,
+    rawOptions,
+    options
+  };
+}
+function shouldParseRuntimeProvider(command) {
+  return !(command[0] === "captcha" && command[1] === "solve");
+}
+function parseKeyValueList(values) {
+  if (values === void 0 || values.length === 0) {
+    return void 0;
+  }
+  return Object.fromEntries(
+    values.map((entry) => {
+      const separator = entry.indexOf("=");
+      if (separator <= 0) {
+        throw new Error(`Expected NAME=VALUE, received "${entry}".`);
+      }
+      return [entry.slice(0, separator), entry.slice(separator + 1)];
+    })
+  );
+}
+function parseCommaSeparatedList(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const values = value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  return values.length === 0 ? void 0 : values;
+}
+function readSingle(options, name) {
+  const values = options.get(name);
+  if (values === void 0 || values.length === 0) {
+    return void 0;
+  }
+  return values[values.length - 1];
+}
+function readOptionalBoolean(options, name) {
+  const value = readSingle(options, name);
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  throw new Error(`Option "--${name}" must be true or false.`);
+}
+function readOptionalNumber(options, name) {
+  const value = readSingle(options, name);
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Option "--${name}" must be a number.`);
+  }
+  return parsed;
+}
+function readJsonValue(options, name) {
+  const value = readSingle(options, name);
+  return value === void 0 ? void 0 : JSON.parse(value);
+}
+function readJsonObject(options, name) {
+  const parsed = readJsonValue(options, name);
+  if (parsed === void 0) {
+    return void 0;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Option "--${name}" must be a JSON object.`);
+  }
+  return parsed;
+}
+function readJsonArray(options, name) {
+  const parsed = readJsonValue(options, name);
+  if (parsed === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error(`Option "--${name}" must be a JSON array.`);
+  }
+  return parsed;
+}
+
+// src/cli/operation-input.ts
+var CLICK_BUTTONS = /* @__PURE__ */ new Set(["left", "middle", "right"]);
+var FETCH_TRANSPORTS = /* @__PURE__ */ new Set(["auto", "direct", "matched-tls", "page"]);
+var CAPTCHA_PROVIDERS = /* @__PURE__ */ new Set(["2captcha", "capsolver"]);
+var CAPTCHA_TYPES = /* @__PURE__ */ new Set(["recaptcha-v2", "hcaptcha", "turnstile"]);
+var SANDBOX_FIDELITIES = /* @__PURE__ */ new Set(["minimal", "standard", "full"]);
+var SANDBOX_CLOCK_MODES = /* @__PURE__ */ new Set(["real", "manual"]);
+var SCREENSHOT_FORMATS = /* @__PURE__ */ new Set(["png", "jpeg", "webp"]);
+var KEY_MODIFIERS = /* @__PURE__ */ new Set(["Shift", "Control", "Alt", "Meta"]);
+var SCROLL_DIRECTIONS = /* @__PURE__ */ new Set(["up", "down", "left", "right"]);
+async function buildOperationInput(operation, parsed, runtime) {
+  switch (operation) {
+    case "session.open": {
+      const url = parsed.rest[0];
+      if (url === void 0) {
+        throw new Error("open requires a URL.");
+      }
+      return {
+        url,
+        ...parsed.options.workspace === void 0 ? {} : { workspace: parsed.options.workspace },
+        ...parsed.options.browser === void 0 ? {} : { browser: parsed.options.browser },
+        ...parsed.options.launch === void 0 ? {} : { launch: parsed.options.launch },
+        ...parsed.options.context === void 0 ? {} : { context: parsed.options.context }
+      };
+    }
+    case "page.list":
+      return {};
+    case "page.new":
+      return parsed.rest[0] === void 0 ? {} : { url: parsed.rest[0] };
+    case "page.activate": {
+      const index = readRequiredPositiveInteger(parsed.rest[0], "tab requires an index.");
+      return {
+        pageRef: await resolvePageRefByIndex(runtime, index)
+      };
+    }
+    case "page.close": {
+      if (parsed.rest[0] === void 0) {
+        return {};
+      }
+      return {
+        pageRef: await resolvePageRefByIndex(
+          runtime,
+          readRequiredPositiveInteger(parsed.rest[0], "tab close requires an index.")
+        )
+      };
+    }
+    case "page.goto": {
+      if (parsed.rest[0] === void 0) {
+        throw new Error("goto requires a URL.");
+      }
+      const captureNetwork = readSingle(parsed.rawOptions, "capture-network");
+      return {
+        url: parsed.rest[0],
+        ...captureNetwork === void 0 ? {} : { captureNetwork }
+      };
+    }
+    case "page.snapshot":
+      return parsed.rest[0] === void 0 ? {} : { mode: parsed.rest[0] };
+    case "page.evaluate":
+      if (parsed.rest[0] === void 0) {
+        throw new Error("evaluate requires a script.");
+      }
+      return {
+        script: joinRest(parsed.rest, 0)
+      };
+    case "page.add-init-script":
+      if (parsed.rest[0] === void 0) {
+        throw new Error("init-script requires a script.");
+      }
+      return {
+        script: joinRest(parsed.rest, 0)
+      };
+    case "dom.click": {
+      const button = readSingle(parsed.rawOptions, "button");
+      return {
+        ...buildElementTargetInput(parsed, "click"),
+        ...button === void 0 ? {} : { button: readClickButton(button) }
+      };
+    }
+    case "dom.hover":
+      return buildElementTargetInput(parsed, "hover");
+    case "dom.input": {
+      if (parsed.rest[1] === void 0) {
+        throw new Error("input requires an element number and text.");
+      }
+      const pressEnter = readOptionalBoolean(parsed.rawOptions, "press-enter");
+      return {
+        ...buildElementTargetInput(parsed, "input"),
+        text: joinRest(parsed.rest, 1),
+        ...pressEnter === void 0 ? {} : { pressEnter }
+      };
+    }
+    case "dom.scroll": {
+      const direction = readSingleDirection(parsed.rest[0]);
+      const amount = readRequiredPositiveInteger(parsed.rest[1], "scroll requires an amount.");
+      const element = readOptionalNumber(parsed.rawOptions, "element");
+      const persist = readPersistKey(parsed, "scroll");
+      const captureNetwork = readSingle(parsed.rawOptions, "capture-network");
+      return {
+        target: element === void 0 ? {
+          kind: "selector",
+          selector: "html"
+        } : {
+          kind: "element",
+          element
+        },
+        direction,
+        amount,
+        ...persist === void 0 ? {} : { persist },
+        ...captureNetwork === void 0 ? {} : { captureNetwork }
+      };
+    }
+    case "dom.extract": {
+      if (parsed.rest[0] === void 0) {
+        throw new Error("extract requires a schema.");
+      }
+      const persist = readExtractPersistKey(parsed);
+      return {
+        schema: parseRequiredJsonObjectArgument(joinRest(parsed.rest, 0), "extract schema"),
+        ...persist === void 0 ? {} : { persist }
+      };
+    }
+    case "network.query": {
+      const capture = readSingle(parsed.rawOptions, "capture");
+      const url = readSingle(parsed.rawOptions, "url");
+      const hostname = readSingle(parsed.rawOptions, "hostname");
+      const path4 = readSingle(parsed.rawOptions, "path");
+      const method = readSingle(parsed.rawOptions, "method");
+      const status = readOptionalNumber(parsed.rawOptions, "status");
+      const resourceType = readSingle(parsed.rawOptions, "type");
+      const json = readOptionalBoolean(parsed.rawOptions, "json");
+      const before = readSingle(parsed.rawOptions, "before");
+      const after = readSingle(parsed.rawOptions, "after");
+      const limit = readOptionalNumber(parsed.rawOptions, "limit");
+      return {
+        ...capture === void 0 ? {} : { capture },
+        ...url === void 0 ? {} : { url },
+        ...hostname === void 0 ? {} : { hostname },
+        ...path4 === void 0 ? {} : { path: path4 },
+        ...method === void 0 ? {} : { method },
+        ...status === void 0 ? {} : { status },
+        ...resourceType === void 0 ? {} : { resourceType },
+        ...json === true ? { json: true } : {},
+        ...before === void 0 ? {} : { before },
+        ...after === void 0 ? {} : { after },
+        ...limit === void 0 ? {} : { limit }
+      };
+    }
+    case "network.detail":
+      if (parsed.rest[0] === void 0) {
+        throw new Error("network detail requires a record id.");
+      }
+      return {
+        recordId: parsed.rest[0]
+      };
+    case "network.replay": {
+      if (parsed.rest[0] === void 0) {
+        throw new Error("replay requires a record id.");
+      }
+      const query = parseKeyValueList(parsed.rawOptions.get("query"));
+      const headers = parseKeyValueList(parsed.rawOptions.get("header"));
+      const bodyJson = readJsonValue(parsed.rawOptions, "body");
+      const variables = readJsonObject(parsed.rawOptions, "variables");
+      return {
+        recordId: parsed.rest[0],
+        ...query === void 0 ? {} : { query },
+        ...headers === void 0 ? {} : { headers },
+        ...bodyJson === void 0 ? {} : { body: { json: bodyJson } },
+        ...variables === void 0 ? {} : { variables }
+      };
+    }
+    case "session.fetch": {
+      const url = parsed.rest[0];
+      if (url === void 0) {
+        throw new Error("fetch requires a URL.");
+      }
+      const bodyJson = readJsonValue(parsed.rawOptions, "body");
+      const bodyText = readSingle(parsed.rawOptions, "body-text");
+      const method = readSingle(parsed.rawOptions, "method");
+      const query = parseKeyValueList(parsed.rawOptions.get("query"));
+      const headers = parseKeyValueList(parsed.rawOptions.get("header"));
+      if (bodyJson !== void 0 && bodyText !== void 0) {
+        throw new Error('Use either "--body" or "--body-text", not both.');
+      }
+      const transport = readSingle(parsed.rawOptions, "transport");
+      const cookies = readOptionalBoolean(parsed.rawOptions, "cookies");
+      const followRedirects = readOptionalBoolean(parsed.rawOptions, "follow-redirects");
+      return {
+        url,
+        ...method === void 0 ? {} : { method },
+        ...query === void 0 ? {} : { query },
+        ...headers === void 0 ? {} : { headers },
+        ...bodyJson === void 0 ? {} : { body: { json: bodyJson } },
+        ...bodyText === void 0 ? {} : { body: { text: bodyText } },
+        ...transport === void 0 ? {} : { transport: readFetchTransport(transport) },
+        ...cookies === void 0 ? {} : { cookies },
+        ...followRedirects === void 0 ? {} : { followRedirects }
+      };
+    }
+    case "session.cookies":
+    case "session.storage":
+    case "session.state":
+      return parsed.rest[0] === void 0 ? {} : { domain: parsed.rest[0] };
+    case "computer.execute":
+      return buildComputerExecuteInput(parsed);
+    case "captcha.solve": {
+      const provider = readSingle(parsed.rawOptions, "provider");
+      const apiKey = readSingle(parsed.rawOptions, "api-key");
+      const timeoutMs = readOptionalNumber(parsed.rawOptions, "timeout") ?? readOptionalNumber(parsed.rawOptions, "timeout-ms");
+      const type = readSingle(parsed.rawOptions, "type");
+      const siteKey = readSingle(parsed.rawOptions, "site-key");
+      const pageUrl = readSingle(parsed.rawOptions, "page-url");
+      if (provider === void 0 || apiKey === void 0) {
+        throw new Error('captcha solve requires "--provider" and "--api-key".');
+      }
+      return {
+        provider: readCaptchaProvider(provider),
+        apiKey,
+        ...timeoutMs === void 0 ? {} : { timeoutMs },
+        ...type === void 0 ? {} : { type: readCaptchaType(type) },
+        ...siteKey === void 0 ? {} : { siteKey },
+        ...pageUrl === void 0 ? {} : { pageUrl }
+      };
+    }
+    case "scripts.capture": {
+      const urlFilter = readSingle(parsed.rawOptions, "url-filter");
+      const persist = readOptionalBoolean(parsed.rawOptions, "persist");
+      const includeInline = readOptionalBoolean(parsed.rawOptions, "inline");
+      const includeExternal = readOptionalBoolean(parsed.rawOptions, "external");
+      const includeDynamic = readOptionalBoolean(parsed.rawOptions, "dynamic");
+      const includeWorkers = readOptionalBoolean(parsed.rawOptions, "workers");
+      return {
+        ...urlFilter === void 0 ? {} : { urlFilter },
+        ...persist === void 0 ? {} : { persist },
+        ...includeInline === void 0 ? {} : { includeInline },
+        ...includeExternal === void 0 ? {} : { includeExternal },
+        ...includeDynamic === void 0 ? {} : { includeDynamic },
+        ...includeWorkers === void 0 ? {} : { includeWorkers }
+      };
+    }
+    case "scripts.beautify":
+    case "scripts.deobfuscate": {
+      if (parsed.rest[0] === void 0) {
+        throw new Error(`${parsed.command.join(" ")} requires an artifact id.`);
+      }
+      const persist = readOptionalBoolean(parsed.rawOptions, "persist");
+      return {
+        artifactId: parsed.rest[0],
+        ...persist === void 0 ? {} : { persist }
+      };
+    }
+    case "scripts.sandbox":
+      if (parsed.rest[0] === void 0) {
+        throw new Error("scripts sandbox requires an artifact id.");
+      }
+      {
+        const fidelity = readSingle(parsed.rawOptions, "fidelity");
+        const timeoutMs = readOptionalNumber(parsed.rawOptions, "timeout") ?? readOptionalNumber(parsed.rawOptions, "timeout-ms");
+        const clock = readSingle(parsed.rawOptions, "clock");
+        const cookies = readJsonObject(parsed.rawOptions, "cookies");
+        const globals = readJsonObject(parsed.rawOptions, "globals");
+        const ajaxRoutes = readJsonArray(parsed.rawOptions, "ajax-routes");
+        return {
+          artifactId: parsed.rest[0],
+          ...fidelity === void 0 ? {} : { fidelity: readSandboxFidelity(fidelity) },
+          ...timeoutMs === void 0 ? {} : { timeoutMs },
+          ...clock === void 0 ? {} : { clockMode: readSandboxClockMode(clock) },
+          ...cookies === void 0 ? {} : { cookies },
+          ...globals === void 0 ? {} : { globals },
+          ...ajaxRoutes === void 0 ? {} : { ajaxRoutes }
+        };
+      }
+    case "interaction.capture": {
+      const key = readSingle(parsed.rawOptions, "key");
+      const durationMs = readOptionalNumber(parsed.rawOptions, "duration");
+      const script = readSingle(parsed.rawOptions, "script");
+      const includeStorage = readOptionalBoolean(parsed.rawOptions, "include-storage");
+      const includeSessionStorage = readOptionalBoolean(
+        parsed.rawOptions,
+        "include-session-storage"
+      );
+      const includeIndexedDb = readOptionalBoolean(parsed.rawOptions, "include-indexed-db");
+      const globalNames = parseCommaSeparatedList(readSingle(parsed.rawOptions, "global-names"));
+      const caseId = readSingle(parsed.rawOptions, "case-id");
+      const notes = readSingle(parsed.rawOptions, "notes");
+      const tags = parseCommaSeparatedList(readSingle(parsed.rawOptions, "tags"));
+      return {
+        ...key === void 0 ? {} : { key },
+        ...durationMs === void 0 ? {} : { durationMs },
+        ...script === void 0 ? {} : { script },
+        ...includeStorage === void 0 ? {} : { includeStorage },
+        ...includeSessionStorage === void 0 ? {} : { includeSessionStorage },
+        ...includeIndexedDb === void 0 ? {} : { includeIndexedDb },
+        ...globalNames === void 0 ? {} : { globalNames },
+        ...caseId === void 0 ? {} : { caseId },
+        ...notes === void 0 ? {} : { notes },
+        ...tags === void 0 ? {} : { tags }
+      };
+    }
+    case "interaction.get":
+    case "interaction.replay":
+      if (parsed.rest[0] === void 0) {
+        throw new Error(`${parsed.command.join(" ")} requires a trace id.`);
+      }
+      return {
+        traceId: parsed.rest[0]
+      };
+    case "interaction.diff":
+      if (parsed.rest[0] === void 0 || parsed.rest[1] === void 0) {
+        throw new Error("interaction diff requires two trace ids.");
+      }
+      return {
+        leftTraceId: parsed.rest[0],
+        rightTraceId: parsed.rest[1]
+      };
+    case "artifact.read":
+      if (parsed.rest[0] === void 0) {
+        throw new Error("artifact read requires an artifact id.");
+      }
+      return {
+        artifactId: parsed.rest[0]
+      };
+    case "session.close":
+      return {};
+    default:
+      throw new Error(
+        `${operation} does not have a direct CLI input shape. Use a supported command or the SDK.`
+      );
   }
-  const browser = record.executablePath ? path.basename(record.executablePath).replace(/\.[A-Za-z0-9]+$/u, "") : void 0;
+}
+function buildElementTargetInput(parsed, verb) {
+  const element = readRequiredPositiveInteger(
+    parsed.rest[0],
+    `${verb} requires an element number.`
+  );
+  const persist = readPersistKey(parsed, verb);
+  const captureNetwork = readSingle(parsed.rawOptions, "capture-network");
   return {
-    provider: "local",
-    status: "active",
-    current,
-    summary: `PID ${String(record.pid)}`,
-    detail: browser ?? record.engine,
-    pid: record.pid,
-    engine: record.engine,
-    ...browser === void 0 ? {} : { browser }
+    target: {
+      kind: "element",
+      element
+    },
+    ...persist === void 0 ? {} : { persist },
+    ...captureNetwork === void 0 ? {} : { captureNetwork }
   };
 }
-async function describeCloudLane(input) {
-  if (input.record === void 0) {
-    return {
-      provider: "cloud",
-      status: "idle",
-      current: input.current,
-      summary: "none"
+function buildComputerExecuteInput(parsed) {
+  const subcommand = parsed.command[1];
+  const screenshotFormat = readSingle(parsed.rawOptions, "format");
+  const screenshot = screenshotFormat === void 0 ? void 0 : {
+    format: readScreenshotFormat(screenshotFormat)
+  };
+  const captureNetwork = readSingle(parsed.rawOptions, "capture-network");
+  switch (subcommand) {
+    case "click": {
+      const button = readSingle(parsed.rawOptions, "button");
+      const clickCount = readOptionalNumber(parsed.rawOptions, "count");
+      const modifiers = readKeyModifiers(readSingle(parsed.rawOptions, "modifiers"));
+      return {
+        action: {
+          type: "click",
+          x: readRequiredNumber(parsed.rest[0], "computer click requires x."),
+          y: readRequiredNumber(parsed.rest[1], "computer click requires y."),
+          ...button === void 0 ? {} : { button: readClickButton(button) },
+          ...clickCount === void 0 ? {} : { clickCount },
+          ...modifiers === void 0 ? {} : { modifiers }
+        },
+        ...captureNetwork === void 0 ? {} : { captureNetwork }
+      };
+    }
+    case "type":
+      if (parsed.rest[0] === void 0) {
+        throw new Error("computer type requires text.");
+      }
+      return {
+        action: {
+          type: "type",
+          text: joinRest(parsed.rest, 0)
+        },
+        ...captureNetwork === void 0 ? {} : { captureNetwork }
+      };
+    case "key": {
+      if (parsed.rest[0] === void 0) {
+        throw new Error("computer key requires a key.");
+      }
+      const modifiers = readKeyModifiers(readSingle(parsed.rawOptions, "modifiers"));
+      return {
+        action: {
+          type: "key",
+          key: parsed.rest[0],
+          ...modifiers === void 0 ? {} : { modifiers }
+        },
+        ...captureNetwork === void 0 ? {} : { captureNetwork }
+      };
+    }
+    case "scroll": {
+      const dx = readOptionalNumber(parsed.rawOptions, "dx");
+      const dy = readOptionalNumber(parsed.rawOptions, "dy");
+      if (dx === void 0 || dy === void 0) {
+        throw new Error('computer scroll requires "--dx" and "--dy".');
+      }
+      return {
+        action: {
+          type: "scroll",
+          x: readRequiredNumber(parsed.rest[0], "computer scroll requires x."),
+          y: readRequiredNumber(parsed.rest[1], "computer scroll requires y."),
+          deltaX: dx,
+          deltaY: dy
+        },
+        ...captureNetwork === void 0 ? {} : { captureNetwork }
+      };
+    }
+    case "move":
+      return {
+        action: {
+          type: "move",
+          x: readRequiredNumber(parsed.rest[0], "computer move requires x."),
+          y: readRequiredNumber(parsed.rest[1], "computer move requires y.")
+        },
+        ...captureNetwork === void 0 ? {} : { captureNetwork }
+      };
+    case "drag": {
+      const steps = readOptionalNumber(parsed.rawOptions, "steps");
+      return {
+        action: {
+          type: "drag",
+          start: {
+            x: readRequiredNumber(parsed.rest[0], "computer drag requires start x."),
+            y: readRequiredNumber(parsed.rest[1], "computer drag requires start y.")
+          },
+          end: {
+            x: readRequiredNumber(parsed.rest[2], "computer drag requires end x."),
+            y: readRequiredNumber(parsed.rest[3], "computer drag requires end y.")
+          },
+          ...steps === void 0 ? {} : { steps }
+        },
+        ...captureNetwork === void 0 ? {} : { captureNetwork }
+      };
+    }
+    case "screenshot":
+      return {
+        action: {
+          type: "screenshot"
+        },
+        ...screenshot === void 0 ? {} : { screenshot }
+      };
+    case "wait":
+      return {
+        action: {
+          type: "wait",
+          durationMs: readRequiredPositiveInteger(parsed.rest[0], "computer wait requires ms.")
+        }
+      };
+    default:
+      throw new Error(`Unknown computer command: ${parsed.command.join(" ")}`);
+  }
+}
+async function resolvePageRefByIndex(runtime, index) {
+  const pages = (await runtime.listPages({})).pages;
+  const page = pages[index - 1];
+  if (page === void 0) {
+    throw new Error(`tab ${String(index)} does not exist.`);
+  }
+  return page.pageRef;
+}
+function readRequiredPositiveInteger(value, message) {
+  const parsed = readRequiredNumber(value, message);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new Error(message);
+  }
+  return parsed;
+}
+function readRequiredNumber(value, message) {
+  if (value === void 0) {
+    throw new Error(message);
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(message);
+  }
+  return parsed;
+}
+function readSingleDirection(value) {
+  if (value === void 0 || !SCROLL_DIRECTIONS.has(value)) {
+    throw new Error("scroll requires a direction: up, down, left, or right.");
+  }
+  return value;
+}
+function readClickButton(value) {
+  if (value === void 0 || !CLICK_BUTTONS.has(value)) {
+    throw new Error('Expected "--button" to be one of: left, middle, right.');
+  }
+  return value;
+}
+function readFetchTransport(value) {
+  if (value === void 0 || !FETCH_TRANSPORTS.has(value)) {
+    throw new Error('Expected "--transport" to be one of: auto, direct, matched-tls, page.');
+  }
+  return value;
+}
+function readCaptchaProvider(value) {
+  if (value === void 0 || !CAPTCHA_PROVIDERS.has(value)) {
+    throw new Error('Expected "--provider" to be one of: 2captcha, capsolver.');
+  }
+  return value;
+}
+function readCaptchaType(value) {
+  if (value === void 0 || !CAPTCHA_TYPES.has(value)) {
+    throw new Error(
+      'Expected "--type" to be one of: recaptcha-v2, hcaptcha, turnstile.'
+    );
+  }
+  return value;
+}
+function readSandboxFidelity(value) {
+  if (value === void 0 || !SANDBOX_FIDELITIES.has(value)) {
+    throw new Error('Expected "--fidelity" to be one of: minimal, standard, full.');
+  }
+  return value;
+}
+function readSandboxClockMode(value) {
+  if (value === void 0 || !SANDBOX_CLOCK_MODES.has(value)) {
+    throw new Error('Expected "--clock" to be one of: real, manual.');
+  }
+  return value;
+}
+function readScreenshotFormat(value) {
+  if (value === void 0 || !SCREENSHOT_FORMATS.has(value)) {
+    throw new Error('Expected "--format" to be one of: png, jpeg, webp.');
+  }
+  return value;
+}
+function readKeyModifiers(value) {
+  const modifiers = parseCommaSeparatedList(value);
+  if (modifiers === void 0) {
+    return void 0;
+  }
+  for (const modifier of modifiers) {
+    if (!KEY_MODIFIERS.has(modifier)) {
+      throw new Error('Expected "--modifiers" to contain only: Shift, Control, Alt, Meta.');
+    }
+  }
+  return [...new Set(modifiers)];
+}
+function readPersistKey(parsed, verb) {
+  const value = readSingle(parsed.rawOptions, "persist");
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === "true" || value === "false") {
+    throw new Error(`${verb} requires "--persist <key>" when using --persist.`);
+  }
+  if (verb === "scroll" && readOptionalNumber(parsed.rawOptions, "element") === void 0) {
+    throw new Error('scroll requires "--element <n>" when using "--persist <key>".');
+  }
+  return value;
+}
+function readExtractPersistKey(parsed) {
+  const value = readSingle(parsed.rawOptions, "persist");
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === "true" || value === "false") {
+    throw new Error('extract requires "--persist <key>" when using --persist.');
+  }
+  return value;
+}
+function parseRequiredJsonObjectArgument(value, label) {
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${label} must be a JSON object.`);
+  }
+  return parsed;
+}
+function joinRest(rest, startIndex) {
+  return rest.slice(startIndex).join(" ");
+}
+
+// src/cli/output.ts
+function renderOperationOutput(operation, result, input) {
+  switch (operation) {
+    case "session.open":
+    case "page.goto":
+      return renderJson(formatNavigationOutput(result));
+    case "page.snapshot":
+      return formatSnapshotOutput(result);
+    case "dom.click":
+    case "dom.hover":
+    case "dom.input":
+    case "dom.scroll":
+      return renderJson(formatActionOutput(result, input));
+    case "dom.extract":
+      return renderJson(formatExtractOutput(result));
+    case "page.list":
+    case "page.new":
+    case "page.activate":
+    case "page.close":
+      return formatTabOutput(result);
+    case "network.query":
+      return formatNetworkQueryOutput(result, input);
+    case "network.detail":
+      return formatNetworkDetailOutput(result);
+    case "network.replay":
+    case "session.fetch":
+      return renderJson(formatTransportOutput(result, operation));
+    case "session.cookies":
+      return formatCookiesOutput(result);
+    case "session.storage":
+      return formatStorageOutput(result);
+    case "session.state":
+      return formatStateOutput(result);
+    case "computer.execute":
+      return renderJson(formatComputerOutput(result));
+    case "scripts.capture":
+      return formatScriptsCaptureOutput(result);
+    case "scripts.beautify":
+      return formatScriptTransformOutput(result, "scripts.beautify");
+    case "scripts.deobfuscate":
+      return formatScriptTransformOutput(result, "scripts.deobfuscate");
+    case "scripts.sandbox":
+      return renderJson(formatScriptSandboxOutput(result));
+    case "captcha.solve":
+      return renderJson(formatCaptchaSolveOutput(result));
+    case "interaction.capture":
+    case "interaction.get":
+      return renderJson(formatInteractionTraceOutput(result));
+    case "interaction.diff":
+      return renderJson(formatInteractionDiffOutput(result));
+    case "interaction.replay":
+      return renderJson(formatInteractionReplayOutput(result));
+    default:
+      return renderJson(result);
+  }
+}
+function formatNavigationOutput(result) {
+  return {
+    ...readStringField(result, "url") === void 0 ? {} : { url: readStringField(result, "url") },
+    ...readStringField(result, "title") === void 0 ? {} : { title: readStringField(result, "title") }
+  };
+}
+function formatSnapshotOutput(result) {
+  if (result !== null && typeof result === "object" && typeof result.html === "string") {
+    return `${result.html}
+`;
+  }
+  return renderJson(result);
+}
+function formatActionOutput(result, input) {
+  const target = readObjectField(result, "target");
+  const output = {
+    ...readStringField(target, "tagName") === void 0 ? {} : { tagName: readStringField(target, "tagName") },
+    ...readStringField(target, "pathHint") === void 0 ? {} : { pathHint: readStringField(target, "pathHint") }
+  };
+  const point = readObjectField(result, "point");
+  if (point !== void 0) {
+    output.point = {
+      ...readNumberField(point, "x") === void 0 ? {} : { x: readNumberField(point, "x") },
+      ...readNumberField(point, "y") === void 0 ? {} : { y: readNumberField(point, "y") }
     };
   }
-  const base = {
-    provider: "cloud",
-    status: "connected",
-    current: input.current,
-    summary: input.record.sessionId,
-    sessionId: input.record.sessionId,
-    ...input.cloudConfig === void 0 ? {} : {
-      detail: input.cloudConfig.baseUrl,
-      baseUrl: input.cloudConfig.baseUrl
+  const persist = readStringField(target, "persist");
+  if (persist !== void 0) {
+    output.persist = persist;
+  }
+  const text = readStringField(input, "text");
+  if (text !== void 0) {
+    output.text = text;
+  }
+  const direction = readStringField(input, "direction");
+  if (direction !== void 0) {
+    output.direction = direction;
+  }
+  const amount = readNumberField(input, "amount");
+  if (amount !== void 0) {
+    output.amount = amount;
+  }
+  return output;
+}
+function formatExtractOutput(result) {
+  const data = readUnknownField(result, "data");
+  return data === void 0 ? result : data;
+}
+function formatTabOutput(result) {
+  const pages = readArrayField(result, "pages");
+  const activePageRef = readStringField(result, "activePageRef");
+  const lines = [`[tabs] ${pages.length} tab${pages.length === 1 ? "" : "s"}`];
+  pages.forEach((page, index) => {
+    const marker = readStringField(page, "pageRef") === activePageRef ? "*" : " ";
+    lines.push(
+      `${marker} ${String(index + 1).padStart(2, " ")}  ${truncateInline(readStringField(page, "title") ?? "(untitled)", 48)}  ${readStringField(page, "url") ?? ""}`
+    );
+  });
+  return `${lines.join("\n")}
+`;
+}
+function formatNetworkQueryOutput(result, input) {
+  const records = readArrayField(result, "records");
+  const capture = summarizeCapture(records);
+  const jsonOnly = readBooleanField(input, "json") === true;
+  const lines = [
+    `[network.query] ${records.length} record${records.length === 1 ? "" : "s"}${capture === void 0 ? "" : ` from capture "${capture}"`}${jsonOnly ? " (JSON/GraphQL only)" : ""}`
+  ];
+  for (const record of records) {
+    const graphql = readObjectField(record, "graphql");
+    const operationName = readStringField(graphql, "operationName");
+    lines.push(
+      `${readStringField(record, "recordId") ?? "rec:unknown"}  ${readStringField(record, "method") ?? "GET"} ${readStatus(record)}  ${readStringField(record, "resourceType") ?? "unknown"}  ${readStringField(record, "url") ?? ""}${operationName === void 0 ? "" : `  [query: ${operationName}]`}`
+    );
+    const request = readObjectField(record, "request");
+    const response = readObjectField(record, "response");
+    const websocket = readObjectField(record, "websocket");
+    if (request !== void 0) {
+      lines.push(`  request: ${formatBodySummary(request)}`);
+    }
+    if (response !== void 0) {
+      lines.push(`  response: ${formatBodySummary(response)}`);
+    }
+    const subprotocol = readStringField(websocket, "subprotocol");
+    if (subprotocol !== void 0) {
+      lines.push(`  subprotocol: ${subprotocol}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function formatNetworkDetailOutput(result) {
+  if (result === null || typeof result !== "object") {
+    return renderJson(result);
+  }
+  const lines = [`[network.detail] ${readStringField(result, "recordId") ?? "unknown"}`, ""];
+  const summary = readObjectField(result, "summary");
+  if (summary !== void 0) {
+    lines.push(
+      `${readStringField(summary, "method") ?? "GET"} ${readStatus(summary)} ${readStringField(summary, "url") ?? ""}`
+    );
+  }
+  const graphql = readObjectField(result, "graphql");
+  if (graphql !== void 0) {
+    const operationType = readStringField(graphql, "operationType");
+    const operationName = readStringField(graphql, "operationName");
+    lines.push(
+      `${["GraphQL:", operationType, operationName].filter((value) => value !== void 0).join(" ")}`
+    );
+    const variables = readUnknownField(graphql, "variables");
+    if (variables !== void 0) {
+      lines.push("Variables:");
+      lines.push(indentLines(stringifyValue(variables)));
+    }
+  }
+  const requestHeaders = readArrayField(result, "requestHeaders");
+  if (requestHeaders.length > 0) {
+    lines.push("", "Request headers:");
+    lines.push(...requestHeaders.map((header) => formatHeaderLine(header)));
+  }
+  const responseHeaders = readArrayField(result, "responseHeaders");
+  if (responseHeaders.length > 0) {
+    lines.push("", "Response headers:");
+    lines.push(...responseHeaders.map((header) => formatHeaderLine(header)));
+  }
+  const cookiesSent = readArrayField(result, "cookiesSent");
+  if (cookiesSent.length > 0) {
+    lines.push("", "Cookies sent:");
+    lines.push(
+      ...cookiesSent.map((cookie) => {
+        const name = readStringField(cookie, "name") ?? "cookie";
+        const value = readStringField(cookie, "value") ?? "";
+        return `  ${name}: ${truncateInline(value, 80)}`;
+      })
+    );
+  }
+  const requestBody = readObjectField(result, "requestBody");
+  if (requestBody !== void 0) {
+    lines.push("", formatBodyPreview("Request body", requestBody));
+  }
+  const responseBody = readObjectField(result, "responseBody");
+  if (responseBody !== void 0) {
+    lines.push("", formatBodyPreview("Response body", responseBody));
+  }
+  const redirectChain = readArrayField(result, "redirectChain");
+  if (redirectChain.length > 0) {
+    lines.push("", `Redirect chain (${redirectChain.length} hop${redirectChain.length === 1 ? "" : "s"}):`);
+    redirectChain.forEach((hop, index) => {
+      const location = readStringField(hop, "location");
+      lines.push(
+        `  ${index + 1}. ${readStringField(hop, "method") ?? "GET"} ${readStatus(hop)} ${readStringField(hop, "url") ?? ""}${location === void 0 ? "" : `  ->  Location: ${location}`}`
+      );
+    });
+  }
+  const notes = readArrayField(result, "notes").map((entry) => typeof entry === "string" ? entry : void 0).filter((entry) => entry !== void 0);
+  if (notes.length > 0) {
+    lines.push("", ...notes.map((note) => `Note: ${note}`));
+  }
+  return `${lines.join("\n")}
+`;
+}
+function formatTransportOutput(result, operation) {
+  if (result === null || typeof result !== "object") {
+    return { result };
+  }
+  const response = readObjectField(result, "response");
+  const attempts = readArrayField(result, "attempts").map((attempt) => ({
+    ...readStringField(attempt, "transport") === void 0 ? {} : { transport: readStringField(attempt, "transport") },
+    ...readNumberField(attempt, "status") === void 0 ? {} : { status: readNumberField(attempt, "status") },
+    ...readStringField(attempt, "note") === void 0 ? {} : { note: readStringField(attempt, "note") },
+    ...readStringField(attempt, "error") === void 0 ? {} : { error: readStringField(attempt, "error") }
+  }));
+  const contentType = response === void 0 ? void 0 : findHeaderValue(readArrayField(response, "headers"), "content-type") ?? readStringField(readObjectField(response, "body"), "mimeType");
+  const body = readObjectField(response, "body");
+  const bodySize = body === void 0 ? void 0 : readNumberField(body, "originalByteLength") ?? readNumberField(body, "capturedByteLength");
+  const output = {
+    ...operation === "network.replay" && readStringField(result, "recordId") !== void 0 ? { recordId: readStringField(result, "recordId") } : {},
+    ...readStringField(result, "transport") === void 0 ? {} : { transport: readStringField(result, "transport") },
+    ...response === void 0 ? {} : { status: readNumberField(response, "status") },
+    ...contentType === void 0 ? {} : { contentType },
+    ...bodySize === void 0 ? {} : { bodySize }
+  };
+  const note = readStringField(result, "note");
+  if (note !== void 0) {
+    output.note = note;
+  }
+  const data = readUnknownField(result, "data");
+  if (data !== void 0) {
+    output.data = truncateDataShape(data);
+  }
+  if (attempts.length > 0) {
+    output.attempts = attempts;
+  }
+  if (JSON.stringify(output).length > 4096 && data !== void 0) {
+    output.data = `... truncated, ${JSON.stringify(data).length.toLocaleString("en-US")} chars total`;
+  }
+  return output;
+}
+function formatCookiesOutput(result) {
+  if (result === null || typeof result !== "object") {
+    return renderJson(result);
+  }
+  const cookies = readArrayField(result, "cookies");
+  const domain = readStringField(result, "domain");
+  const lines = [`[cookies] ${cookies.length} cookie${cookies.length === 1 ? "" : "s"}${domain === void 0 ? "" : ` for ${domain}`}`];
+  for (const cookie of cookies) {
+    const flags = [
+      readBooleanField(cookie, "session") === true ? "session" : void 0,
+      readBooleanField(cookie, "httpOnly") === true ? "httpOnly" : void 0,
+      readBooleanField(cookie, "secure") === true ? "secure" : void 0,
+      readStringField(cookie, "expiresAt")
+    ].filter((value) => value !== void 0);
+    lines.push(
+      `  ${padRight(readStringField(cookie, "name") ?? "cookie", 20)} ${truncateInline(readStringField(cookie, "value") ?? "", 48)}${flags.length === 0 ? "" : `  ${flags.join("  ")}`}`
+    );
+  }
+  return `${lines.join("\n")}
+`;
+}
+function formatStorageOutput(result) {
+  if (result === null || typeof result !== "object") {
+    return renderJson(result);
+  }
+  const domains = readArrayField(result, "domains");
+  const lines = [];
+  for (const domain of domains) {
+    const domainName = readStringField(domain, "domain") ?? "unknown";
+    const localStorage = readArrayField(domain, "localStorage");
+    const sessionStorage = readArrayField(domain, "sessionStorage");
+    lines.push(`[storage] localStorage for ${domainName} (${localStorage.length} key${localStorage.length === 1 ? "" : "s"})`, "");
+    lines.push(...localStorage.map((entry) => formatStorageEntry(entry)));
+    lines.push("", `[storage] sessionStorage for ${domainName} (${sessionStorage.length} key${sessionStorage.length === 1 ? "" : "s"})`, "");
+    lines.push(...sessionStorage.map((entry) => formatStorageEntry(entry)), "");
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function formatStateOutput(result) {
+  if (result === null || typeof result !== "object") {
+    return renderJson(result);
+  }
+  const domains = readArrayField(result, "domains");
+  const lines = [];
+  for (const domain of domains) {
+    const name = readStringField(domain, "domain") ?? "unknown";
+    lines.push(`[state] ${name}`, "");
+    const cookies = readArrayField(domain, "cookies");
+    lines.push(`Cookies (${cookies.length}):`);
+    lines.push(
+      ...cookies.map(
+        (cookie) => `  ${padRight(readStringField(cookie, "name") ?? "cookie", 16)} ${truncateInline(readStringField(cookie, "value") ?? "", 36)}`
+      )
+    );
+    const hiddenFields = readArrayField(domain, "hiddenFields");
+    lines.push("", `Hidden fields (${hiddenFields.length}):`);
+    lines.push(
+      ...hiddenFields.map(
+        (field) => `  ${readStringField(field, "path") ?? "input"}  = ${JSON.stringify(readStringField(field, "value") ?? "")}`
+      )
+    );
+    const localStorage = readArrayField(domain, "localStorage");
+    lines.push("", `localStorage (${localStorage.length} key${localStorage.length === 1 ? "" : "s"}):`);
+    lines.push(...localStorage.map((entry) => formatStorageEntry(entry)));
+    const sessionStorage = readArrayField(domain, "sessionStorage");
+    lines.push("", `sessionStorage (${sessionStorage.length} key${sessionStorage.length === 1 ? "" : "s"}):`);
+    lines.push(...sessionStorage.map((entry) => formatStorageEntry(entry)));
+    const globals = readObjectField(domain, "globals");
+    if (globals !== void 0) {
+      lines.push("", "Globals:");
+      for (const [key, value] of Object.entries(globals)) {
+        lines.push(`  ${key} = ${truncateInline(stringifyScalarLike(value), 80)}`);
+      }
+    }
+    lines.push("");
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function formatComputerOutput(result) {
+  const action = readObjectField(result, "action");
+  const screenshot = readObjectField(result, "screenshot");
+  const payload = readObjectField(screenshot, "payload");
+  const timing = readObjectField(result, "timing");
+  return {
+    ...action === void 0 ? {} : { action },
+    ...payload === void 0 ? {} : {
+      screenshot: {
+        ...readStringField(payload, "uri") === void 0 ? {} : { uri: readStringField(payload, "uri") },
+        ...readStringField(screenshot, "format") === void 0 ? {} : { format: readStringField(screenshot, "format") },
+        ...readObjectField(screenshot, "size") === void 0 ? {} : { size: readObjectField(screenshot, "size") }
+      }
+    },
+    ...timing === void 0 ? {} : { timingMs: timing }
+  };
+}
+function formatScriptsCaptureOutput(result) {
+  if (result === null || typeof result !== "object") {
+    return renderJson(result);
+  }
+  const scripts = readArrayField(result, "scripts");
+  const lines = [`[scripts.capture] ${scripts.length} script${scripts.length === 1 ? "" : "s"}`];
+  for (const script of scripts) {
+    const source = readStringField(script, "source") ?? "unknown";
+    const url = readStringField(script, "url") ?? "<inline>";
+    const artifactId = readStringField(script, "artifactId");
+    const content = readStringField(script, "content") ?? "";
+    lines.push(
+      `${artifactId === void 0 ? "-" : artifactId}  ${source.padEnd(8, " ")}  ${truncateInline(url, 120)}  (${content.length.toLocaleString("en-US")} chars)`
+    );
+  }
+  return `${lines.join("\n")}
+`;
+}
+function formatScriptTransformOutput(result, label) {
+  if (result === null || typeof result !== "object") {
+    return renderJson(result);
+  }
+  const lines = [
+    `[${label}] ${formatBytes(readNumberField(result, "bytesBefore"))} -> ${formatBytes(readNumberField(result, "bytesAfter"))}`
+  ];
+  const artifactId = readStringField(result, "artifactId");
+  if (artifactId !== void 0) {
+    lines.push(`artifact: ${artifactId}`);
+  }
+  const transforms = readArrayField(result, "transforms").map((value) => typeof value === "string" ? value : void 0).filter((value) => value !== void 0);
+  if (transforms.length > 0) {
+    lines.push(`transforms: ${transforms.join(", ")}`);
+  }
+  const content = readStringField(result, "content");
+  if (content !== void 0) {
+    lines.push("", content);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function formatInteractionTraceOutput(result) {
+  const trace = readObjectField(result, "trace");
+  if (trace === void 0) {
+    return { result };
+  }
+  const payload = readObjectField(trace, "payload");
+  return {
+    ...readStringField(trace, "id") === void 0 ? {} : { id: readStringField(trace, "id") },
+    ...readStringField(trace, "key") === void 0 ? {} : { key: readStringField(trace, "key") },
+    ...readStringField(trace, "version") === void 0 ? {} : { version: readStringField(trace, "version") },
+    ...readStringField(payload, "mode") === void 0 ? {} : { mode: readStringField(payload, "mode") },
+    ...readStringField(payload, "url") === void 0 ? {} : { url: readStringField(payload, "url") },
+    ...readArrayField(payload, "events").length === 0 ? {} : { eventCount: readArrayField(payload, "events").length },
+    ...readArrayField(payload, "networkRecordIds").length === 0 ? {} : { networkRecordIds: readArrayField(payload, "networkRecordIds") }
+  };
+}
+function formatScriptSandboxOutput(result) {
+  if (result === null || typeof result !== "object") {
+    return { result };
+  }
+  const capturedAjax = readArrayField(result, "capturedAjax").map((entry) => ({
+    ...readStringField(entry, "method") === void 0 ? {} : { method: readStringField(entry, "method") },
+    ...readStringField(entry, "url") === void 0 ? {} : { url: readStringField(entry, "url") },
+    ...readNumberField(entry, "timestamp") === void 0 ? {} : { timestamp: readNumberField(entry, "timestamp") }
+  }));
+  const errors = readArrayField(result, "errors").map((entry) => typeof entry === "string" ? entry : void 0).filter((entry) => entry !== void 0);
+  return {
+    ...readNumberField(result, "durationMs") === void 0 ? {} : { durationMs: readNumberField(result, "durationMs") },
+    ...capturedAjax.length === 0 ? {} : { capturedAjax },
+    ...errors.length === 0 ? {} : { errors },
+    ...readUnknownField(result, "result") === void 0 ? {} : { result: truncateDataShape(readUnknownField(result, "result")) }
+  };
+}
+function formatCaptchaSolveOutput(result) {
+  const captcha = readObjectField(result, "captcha");
+  return {
+    ...readStringField(result, "provider") === void 0 ? {} : { provider: readStringField(result, "provider") },
+    ...captcha === void 0 ? {} : {
+      captcha: {
+        ...readStringField(captcha, "type") === void 0 ? {} : { type: readStringField(captcha, "type") },
+        ...readStringField(captcha, "siteKey") === void 0 ? {} : { siteKey: readStringField(captcha, "siteKey") },
+        ...readStringField(captcha, "pageUrl") === void 0 ? {} : { pageUrl: readStringField(captcha, "pageUrl") }
+      }
+    },
+    ...readStringField(result, "token") === void 0 ? {} : { token: readStringField(result, "token") },
+    ...readBooleanField(result, "injected") === void 0 ? {} : { injected: readBooleanField(result, "injected") }
+  };
+}
+function formatInteractionDiffOutput(result) {
+  return {
+    ...readObjectField(result, "summary") === void 0 ? {} : { summary: readObjectField(result, "summary") },
+    ...readArrayField(result, "eventSequenceMismatches").length === 0 ? {} : { eventSequenceMismatches: readArrayField(result, "eventSequenceMismatches") },
+    ...readArrayField(result, "eventPropertyMismatches").length === 0 ? {} : { eventPropertyMismatches: readArrayField(result, "eventPropertyMismatches") },
+    ...readArrayField(result, "stateMismatches").length === 0 ? {} : { stateMismatches: readArrayField(result, "stateMismatches") },
+    ...readArrayField(result, "downstreamRequestMismatches").length === 0 ? {} : { downstreamRequestMismatches: readArrayField(result, "downstreamRequestMismatches") }
+  };
+}
+function formatInteractionReplayOutput(result) {
+  return {
+    ...readStringField(result, "traceId") === void 0 ? {} : { traceId: readStringField(result, "traceId") },
+    ...readNumberField(result, "replayedEventCount") === void 0 ? {} : { replayedEventCount: readNumberField(result, "replayedEventCount") },
+    ...readBooleanField(result, "success") === void 0 ? {} : { success: readBooleanField(result, "success") },
+    ...readStringField(result, "error") === void 0 ? {} : { error: readStringField(result, "error") }
+  };
+}
+function formatBodySummary(body) {
+  if (body === null || typeof body !== "object") {
+    return "unknown";
+  }
+  if (readBooleanField(body, "streaming") === true) {
+    return `streaming (${readStringField(body, "contentType") ?? "unknown"})`;
+  }
+  return `${formatBytes(readNumberField(body, "bytes"))} (${readStringField(body, "contentType") ?? "unknown"})`;
+}
+function formatBodyPreview(label, preview) {
+  const header = `${label} (${formatBytes(readNumberField(preview, "bytes"))}${readStringField(preview, "contentType") === void 0 ? "" : `, ${readStringField(preview, "contentType")}`}${readBooleanField(preview, "truncated") === true ? ", truncated" : ""}):`;
+  const data = readUnknownField(preview, "data");
+  if (data === void 0) {
+    return header;
+  }
+  return `${header}
+${indentLines(stringifyValue(data))}`;
+}
+function formatStorageEntry(entry) {
+  return `  ${padRight(readStringField(entry, "key") ?? "key", 18)} ${truncateInline(readStringField(entry, "value") ?? "", 80)}`;
+}
+function formatHeaderLine(header) {
+  return `  ${readStringField(header, "name") ?? "header"}: ${readStringField(header, "value") ?? ""}`;
+}
+function truncateDataShape(value, depth = 0) {
+  if (value === null || typeof value === "number" || typeof value === "boolean" || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value.length <= 200 ? value : `${value.slice(0, 200)}...${value.length} chars total`;
+  }
+  if (Array.isArray(value)) {
+    if (depth >= 4) {
+      return `... ${value.length} items`;
     }
-  };
-  if (input.cloudConfig === void 0) {
-    return base;
+    if (value.length > 3) {
+      return [
+        `... ${value.length} items, first 2 shown`,
+        truncateDataShape(value[0], depth + 1),
+        truncateDataShape(value[1], depth + 1)
+      ];
+    }
+    return value.map((entry) => truncateDataShape(entry, depth + 1));
   }
-  try {
-    const client = new OpensteerCloudClient(input.cloudConfig);
-    const session = await client.getSession(input.record.sessionId);
-    if (session.status === "closed") {
-      return {
-        ...base,
-        status: "closed",
-        ...session.region ?? session.runtimeRegion ? { region: session.region ?? session.runtimeRegion } : {}
-      };
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (depth >= 4) {
+      return `... ${entries.length} keys`;
     }
-    if (session.status === "failed") {
-      return {
-        ...base,
-        status: "stale"
-      };
+    return Object.fromEntries(
+      entries.map(([key, entry]) => [key, truncateDataShape(entry, depth + 1)])
+    );
+  }
+  return String(value);
+}
+function readArrayField(value, key) {
+  if (value === null || typeof value !== "object") {
+    return [];
+  }
+  const field = value[key];
+  return Array.isArray(field) ? field : [];
+}
+function readObjectField(value, key) {
+  if (value === null || typeof value !== "object") {
+    return void 0;
+  }
+  const field = value[key];
+  return field !== null && typeof field === "object" && !Array.isArray(field) ? field : void 0;
+}
+function readUnknownField(value, key) {
+  if (value === null || typeof value !== "object") {
+    return void 0;
+  }
+  return value[key];
+}
+function readStringField(value, key) {
+  if (value === null || typeof value !== "object") {
+    return void 0;
+  }
+  const field = value[key];
+  return typeof field === "string" ? field : void 0;
+}
+function readNumberField(value, key) {
+  if (value === null || typeof value !== "object") {
+    return void 0;
+  }
+  const field = value[key];
+  return typeof field === "number" ? field : void 0;
+}
+function readBooleanField(value, key) {
+  if (value === null || typeof value !== "object") {
+    return void 0;
+  }
+  const field = value[key];
+  return typeof field === "boolean" ? field : void 0;
+}
+function readStatus(value) {
+  const status = readNumberField(value, "status");
+  return status === void 0 ? "-" : String(status);
+}
+function findHeaderValue(headers, name) {
+  const normalized = name.toLowerCase();
+  for (const header of headers) {
+    if (readStringField(header, "name")?.toLowerCase() === normalized) {
+      return readStringField(header, "value");
     }
-    return {
-      ...base,
-      ...session.region ?? session.runtimeRegion ? { region: session.region ?? session.runtimeRegion } : {}
-    };
-  } catch {
-    return {
-      ...base,
-      status: "stale"
-    };
   }
+  return void 0;
 }
-function mapProviderSource(source) {
-  if (source === "explicit") {
-    return "flag";
+function formatBytes(bytes) {
+  if (bytes === void 0) {
+    return "unknown";
   }
-  return source;
+  return `${bytes.toLocaleString("en-US")} bytes`;
 }
-function formatLaneRow(input) {
-  const provider = input.provider.padEnd(7, " ");
-  const status = input.status.padEnd(9, " ");
-  const summary = input.summary.padEnd(16, " ");
-  return `${input.marker} ${provider} ${status} ${summary}${input.detail ?? ""}`.trimEnd();
+function summarizeCapture(records) {
+  const captures = new Set(
+    records.map((record) => readStringField(record, "capture")).filter((capture) => capture !== void 0)
+  );
+  return captures.size === 1 ? [...captures][0] : void 0;
+}
+function padRight(value, width) {
+  return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
+}
+function truncateInline(value, limit) {
+  return value.length <= limit ? value : `${value.slice(0, Math.max(0, limit - 18))}...${value.length} chars`;
+}
+function stringifyValue(value) {
+  return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+}
+function stringifyScalarLike(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function indentLines(value) {
+  return value.split("\n").map((line) => `  ${line}`).join("\n");
+}
+function renderJson(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
 }
 async function openBrowserUrl(url) {
   const command = resolveOpenBrowserCommand(url);
   await new Promise((resolve, reject) => {
     const child = spawn(command.executable, command.args, {
-      detached: process3.platform !== "win32",
+      detached: process4.platform !== "win32",
       stdio: "ignore"
     });
     child.once("error", reject);
@@ -295,15 +1649,15 @@ async function openBrowserUrl(url) {
   });
 }
 function resolveOpenBrowserCommand(url) {
-  if (process3.platform === "darwin") {
+  if (process4.platform === "darwin") {
     return {
       executable: "open",
       args: [url]
     };
   }
-  if (process3.platform === "win32" || isWsl()) {
+  if (process4.platform === "win32" || isWsl()) {
     return {
-      executable: process3.platform === "win32" ? "cmd" : "cmd.exe",
+      executable: process4.platform === "win32" ? "cmd" : "cmd.exe",
       args: ["/c", "start", "", url]
     };
   }
@@ -313,7 +1667,7 @@ function resolveOpenBrowserCommand(url) {
   };
 }
 function isWsl() {
-  return process3.platform === "linux" && (process3.env.WSL_DISTRO_NAME !== void 0 || os.release().toLowerCase().includes("microsoft"));
+  return process4.platform === "linux" && (process4.env.WSL_DISTRO_NAME !== void 0 || os.release().toLowerCase().includes("microsoft"));
 }
 
 // src/cli/record.ts
@@ -351,7 +1705,7 @@ async function runOpensteerRecordCommand(input) {
       workspace: input.workspace,
       startUrl: opened.url
     });
-    await mkdir(path.dirname(outputPath), { recursive: true });
+    await mkdir(path2.dirname(outputPath), { recursive: true });
     await writeFile(outputPath, script, "utf8");
     if (input.closeSession !== void 0) {
       await input.closeSession();
@@ -417,7 +1771,7 @@ async function runOpensteerCloudRecordCommand(input) {
     if (completed.result === void 0) {
       throw new Error("Cloud recording completed without a replay script.");
     }
-    await mkdir(path.dirname(outputPath), { recursive: true });
+    await mkdir(path2.dirname(outputPath), { recursive: true });
     await writeFile(outputPath, completed.result.script, "utf8");
     await runtime.close();
     closed = true;
@@ -433,166 +1787,385 @@ async function runOpensteerCloudRecordCommand(input) {
     }
   }
 }
-function resolveRecordOutputPath(input) {
-  if (input.outputPath !== void 0) {
-    return path.resolve(input.rootDir, input.outputPath);
+function resolveRecordOutputPath(input) {
+  if (input.outputPath !== void 0) {
+    return path2.resolve(input.rootDir, input.outputPath);
+  }
+  return path2.join(
+    resolveFilesystemWorkspacePath({
+      rootDir: input.rootDir,
+      workspace: input.workspace
+    }),
+    "recorded-flow.ts"
+  );
+}
+function createRecorderRuntimeAdapter(runtime) {
+  return {
+    addInitScript: (input) => runtime.addInitScript(input),
+    evaluate: async (input) => {
+      const output = await runtime.evaluate({
+        script: input.script,
+        ...input.pageRef === void 0 ? {} : { pageRef: input.pageRef }
+      });
+      return output.value;
+    },
+    listPages: async () => {
+      const output = await runtime.listPages();
+      return {
+        pages: output.pages.map((page) => ({
+          pageRef: page.pageRef,
+          url: page.url,
+          ...page.openerPageRef === void 0 ? {} : { openerPageRef: page.openerPageRef }
+        }))
+      };
+    }
+  };
+}
+function buildCloudRecordingSessionUrl(appBaseUrl, sessionId) {
+  return `${appBaseUrl}/browsers/${encodeURIComponent(sessionId)}`;
+}
+async function tryOpenCloudRecordingSessionUrl(input) {
+  try {
+    await input.openUrl(input.sessionUrl);
+  } catch {
+    input.stderr.write(
+      `Could not automatically open the cloud browser session. Open it manually: ${input.sessionUrl}
+`
+    );
+  }
+}
+async function resolveCloudRecordingSessionId(runtime) {
+  const info = await runtime.info();
+  if (typeof info.sessionId !== "string" || info.sessionId.length === 0) {
+    throw new Error("Cloud recording could not resolve the created session id.");
+  }
+  return info.sessionId;
+}
+async function waitForCloudRecordingCompletion(input) {
+  const pollIntervalMs = input.pollIntervalMs ?? 1e3;
+  for (; ; ) {
+    const state = await input.client.getSessionRecording(input.sessionId);
+    if (state.status === "completed") {
+      return state;
+    }
+    if (state.status === "failed") {
+      throw new Error(state.error ?? "Cloud recording failed.");
+    }
+    await input.sleep(pollIntervalMs);
+  }
+}
+function formatRecordedAction(action) {
+  const time = new Date(action.timestamp).toISOString().slice(11, 19);
+  switch (action.kind) {
+    case "click":
+      return `[${time}] click ${action.pageId} -> ${action.selector ?? "<unknown>"}`;
+    case "dblclick":
+      return `[${time}] dblclick ${action.pageId} -> ${action.selector ?? "<unknown>"}`;
+    case "type":
+      return `[${time}] type ${action.pageId} -> ${action.selector ?? "<unknown>"} -> ${JSON.stringify(action.detail.text)}`;
+    case "keypress":
+      return `[${time}] keypress ${action.pageId} -> ${action.detail.key}`;
+    case "scroll":
+      return `[${time}] scroll ${action.pageId} -> (${String(action.detail.deltaX)}, ${String(action.detail.deltaY)})`;
+    case "select-option":
+      return `[${time}] select ${action.pageId} -> ${action.selector ?? "<unknown>"} -> ${JSON.stringify(action.detail.value)}`;
+    case "navigate":
+      return `[${time}] navigate ${action.pageId} -> ${action.detail.url}`;
+    case "new-tab":
+      return `[${time}] new-tab ${action.pageId} -> ${action.detail.initialUrl}`;
+    case "close-tab":
+      return `[${time}] close-tab ${action.pageId}`;
+    case "switch-tab":
+      return `[${time}] switch-tab -> ${action.detail.toPageId}`;
+    case "go-back":
+      return `[${time}] go-back ${action.pageId}`;
+    case "go-forward":
+      return `[${time}] go-forward ${action.pageId}`;
+    case "reload":
+      return `[${time}] reload ${action.pageId}`;
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+var OPENSTEER_GITHUB_SOURCE = "steerlabs/opensteer";
+function createOpensteerSkillsInvocation(input) {
+  const cliArgs = ["add", input.skillSourcePath];
+  if (input.options.all === true) {
+    cliArgs.push("--all");
+  } else {
+    const selectedSkills = resolveSelectedSkills(input.options);
+    for (const skill of selectedSkills) {
+      cliArgs.push("--skill", skill);
+    }
+  }
+  for (const agent of input.options.agents ?? []) {
+    cliArgs.push("--agent", agent);
+  }
+  if (input.options.global === true) {
+    cliArgs.push("--global");
+  }
+  if (input.options.yes === true) {
+    cliArgs.push("--yes");
+  }
+  if (input.options.copy === true) {
+    cliArgs.push("--copy");
+  }
+  if (input.options.list === true) {
+    cliArgs.push("--list");
+  }
+  return {
+    cliPath: input.skillsCliPath,
+    cliArgs
+  };
+}
+function resolveOpensteerSkillsCliPath() {
+  const require2 = createRequire(import.meta.url);
+  const skillsPackagePath = require2.resolve("skills/package.json");
+  const skillsPackageDir = path2.dirname(skillsPackagePath);
+  const cliPath = path2.join(skillsPackageDir, "bin", "cli.mjs");
+  if (!existsSync(cliPath)) {
+    throw new Error(`skills CLI entrypoint was not found at "${cliPath}".`);
+  }
+  return cliPath;
+}
+function resolveOpensteerLocalSkillSourcePath() {
+  let ancestor = path2.dirname(fileURLToPath(import.meta.url));
+  for (let index = 0; index < 6; index += 1) {
+    const candidate = path2.join(ancestor, "skills");
+    const skillManifest = path2.join(candidate, "opensteer", "SKILL.md");
+    if (existsSync(skillManifest)) {
+      return candidate;
+    }
+    ancestor = path2.resolve(ancestor, "..");
+  }
+  throw new Error("Unable to find the packaged Opensteer skill source directory.");
+}
+async function checkOpensteerGitHubReachable() {
+  try {
+    const response = await fetch(`https://github.com/${OPENSTEER_GITHUB_SOURCE}`, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(3e3),
+      redirect: "manual"
+    });
+    return response.status < 500;
+  } catch {
+    return false;
+  }
+}
+async function runOpensteerSkillsInstaller(options = {}, overrideDeps = {}) {
+  const deps = {
+    resolveSkillsCliPath: resolveOpensteerSkillsCliPath,
+    resolveLocalSkillSourcePath: resolveOpensteerLocalSkillSourcePath,
+    checkGitHubReachable: checkOpensteerGitHubReachable,
+    spawnInvocation: spawnOpensteerSkillsInvocation,
+    ...overrideDeps
+  };
+  const useGitHub = await deps.checkGitHubReachable();
+  const skillSourcePath = useGitHub ? OPENSTEER_GITHUB_SOURCE : deps.resolveLocalSkillSourcePath();
+  const invocation = createOpensteerSkillsInvocation({
+    options,
+    skillsCliPath: deps.resolveSkillsCliPath(),
+    skillSourcePath
+  });
+  return deps.spawnInvocation(invocation);
+}
+async function spawnOpensteerSkillsInvocation(invocation) {
+  return await new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(process.execPath, [invocation.cliPath, ...invocation.cliArgs], {
+      cwd: process.cwd(),
+      env: process.env,
+      stdio: "inherit"
+    });
+    child.once("error", (error) => {
+      rejectPromise(error);
+    });
+    child.once("exit", (code) => {
+      resolvePromise(typeof code === "number" ? code : 1);
+    });
+  });
+}
+function resolveSelectedSkills(options) {
+  if (options.skills !== void 0 && options.skills.length > 0) {
+    return options.skills;
   }
-  return path.join(
-    resolveFilesystemWorkspacePath({
-      rootDir: input.rootDir,
-      workspace: input.workspace
-    }),
-    "recorded-flow.ts"
-  );
+  if (options.list === true) {
+    return [];
+  }
+  return ["opensteer"];
 }
-function createRecorderRuntimeAdapter(runtime) {
-  return {
-    addInitScript: (input) => runtime.addInitScript(input),
-    evaluate: async (input) => {
-      const output = await runtime.evaluate({
-        script: input.script,
-        ...input.pageRef === void 0 ? {} : { pageRef: input.pageRef }
-      });
-      return output.value;
+async function collectOpensteerStatus(input) {
+  const output = {
+    provider: {
+      current: input.provider.mode,
+      source: mapProviderSource(input.provider.source),
+      ...input.cloudConfig === void 0 ? {} : { cloudBaseUrl: input.cloudConfig.baseUrl }
     },
-    listPages: async () => {
-      const output = await runtime.listPages();
-      return {
-        pages: output.pages.map((page) => ({
-          pageRef: page.pageRef,
-          url: page.url,
-          ...page.openerPageRef === void 0 ? {} : { openerPageRef: page.openerPageRef }
-        }))
-      };
+    ...input.workspace === void 0 ? {} : { workspace: input.workspace }
+  };
+  if (input.workspace === void 0) {
+    return output;
+  }
+  const rootPath = resolveFilesystemWorkspacePath({
+    rootDir: input.rootDir,
+    workspace: input.workspace
+  });
+  const localRecord = await readWorkspaceLocalRecord(rootPath);
+  const cloudRecord = await readWorkspaceCloudRecord(rootPath);
+  return {
+    ...output,
+    rootPath,
+    lanes: {
+      local: describeLocalLane(localRecord, input.provider.mode === "local"),
+      cloud: await describeCloudLane({
+        record: cloudRecord,
+        current: input.provider.mode === "cloud",
+        cloudConfig: input.cloudConfig
+      })
     }
   };
 }
-function buildCloudRecordingSessionUrl(appBaseUrl, sessionId) {
-  return `${appBaseUrl}/browsers/${encodeURIComponent(sessionId)}`;
-}
-async function tryOpenCloudRecordingSessionUrl(input) {
-  try {
-    await input.openUrl(input.sessionUrl);
-  } catch {
-    input.stderr.write(
-      `Could not automatically open the cloud browser session. Open it manually: ${input.sessionUrl}
-`
+function renderOpensteerStatus(status) {
+  const lines = [
+    "Provider resolution",
+    `  current: ${status.provider.current}`,
+    `  source: ${status.provider.source}`
+  ];
+  if (status.provider.cloudBaseUrl !== void 0) {
+    lines.push(`  control api: ${status.provider.cloudBaseUrl}`);
+  }
+  if (status.workspace !== void 0) {
+    lines.push(`  workspace: ${status.workspace}`);
+  }
+  if (status.lanes === void 0) {
+    return `${lines.join("\n")}
+`;
+  }
+  lines.push("", "Live sessions");
+  for (const lane of [status.lanes.local, status.lanes.cloud]) {
+    lines.push(
+      formatLaneRow({
+        marker: lane.current ? "*" : " ",
+        provider: lane.provider,
+        status: lane.status,
+        summary: lane.summary ?? "none",
+        detail: lane.detail
+      })
     );
   }
+  return `${lines.join("\n")}
+`;
 }
-async function resolveCloudRecordingSessionId(runtime) {
-  const info = await runtime.info();
-  if (typeof info.sessionId !== "string" || info.sessionId.length === 0) {
-    throw new Error("Cloud recording could not resolve the created session id.");
+async function readWorkspaceLocalRecord(rootPath) {
+  if (!await pathExists(rootPath)) {
+    return void 0;
   }
-  return info.sessionId;
+  return readPersistedLocalBrowserSessionRecord(rootPath);
 }
-async function waitForCloudRecordingCompletion(input) {
-  const pollIntervalMs = input.pollIntervalMs ?? 1e3;
-  for (; ; ) {
-    const state = await input.client.getSessionRecording(input.sessionId);
-    if (state.status === "completed") {
-      return state;
-    }
-    if (state.status === "failed") {
-      throw new Error(state.error ?? "Cloud recording failed.");
-    }
-    await input.sleep(pollIntervalMs);
+async function readWorkspaceCloudRecord(rootPath) {
+  if (!await pathExists(rootPath)) {
+    return void 0;
   }
+  return readPersistedCloudSessionRecord(rootPath);
 }
-function formatRecordedAction(action) {
-  const time = new Date(action.timestamp).toISOString().slice(11, 19);
-  switch (action.kind) {
-    case "click":
-      return `[${time}] click ${action.pageId} -> ${action.selector ?? "<unknown>"}`;
-    case "dblclick":
-      return `[${time}] dblclick ${action.pageId} -> ${action.selector ?? "<unknown>"}`;
-    case "type":
-      return `[${time}] type ${action.pageId} -> ${action.selector ?? "<unknown>"} -> ${JSON.stringify(action.detail.text)}`;
-    case "keypress":
-      return `[${time}] keypress ${action.pageId} -> ${action.detail.key}`;
-    case "scroll":
-      return `[${time}] scroll ${action.pageId} -> (${String(action.detail.deltaX)}, ${String(action.detail.deltaY)})`;
-    case "select-option":
-      return `[${time}] select ${action.pageId} -> ${action.selector ?? "<unknown>"} -> ${JSON.stringify(action.detail.value)}`;
-    case "navigate":
-      return `[${time}] navigate ${action.pageId} -> ${action.detail.url}`;
-    case "new-tab":
-      return `[${time}] new-tab ${action.pageId} -> ${action.detail.initialUrl}`;
-    case "close-tab":
-      return `[${time}] close-tab ${action.pageId}`;
-    case "switch-tab":
-      return `[${time}] switch-tab -> ${action.detail.toPageId}`;
-    case "go-back":
-      return `[${time}] go-back ${action.pageId}`;
-    case "go-forward":
-      return `[${time}] go-forward ${action.pageId}`;
-    case "reload":
-      return `[${time}] reload ${action.pageId}`;
+function describeLocalLane(record, current) {
+  if (record === void 0 || !isProcessRunning(record.pid)) {
+    return {
+      provider: "local",
+      status: "idle",
+      current,
+      summary: "none"
+    };
   }
+  const browser = record.executablePath ? path2.basename(record.executablePath).replace(/\.[A-Za-z0-9]+$/u, "") : void 0;
+  return {
+    provider: "local",
+    status: "active",
+    current,
+    summary: `PID ${String(record.pid)}`,
+    detail: browser ?? record.engine,
+    pid: record.pid,
+    engine: record.engine,
+    ...browser === void 0 ? {} : { browser }
+  };
 }
-function delay(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
+async function describeCloudLane(input) {
+  if (input.record === void 0) {
+    return {
+      provider: "cloud",
+      status: "idle",
+      current: input.current,
+      summary: "none"
+    };
+  }
+  const base = {
+    provider: "cloud",
+    status: "connected",
+    current: input.current,
+    summary: input.record.sessionId,
+    sessionId: input.record.sessionId,
+    ...input.cloudConfig === void 0 ? {} : {
+      detail: input.cloudConfig.baseUrl,
+      baseUrl: input.cloudConfig.baseUrl
+    }
+  };
+  if (input.cloudConfig === void 0) {
+    return base;
+  }
+  try {
+    const client = new OpensteerCloudClient(input.cloudConfig);
+    const session = await client.getSession(input.record.sessionId);
+    if (session.status === "closed") {
+      return {
+        ...base,
+        status: "closed",
+        ...session.region ?? session.runtimeRegion ? { region: session.region ?? session.runtimeRegion } : {}
+      };
+    }
+    if (session.status === "failed") {
+      return {
+        ...base,
+        status: "stale"
+      };
+    }
+    return {
+      ...base,
+      ...session.region ?? session.runtimeRegion ? { region: session.region ?? session.runtimeRegion } : {}
+    };
+  } catch {
+    return {
+      ...base,
+      status: "stale"
+    };
+  }
 }
-
-// src/cli/bin.ts
-var OPERATION_ALIASES = /* @__PURE__ */ new Map([
-  ["open", "session.open"],
-  ["goto", "page.goto"],
-  ["snapshot", "page.snapshot"],
-  ["click", "dom.click"],
-  ["hover", "dom.hover"],
-  ["input", "dom.input"],
-  ["scroll", "dom.scroll"],
-  ["extract", "dom.extract"],
-  ["network query", "network.query"],
-  ["network tag", "network.tag"],
-  ["network clear", "network.clear"],
-  ["network minimize", "network.minimize"],
-  ["network diff", "network.diff"],
-  ["network probe", "network.probe"],
-  ["reverse discover", "reverse.discover"],
-  ["reverse query", "reverse.query"],
-  ["reverse package create", "reverse.package.create"],
-  ["reverse package run", "reverse.package.run"],
-  ["reverse export", "reverse.export"],
-  ["reverse report", "reverse.report"],
-  ["reverse package get", "reverse.package.get"],
-  ["reverse package list", "reverse.package.list"],
-  ["reverse package patch", "reverse.package.patch"],
-  ["interaction capture", "interaction.capture"],
-  ["interaction get", "interaction.get"],
-  ["interaction diff", "interaction.diff"],
-  ["interaction replay", "interaction.replay"],
-  ["artifact read", "artifact.read"],
-  ["scripts capture", "scripts.capture"],
-  ["scripts beautify", "scripts.beautify"],
-  ["scripts deobfuscate", "scripts.deobfuscate"],
-  ["scripts sandbox", "scripts.sandbox"],
-  ["captcha solve", "captcha.solve"],
-  ["inspect cookies", "inspect.cookies"],
-  ["inspect storage", "inspect.storage"],
-  ["request raw", "request.raw"],
-  ["request-plan infer", "request-plan.infer"],
-  ["request-plan write", "request-plan.write"],
-  ["request-plan get", "request-plan.get"],
-  ["request-plan list", "request-plan.list"],
-  ["recipe write", "recipe.write"],
-  ["recipe get", "recipe.get"],
-  ["recipe list", "recipe.list"],
-  ["recipe run", "recipe.run"],
-  ["auth-recipe write", "auth-recipe.write"],
-  ["auth-recipe get", "auth-recipe.get"],
-  ["auth-recipe list", "auth-recipe.list"],
-  ["auth-recipe run", "auth-recipe.run"],
-  ["request execute", "request.execute"],
-  ["computer execute", "computer.execute"],
-  ["close", "session.close"]
-]);
+function mapProviderSource(source) {
+  if (source === "explicit") {
+    return "flag";
+  }
+  return source;
+}
+function formatLaneRow(input) {
+  const provider = input.provider.padEnd(7, " ");
+  const status = input.status.padEnd(9, " ");
+  const summary = input.summary.padEnd(16, " ");
+  return `${input.marker} ${provider} ${status} ${summary}${input.detail ?? ""}`.trimEnd();
+}
+
+// src/cli/bin.ts
+var emitProcessWarning = process4.emitWarning.bind(process4);
+process4.emitWarning = ((warning, ...args) => {
+  const name = warning instanceof Error ? warning.name : typeof args[0] === "string" ? args[0] : void 0;
+  const message = warning instanceof Error ? warning.message : warning;
+  if (name === "ExperimentalWarning" && typeof message === "string" && message.includes("SQLite is an experimental feature")) {
+    return;
+  }
+  return emitProcessWarning(warning, ...args);
+});
 async function main() {
-  const argv = process3.argv.slice(2);
+  const argv = process4.argv.slice(2);
   const bootstrapAction = resolveCliBootstrapAction(argv);
   if (bootstrapAction === "version") {
     printVersion();
@@ -602,7 +2175,7 @@ async function main() {
     printHelp();
     return;
   }
-  await loadCliEnvironment(process3.cwd());
+  await loadCliEnvironment(process4.cwd());
   const parsed = parseCommandLine(argv);
   if (parsed.command[0] === "browser") {
     await handleBrowserCommand(parsed);
@@ -619,7 +2192,7 @@ async function main() {
       list: parsed.options.list === true
     });
     if (exitCode !== 0) {
-      process3.exitCode = exitCode;
+      process4.exitCode = exitCode;
     }
     return;
   }
@@ -631,12 +2204,14 @@ async function main() {
     await handleRecordCommandEntry(parsed);
     return;
   }
-  const operation = parsed.command[0] === "run" ? parsed.rest[0] : resolveOperation(parsed.command);
+  const operation = resolveOperation(parsed.command);
   if (!operation) {
     throw new Error(`Unknown command: ${parsed.command.join(" ")}`);
   }
   if (parsed.options.workspace === void 0) {
-    throw new Error('Stateful commands require "--workspace <id>".');
+    throw new Error(
+      'Stateful commands require "--workspace <id>" or OPENSTEER_WORKSPACE.'
+    );
   }
   const engineName = resolveCliEngineName(parsed);
   const provider = resolveCliProvider(parsed);
@@ -644,34 +2219,7 @@ async function main() {
   assertCloudCliOptionsMatchProvider(parsed, provider.mode);
   const runtimeProvider = buildCliRuntimeProvider(parsed, provider.mode);
   if (operation === "session.close") {
-    if (provider.mode === "cloud") {
-      const runtime2 = createOpensteerSemanticRuntime({
-        ...runtimeProvider === void 0 ? {} : { provider: runtimeProvider },
-        engine: engineName,
-        runtimeOptions: {
-          workspace: parsed.options.workspace,
-          rootDir: process3.cwd(),
-          browser: "persistent",
-          ...parsed.options.launch === void 0 ? {} : { launch: parsed.options.launch },
-          ...parsed.options.context === void 0 ? {} : { context: parsed.options.context }
-        }
-      });
-      const result2 = await runtime2.close();
-      process3.stdout.write(`${JSON.stringify(result2, null, 2)}
-`);
-      return;
-    }
-    const manager = new OpensteerBrowserManager({
-      rootDir: process3.cwd(),
-      workspace: parsed.options.workspace,
-      engineName,
-      browser: "persistent",
-      ...parsed.options.launch === void 0 ? {} : { launch: parsed.options.launch },
-      ...parsed.options.context === void 0 ? {} : { context: parsed.options.context }
-    });
-    await manager.close();
-    process3.stdout.write(`${JSON.stringify({ closed: true }, null, 2)}
-`);
+    await handleCloseCommand(parsed, engineName, provider.mode, runtimeProvider);
     return;
   }
   const runtime = createOpensteerSemanticRuntime({
@@ -679,27 +2227,25 @@ async function main() {
     engine: engineName,
     runtimeOptions: {
       workspace: parsed.options.workspace,
-      rootDir: process3.cwd(),
+      rootDir: process4.cwd(),
       ...parsed.options.browser === void 0 ? {} : { browser: parsed.options.browser },
       ...parsed.options.launch === void 0 ? {} : { launch: parsed.options.launch },
       ...parsed.options.context === void 0 ? {} : { context: parsed.options.context }
     }
   });
   let result;
+  let renderOperation = operation;
   try {
-    result = await dispatchSemanticOperation(
-      runtime,
-      operation,
-      buildOperationInput(
-        operation,
-        parsed.command[0] === "run" ? { ...parsed, rest: parsed.rest.slice(1) } : parsed
-      )
-    );
+    const input = await buildOperationInput(operation, parsed, runtime);
+    result = await dispatchSemanticOperation(runtime, operation, input);
+    if (parsed.command[0] === "tab" && operation !== "page.list") {
+      renderOperation = "page.list";
+      result = await runtime.listPages({});
+    }
+    process4.stdout.write(renderOperationOutput(renderOperation, result, input));
   } finally {
     await runtime.disconnect().catch(() => void 0);
   }
-  process3.stdout.write(`${JSON.stringify(result, null, 2)}
-`);
 }
 async function handleBrowserCommand(parsed) {
   const subcommand = parsed.command[1];
@@ -707,7 +2253,7 @@ async function handleBrowserCommand(parsed) {
     const result = await discoverLocalCdpBrowsers({
       ...parsed.options.launch?.timeoutMs === void 0 ? {} : { timeoutMs: parsed.options.launch.timeoutMs }
     });
-    process3.stdout.write(`${JSON.stringify(result, null, 2)}
+    process4.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
     return;
   }
@@ -723,16 +2269,18 @@ async function handleBrowserCommand(parsed) {
       ...parsed.options.attachHeaders === void 0 ? {} : { headers: parsed.options.attachHeaders },
       ...parsed.options.launch?.timeoutMs === void 0 ? {} : { timeoutMs: parsed.options.launch.timeoutMs }
     });
-    process3.stdout.write(`${JSON.stringify(result, null, 2)}
+    process4.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
     return;
   }
   if (parsed.options.workspace === void 0) {
-    throw new Error('Browser workspace commands require "--workspace <id>".');
+    throw new Error(
+      'Browser workspace commands require "--workspace <id>" or OPENSTEER_WORKSPACE.'
+    );
   }
   const engineName = resolveCliEngineName(parsed);
   const manager = new OpensteerBrowserManager({
-    rootDir: process3.cwd(),
+    rootDir: process4.cwd(),
     workspace: parsed.options.workspace,
     engineName,
     browser: "persistent",
@@ -742,7 +2290,7 @@ async function handleBrowserCommand(parsed) {
   switch (subcommand) {
     case "status": {
       const result = await manager.status();
-      process3.stdout.write(`${JSON.stringify(result, null, 2)}
+      process4.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
       return;
     }
@@ -755,393 +2303,147 @@ async function handleBrowserCommand(parsed) {
         sourceUserDataDir,
         ...parsed.options.sourceProfileDirectory === void 0 ? {} : { sourceProfileDirectory: parsed.options.sourceProfileDirectory }
       });
-      process3.stdout.write(`${JSON.stringify(result, null, 2)}
+      process4.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
       return;
     }
     case "reset": {
       await manager.reset();
-      process3.stdout.write(`${JSON.stringify({ reset: true }, null, 2)}
+      process4.stdout.write(`${JSON.stringify({ reset: true }, null, 2)}
 `);
       return;
     }
     case "delete": {
       await manager.delete();
-      process3.stdout.write(`${JSON.stringify({ deleted: true }, null, 2)}
+      process4.stdout.write(`${JSON.stringify({ deleted: true }, null, 2)}
 `);
       return;
     }
     default:
-      throw new Error(`Unknown browser command: ${parsed.command.join(" ")}`);
-  }
-}
-async function handleRecordCommandEntry(parsed) {
-  if (parsed.options.workspace === void 0) {
-    throw new Error('record requires "--workspace <id>".');
-  }
-  const url = parsed.options.url ?? parsed.rest[0];
-  if (url === void 0) {
-    throw new Error('record requires "--url <value>" or a positional URL.');
-  }
-  const provider = resolveCliProvider(parsed);
-  assertCloudCliOptionsMatchProvider(parsed, provider.mode);
-  const engineName = resolveCliEngineName(parsed);
-  if (engineName !== "playwright") {
-    throw new Error("record requires engine=playwright.");
-  }
-  const rootDir = process3.cwd();
-  const recordBrowser = parsed.options.browser;
-  if (provider.mode === "cloud") {
-    if (typeof recordBrowser === "object") {
-      throw new Error('record does not support browser.mode="attach".');
-    }
-    const runtimeProvider = buildCliRuntimeProvider(parsed, provider.mode);
-    const runtimeConfig = resolveOpensteerRuntimeConfig({
-      ...runtimeProvider === void 0 ? {} : { provider: runtimeProvider },
-      environment: process3.env
-    });
-    await runOpensteerCloudRecordCommand({
-      cloudConfig: runtimeConfig.cloud,
-      workspace: parsed.options.workspace,
-      url,
-      rootDir,
-      ...recordBrowser === void 0 ? {} : { browser: recordBrowser },
-      ...parsed.options.launch === void 0 ? {} : { launch: parsed.options.launch },
-      ...parsed.options.context === void 0 ? {} : { context: parsed.options.context },
-      ...parsed.options.output === void 0 ? {} : { outputPath: parsed.options.output }
-    });
-    return;
-  }
-  if (parsed.options.launch?.headless === true) {
-    throw new Error('record requires a headed browser. Remove "--headless true".');
-  }
-  if (recordBrowser !== void 0 && recordBrowser !== "persistent") {
-    throw new Error('record only supports "--browser persistent".');
-  }
-  const launch = {
-    ...parsed.options.launch ?? {},
-    headless: false
-  };
-  const browserManager = new OpensteerBrowserManager({
-    rootDir,
-    workspace: parsed.options.workspace,
-    engineName,
-    browser: "persistent",
-    launch,
-    ...parsed.options.context === void 0 ? {} : { context: parsed.options.context }
-  });
-  const runtime = createOpensteerSemanticRuntime({
-    provider: {
-      mode: "local"
-    },
-    engine: engineName,
-    runtimeOptions: {
-      rootPath: browserManager.rootPath,
-      cleanupRootOnClose: browserManager.cleanupRootOnDisconnect,
-      workspace: parsed.options.workspace,
-      browser: "persistent",
-      launch,
-      ...parsed.options.context === void 0 ? {} : { context: parsed.options.context }
-    }
-  });
-  await runOpensteerRecordCommand({
-    runtime,
-    closeSession: () => closeOwnedLocalBrowserSession(runtime, browserManager),
-    workspace: parsed.options.workspace,
-    url,
-    rootDir,
-    ...parsed.options.output === void 0 ? {} : { outputPath: parsed.options.output }
-  });
-}
-async function closeOwnedLocalBrowserSession(runtime, browserManager) {
-  let closeError;
-  try {
-    await runtime.close();
-  } catch (error) {
-    closeError = error;
-  }
-  try {
-    await browserManager.close();
-  } catch (error) {
-    closeError ??= error;
-  }
-  if (closeError !== void 0) {
-    throw closeError;
-  }
-}
-function buildOperationInput(operation, parsed) {
-  if (parsed.options.inputJson !== void 0) {
-    return parsed.options.inputJson;
-  }
-  switch (operation) {
-    case "session.open":
-      return {
-        ...parsed.rest[0] === void 0 ? {} : { url: parsed.rest[0] },
-        ...parsed.options.workspace === void 0 ? {} : { workspace: parsed.options.workspace },
-        ...parsed.options.browser === void 0 ? {} : { browser: parsed.options.browser },
-        ...parsed.options.launch === void 0 ? {} : { launch: parsed.options.launch },
-        ...parsed.options.context === void 0 ? {} : { context: parsed.options.context }
-      };
-    case "page.goto":
-      if (parsed.rest[0] === void 0) {
-        throw new Error("goto requires a URL.");
-      }
-      return {
-        url: parsed.rest[0]
-      };
-    case "page.snapshot":
-      return parsed.rest[0] === void 0 ? {} : { mode: parsed.rest[0] };
-    case "dom.click":
-    case "dom.hover":
-      return normalizeTargetInput(parsed, {});
-    case "dom.input":
-      if (parsed.options.text === void 0) {
-        throw new Error('input requires "--text <value>".');
-      }
-      return {
-        ...normalizeTargetInput(parsed, {}),
-        text: parsed.options.text,
-        ...parsed.options.pressEnter === void 0 ? {} : { pressEnter: parsed.options.pressEnter }
-      };
-    case "dom.scroll":
-      if (parsed.options.direction === void 0 || parsed.options.amount === void 0) {
-        throw new Error('scroll requires "--direction" and "--amount".');
-      }
-      return {
-        ...normalizeTargetInput(parsed, {}),
-        direction: parsed.options.direction,
-        amount: parsed.options.amount
-      };
-    case "dom.extract":
-      if (parsed.options.description === void 0) {
-        throw new Error('extract requires "--description <text>".');
-      }
-      return {
-        description: parsed.options.description,
-        ...parsed.options.schemaJson === void 0 ? {} : { schema: parsed.options.schemaJson }
-      };
-    case "session.close":
-      return {};
-    default:
-      return {};
-  }
-}
-function normalizeTargetInput(parsed, input) {
-  const hasElement = parsed.options.element !== void 0;
-  const hasSelector = parsed.options.selector !== void 0;
-  const hasDescription = parsed.options.description !== void 0;
-  const selected = Number(hasElement) + Number(hasSelector) + Number(hasDescription);
-  if (selected !== 1) {
-    throw new Error('Specify exactly one of "--element", "--selector", or "--description".');
-  }
-  return {
-    ...input,
-    target: hasElement ? { kind: "element", element: parsed.options.element } : hasSelector ? { kind: "selector", selector: parsed.options.selector } : { kind: "description", description: parsed.options.description }
-  };
-}
-function resolveOperation(command) {
-  for (let length = Math.min(3, command.length); length >= 1; length -= 1) {
-    const key = command.slice(0, length).join(" ");
-    const operation = OPERATION_ALIASES.get(key);
-    if (operation) {
-      return operation;
-    }
-  }
-  return void 0;
-}
-var CLI_OPTION_SPECS = {
-  workspace: { kind: "value" },
-  url: { kind: "value" },
-  output: { kind: "value" },
-  engine: { kind: "value" },
-  provider: { kind: "value" },
-  "cloud-base-url": { kind: "value" },
-  "cloud-api-key": { kind: "value" },
-  "cloud-app-base-url": { kind: "value" },
-  "cloud-profile-id": { kind: "value" },
-  "cloud-profile-reuse-if-active": { kind: "boolean" },
-  json: { kind: "boolean" },
-  agent: { kind: "value", multiple: true },
-  skill: { kind: "value", multiple: true },
-  global: { kind: "boolean" },
-  yes: { kind: "boolean" },
-  copy: { kind: "boolean" },
-  all: { kind: "boolean" },
-  list: { kind: "boolean" },
-  browser: { kind: "value" },
-  "attach-endpoint": { kind: "value" },
-  "attach-header": { kind: "value", multiple: true },
-  "fresh-tab": { kind: "boolean" },
-  headless: { kind: "boolean" },
-  "executable-path": { kind: "value" },
-  arg: { kind: "value", multiple: true },
-  "timeout-ms": { kind: "value" },
-  "context-json": { kind: "value" },
-  "input-json": { kind: "value" },
-  "schema-json": { kind: "value" },
-  "source-user-data-dir": { kind: "value" },
-  "source-profile-directory": { kind: "value" },
-  selector: { kind: "value" },
-  description: { kind: "value" },
-  element: { kind: "value" },
-  text: { kind: "value" },
-  "press-enter": { kind: "boolean" },
-  direction: { kind: "value" },
-  amount: { kind: "value" }
-};
-function parseCommandLine(argv) {
-  const leadingTokens = [];
-  let index = 0;
-  while (index < argv.length && !argv[index].startsWith("--")) {
-    leadingTokens.push(argv[index]);
-    index += 1;
-  }
-  const commandLength = resolveCommandLength(leadingTokens);
-  const commandTokens = leadingTokens.slice(0, commandLength);
-  const rest = leadingTokens.slice(commandLength);
-  const rawOptions = /* @__PURE__ */ new Map();
-  while (index < argv.length) {
-    const token = argv[index];
-    if (token === "--") {
-      rest.push(...argv.slice(index + 1));
-      break;
-    }
-    if (!token.startsWith("--")) {
-      rest.push(token);
-      index += 1;
-      continue;
-    }
-    const separator = token.indexOf("=");
-    const key = token.slice(2, separator === -1 ? void 0 : separator);
-    const spec = CLI_OPTION_SPECS[key];
-    if (spec === void 0) {
-      throw new Error(`Unknown option: --${key}.`);
-    }
-    if (separator !== -1) {
-      const value = token.slice(separator + 1);
-      rawOptions.set(key, [...rawOptions.get(key) ?? [], value]);
-      index += 1;
-      continue;
-    }
-    const next = argv[index + 1];
-    if (spec.kind === "boolean") {
-      if (next === void 0 || next.startsWith("--")) {
-        rawOptions.set(key, [...rawOptions.get(key) ?? [], "true"]);
-        index += 1;
-        continue;
-      }
-      rawOptions.set(key, [...rawOptions.get(key) ?? [], next]);
-      index += 2;
-      continue;
-    }
-    if (next === void 0 || next.startsWith("--")) {
-      throw new Error(
-        `Option "--${key}" requires a value.${next?.startsWith("--") === true ? ` Use "--${key}=<value>" when the value begins with "--".` : ``}`
-      );
+      throw new Error(`Unknown browser command: ${parsed.command.join(" ")}`);
+  }
+}
+async function handleCloseCommand(parsed, engineName, providerMode, runtimeProvider) {
+  if (providerMode === "cloud") {
+    const runtime = createOpensteerSemanticRuntime({
+      ...runtimeProvider === void 0 ? {} : { provider: runtimeProvider },
+      engine: engineName,
+      runtimeOptions: {
+        workspace: parsed.options.workspace,
+        rootDir: process4.cwd(),
+        browser: "persistent",
+        ...parsed.options.launch === void 0 ? {} : { launch: parsed.options.launch },
+        ...parsed.options.context === void 0 ? {} : { context: parsed.options.context }
+      }
+    });
+    const result = await runtime.close();
+    process4.stdout.write(renderOperationOutput("session.close", result));
+    return;
+  }
+  const manager = new OpensteerBrowserManager({
+    rootDir: process4.cwd(),
+    workspace: parsed.options.workspace,
+    engineName,
+    browser: "persistent",
+    ...parsed.options.launch === void 0 ? {} : { launch: parsed.options.launch },
+    ...parsed.options.context === void 0 ? {} : { context: parsed.options.context }
+  });
+  await manager.close();
+  process4.stdout.write(renderOperationOutput("session.close", { closed: true }));
+}
+async function handleRecordCommandEntry(parsed) {
+  if (parsed.options.workspace === void 0) {
+    throw new Error('record requires "--workspace <id>" or OPENSTEER_WORKSPACE.');
+  }
+  const url = parsed.options.url ?? parsed.rest[0];
+  if (url === void 0) {
+    throw new Error('record requires "--url <value>" or a positional URL.');
+  }
+  const provider = resolveCliProvider(parsed);
+  assertCloudCliOptionsMatchProvider(parsed, provider.mode);
+  const engineName = resolveCliEngineName(parsed);
+  if (engineName !== "playwright") {
+    throw new Error("record requires engine=playwright.");
+  }
+  const rootDir = process4.cwd();
+  const recordBrowser = parsed.options.browser;
+  if (provider.mode === "cloud") {
+    if (typeof recordBrowser === "object") {
+      throw new Error('record does not support browser.mode="attach".');
     }
-    rawOptions.set(key, [...rawOptions.get(key) ?? [], next]);
-    index += 2;
+    const runtimeProvider = buildCliRuntimeProvider(parsed, provider.mode);
+    const runtimeConfig = resolveOpensteerRuntimeConfig({
+      ...runtimeProvider === void 0 ? {} : { provider: runtimeProvider },
+      environment: process4.env
+    });
+    await runOpensteerCloudRecordCommand({
+      cloudConfig: runtimeConfig.cloud,
+      workspace: parsed.options.workspace,
+      url,
+      rootDir,
+      ...recordBrowser === void 0 ? {} : { browser: recordBrowser },
+      ...parsed.options.launch === void 0 ? {} : { launch: parsed.options.launch },
+      ...parsed.options.context === void 0 ? {} : { context: parsed.options.context },
+      ...parsed.options.output === void 0 ? {} : { outputPath: parsed.options.output }
+    });
+    return;
+  }
+  if (parsed.options.launch?.headless === true) {
+    throw new Error('record requires a headed browser. Remove "--headless true".');
+  }
+  if (typeof recordBrowser === "object") {
+    throw new Error('record does not support browser.mode="attach".');
   }
-  const browserKind = readSingle(rawOptions, "browser");
-  const requestedEngineName = readSingle(rawOptions, "engine");
-  const attachEndpoint = readSingle(rawOptions, "attach-endpoint");
-  const attachHeaders = parseKeyValueList(rawOptions.get("attach-header"));
-  const freshTab = readOptionalBoolean(rawOptions, "fresh-tab");
-  const headless = readOptionalBoolean(rawOptions, "headless");
-  const executablePath = readSingle(rawOptions, "executable-path");
-  const launchArgs = rawOptions.get("arg");
-  const timeoutMs = readOptionalNumber(rawOptions, "timeout-ms");
-  const browser = browserKind === void 0 ? attachEndpoint === void 0 ? void 0 : {
-    mode: "attach",
-    endpoint: attachEndpoint,
-    ...attachHeaders === void 0 ? {} : { headers: attachHeaders },
-    ...freshTab === void 0 ? {} : { freshTab }
-  } : browserKind === "temporary" || browserKind === "persistent" ? browserKind : {
-    mode: "attach",
-    ...attachEndpoint === void 0 ? {} : { endpoint: attachEndpoint },
-    ...attachHeaders === void 0 ? {} : { headers: attachHeaders },
-    ...freshTab === void 0 ? {} : { freshTab }
-  };
   const launch = {
-    ...headless === void 0 ? {} : { headless },
-    ...executablePath === void 0 ? {} : { executablePath },
-    ...launchArgs === void 0 ? {} : { args: launchArgs },
-    ...timeoutMs === void 0 ? {} : { timeoutMs }
-  };
-  const workspace = readSingle(rawOptions, "workspace");
-  const url = readSingle(rawOptions, "url");
-  const output = readSingle(rawOptions, "output");
-  const sourceUserDataDir = readSingle(rawOptions, "source-user-data-dir");
-  const sourceProfileDirectory = readSingle(rawOptions, "source-profile-directory");
-  const selector = readSingle(rawOptions, "selector");
-  const description = readSingle(rawOptions, "description");
-  const element = readOptionalNumber(rawOptions, "element");
-  const text = readSingle(rawOptions, "text");
-  const pressEnter = readOptionalBoolean(rawOptions, "press-enter");
-  const direction = readSingle(rawOptions, "direction");
-  const amount = readOptionalNumber(rawOptions, "amount");
-  const contextJson = readJsonObject(rawOptions, "context-json");
-  const inputJson = readJsonObject(rawOptions, "input-json");
-  const schemaJson = readJsonObject(rawOptions, "schema-json");
-  const providerValue = readSingle(rawOptions, "provider");
-  const provider = providerValue === void 0 ? void 0 : normalizeOpensteerProviderMode(providerValue, "--provider");
-  const cloudBaseUrl = readSingle(rawOptions, "cloud-base-url");
-  const cloudApiKey = readSingle(rawOptions, "cloud-api-key");
-  const cloudAppBaseUrl = readSingle(rawOptions, "cloud-app-base-url");
-  const cloudProfileId = readSingle(rawOptions, "cloud-profile-id");
-  const cloudProfileReuseIfActive = readOptionalBoolean(
-    rawOptions,
-    "cloud-profile-reuse-if-active"
-  );
-  const json = readOptionalBoolean(rawOptions, "json");
-  const agents = rawOptions.get("agent");
-  const skills = rawOptions.get("skill");
-  const global = readOptionalBoolean(rawOptions, "global");
-  const yes = readOptionalBoolean(rawOptions, "yes");
-  const copy = readOptionalBoolean(rawOptions, "copy");
-  const all = readOptionalBoolean(rawOptions, "all");
-  const list = readOptionalBoolean(rawOptions, "list");
-  const options = {
-    ...workspace === void 0 ? {} : { workspace },
-    ...url === void 0 ? {} : { url },
-    ...output === void 0 ? {} : { output },
-    ...requestedEngineName === void 0 ? {} : { requestedEngineName },
-    ...provider === void 0 ? {} : { provider },
-    ...cloudBaseUrl === void 0 ? {} : { cloudBaseUrl },
-    ...cloudApiKey === void 0 ? {} : { cloudApiKey },
-    ...cloudAppBaseUrl === void 0 ? {} : { cloudAppBaseUrl },
-    ...cloudProfileId === void 0 ? {} : { cloudProfileId },
-    ...cloudProfileReuseIfActive === void 0 ? {} : { cloudProfileReuseIfActive },
-    ...json === void 0 ? {} : { json },
-    ...agents === void 0 ? {} : { agents },
-    ...skills === void 0 ? {} : { skills },
-    ...global === void 0 ? {} : { global },
-    ...yes === void 0 ? {} : { yes },
-    ...copy === void 0 ? {} : { copy },
-    ...all === void 0 ? {} : { all },
-    ...list === void 0 ? {} : { list },
-    ...browser === void 0 ? {} : { browser },
-    ...Object.keys(launch).length === 0 ? {} : { launch },
-    ...contextJson === void 0 ? {} : { context: contextJson },
-    ...inputJson === void 0 ? {} : { inputJson },
-    ...schemaJson === void 0 ? {} : { schemaJson },
-    ...attachEndpoint === void 0 ? {} : { attachEndpoint },
-    ...attachHeaders === void 0 ? {} : { attachHeaders },
-    ...sourceUserDataDir === void 0 ? {} : { sourceUserDataDir },
-    ...sourceProfileDirectory === void 0 ? {} : { sourceProfileDirectory },
-    ...selector === void 0 ? {} : { selector },
-    ...description === void 0 ? {} : { description },
-    ...element === void 0 ? {} : { element },
-    ...text === void 0 ? {} : { text },
-    ...pressEnter === void 0 ? {} : { pressEnter },
-    ...direction === void 0 ? {} : { direction },
-    ...amount === void 0 ? {} : { amount }
-  };
-  return {
-    command: commandTokens,
-    rest,
-    options
+    ...parsed.options.launch ?? {},
+    headless: false
   };
+  const browserManager = new OpensteerBrowserManager({
+    rootDir,
+    workspace: parsed.options.workspace,
+    engineName,
+    browser: "persistent",
+    launch,
+    ...parsed.options.context === void 0 ? {} : { context: parsed.options.context }
+  });
+  const runtime = createOpensteerSemanticRuntime({
+    provider: {
+      mode: "local"
+    },
+    engine: engineName,
+    runtimeOptions: {
+      rootPath: browserManager.rootPath,
+      cleanupRootOnClose: browserManager.cleanupRootOnDisconnect,
+      workspace: parsed.options.workspace,
+      browser: "persistent",
+      launch,
+      ...parsed.options.context === void 0 ? {} : { context: parsed.options.context }
+    }
+  });
+  await runOpensteerRecordCommand({
+    runtime,
+    closeSession: () => closeOwnedLocalBrowserSession(runtime, browserManager),
+    workspace: parsed.options.workspace,
+    url,
+    rootDir,
+    ...parsed.options.output === void 0 ? {} : { outputPath: parsed.options.output }
+  });
+}
+async function closeOwnedLocalBrowserSession(runtime, browserManager) {
+  let closeError;
+  try {
+    await runtime.close();
+  } catch (error) {
+    closeError = error;
+  }
+  try {
+    await browserManager.close();
+  } catch (error) {
+    closeError ??= error;
+  }
+  if (closeError !== void 0) {
+    throw closeError;
+  }
 }
 function resolveCliBootstrapAction(argv) {
   if (argv.length === 0) {
@@ -1178,14 +2480,14 @@ function buildCliExplicitProvider(parsed) {
 function resolveCliEngineName(parsed) {
   return resolveOpensteerEngineName({
     ...parsed.options.requestedEngineName === void 0 ? {} : { requested: parsed.options.requestedEngineName },
-    ...process3.env.OPENSTEER_ENGINE === void 0 ? {} : { environment: process3.env.OPENSTEER_ENGINE }
+    ...process4.env.OPENSTEER_ENGINE === void 0 ? {} : { environment: process4.env.OPENSTEER_ENGINE }
   });
 }
 function resolveCliProvider(parsed) {
   const explicitProvider = buildCliExplicitProvider(parsed);
   return resolveOpensteerProvider({
     ...explicitProvider === void 0 ? {} : { provider: explicitProvider },
-    ...process3.env.OPENSTEER_PROVIDER === void 0 ? {} : { environmentProvider: process3.env.OPENSTEER_PROVIDER }
+    ...process4.env.OPENSTEER_PROVIDER === void 0 ? {} : { environmentProvider: process4.env.OPENSTEER_PROVIDER }
   });
 }
 function buildCliRuntimeProvider(parsed, providerMode) {
@@ -1219,156 +2521,26 @@ async function handleStatusCommand(parsed) {
   const runtimeProvider = buildCliRuntimeProvider(parsed, provider.mode);
   const runtimeConfig = resolveOpensteerRuntimeConfig({
     ...runtimeProvider === void 0 ? {} : { provider: runtimeProvider },
-    environment: process3.env
+    environment: process4.env
   });
   const status = await collectOpensteerStatus({
-    rootDir: process3.cwd(),
+    rootDir: process4.cwd(),
     ...parsed.options.workspace === void 0 ? {} : { workspace: parsed.options.workspace },
     provider,
     ...runtimeConfig.cloud === void 0 ? {} : { cloudConfig: runtimeConfig.cloud }
   });
   if (parsed.options.json === true) {
-    process3.stdout.write(`${JSON.stringify(status, null, 2)}
+    process4.stdout.write(`${JSON.stringify(status, null, 2)}
 `);
     return;
   }
-  process3.stdout.write(renderOpensteerStatus(status));
-}
-function parseKeyValueList(values) {
-  if (values === void 0 || values.length === 0) {
-    return void 0;
-  }
-  return Object.fromEntries(
-    values.map((entry) => {
-      const separator = entry.indexOf("=");
-      if (separator <= 0) {
-        throw new Error(`Expected NAME=VALUE, received "${entry}".`);
-      }
-      return [entry.slice(0, separator), entry.slice(separator + 1)];
-    })
-  );
-}
-function readSingle(options, name) {
-  const values = options.get(name);
-  if (values === void 0 || values.length === 0) {
-    return void 0;
-  }
-  return values[values.length - 1];
-}
-function readOptionalBoolean(options, name) {
-  const value = readSingle(options, name);
-  if (value === void 0) {
-    return void 0;
-  }
-  if (value === "true") {
-    return true;
-  }
-  if (value === "false") {
-    return false;
-  }
-  throw new Error(`Option "--${name}" must be true or false.`);
-}
-function readOptionalNumber(options, name) {
-  const value = readSingle(options, name);
-  if (value === void 0) {
-    return void 0;
-  }
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed)) {
-    throw new Error(`Option "--${name}" must be a number.`);
-  }
-  return parsed;
-}
-function readJsonObject(options, name) {
-  const value = readSingle(options, name);
-  if (value === void 0) {
-    return void 0;
-  }
-  const parsed = JSON.parse(value);
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`Option "--${name}" must be a JSON object.`);
-  }
-  return parsed;
-}
-function resolveCommandLength(tokens) {
-  if (tokens.length === 0) {
-    return 0;
-  }
-  if (tokens[0] === "browser") {
-    return Math.min(tokens.length, 2);
-  }
-  if (tokens[0] === "skills") {
-    return Math.min(tokens.length, 2);
-  }
-  if (tokens[0] === "run") {
-    return 1;
-  }
-  if (tokens[0] === "status") {
-    return 1;
-  }
-  if (tokens[0] === "record") {
-    return 1;
-  }
-  for (let length = Math.min(3, tokens.length); length >= 1; length -= 1) {
-    if (OPERATION_ALIASES.has(tokens.slice(0, length).join(" "))) {
-      return length;
-    }
-  }
-  return Math.min(tokens.length, 1);
+  process4.stdout.write(renderOpensteerStatus(status));
 }
 function printHelp() {
-  process3.stdout.write(`Opensteer v2 CLI
-
-Usage:
-  opensteer open <url> --workspace <id> [--browser persistent|temporary|attach]
-  opensteer goto <url> --workspace <id>
-  opensteer snapshot [action|extraction] --workspace <id>
-  opensteer click --workspace <id> (--element <n> | --selector <css> | --description <text>)
-  opensteer input --workspace <id> --text <value> (--element <n> | --selector <css> | --description <text>)
-  opensteer extract --workspace <id> --description <text> [--schema-json <json>]
-  opensteer record --workspace <id> --url <url> [--output <path>]
-  opensteer close --workspace <id>
-  opensteer status [--workspace <id>] [--json]
-
-  opensteer browser status --workspace <id>
-  opensteer browser clone --workspace <id> --source-user-data-dir <path> [--source-profile-directory <name>]
-  opensteer browser reset --workspace <id>
-  opensteer browser delete --workspace <id>
-  opensteer browser discover
-  opensteer browser inspect --attach-endpoint <url>
-  opensteer skills install [--skill <name>] [--agent <name>] [--global] [--yes]
-
-  opensteer run <semantic-operation> --workspace <id> --input-json <json>
-
-Common options:
-  --help
-  --version
-  --workspace <id>
-  --url <url>
-  --output <path>
-  --provider local|cloud
-  --cloud-base-url <url>
-  --cloud-api-key <key>
-  --cloud-app-base-url <url>
-  --cloud-profile-id <id>
-  --cloud-profile-reuse-if-active <true|false>
-  --json <true|false>
-  --engine playwright|abp
-  --browser temporary|persistent|attach
-  --attach-endpoint <url>
-  --fresh-tab <true|false>
-  --headless <true|false>
-  --executable-path <path>
-  --arg <value>        repeatable
-  --timeout-ms <ms>
-  --context-json <json>
-  --input-json <json>
-  --skill <name>      repeatable
-  --agent <name>      repeatable
-`);
+  process4.stdout.write(getHelpText());
 }
 function printVersion() {
-  process3.stdout.write(`${package_default.version}
+  process4.stdout.write(`${package_default.version}
 `);
 }
 main().catch((error) => {
@@ -1383,9 +2555,9 @@ main().catch((error) => {
       message: String(error)
     }
   };
-  process3.stderr.write(`${JSON.stringify(payload)}
+  process4.stderr.write(`${JSON.stringify(payload)}
 `);
-  process3.exitCode = 1;
+  process4.exitCode = 1;
 });
 //# sourceMappingURL=bin.js.map
 //# sourceMappingURL=bin.js.map