@swmansion/argent 0.13.1-next.1 → 0.13.1-next.2

package/dist/cli-cmds.mjs

@@ -109,8 +109,8 @@ var require_picocolors = __commonJS({
 var require_src = __commonJS({
   "../../node_modules/sisteransi/src/index.js"(exports, module) {
     "use strict";
-    var ESC2 = "\x1B";
-    var CSI2 = `${ESC2}[`;
+    var ESC3 = "\x1B";
+    var CSI2 = `${ESC3}[`;
     var beep = "\x07";
     var cursor3 = {
       to(x, y) {
@@ -134,8 +134,8 @@ var require_src = __commonJS({
       left: `${CSI2}G`,
       hide: `${CSI2}?25l`,
       show: `${CSI2}?25h`,
-      save: `${ESC2}7`,
-      restore: `${ESC2}8`
+      save: `${ESC3}7`,
+      restore: `${ESC3}8`
     };
     var scroll = {
       up: (count = 1) => `${CSI2}S`.repeat(count),
@@ -162,8 +162,8 @@ var require_src = __commonJS({
 });
 
 // ../argent-cli/src/run.ts
-import * as fs6 from "node:fs";
-import * as path7 from "node:path";
+import * as fs7 from "node:fs";
+import * as path9 from "node:path";
 
 // ../argent-tools-client/src/launcher.ts
 import * as net from "node:net";
@@ -617,8 +617,8 @@ function parseLinkTarget(input) {
   const host = u3.hostname.startsWith("[") ? u3.hostname.slice(1, -1) : u3.hostname;
   if (!host) throw new Error(`URL "${input}" is missing a host.`);
   const port = u3.port ? Number(u3.port) : u3.protocol === "https:" ? 443 : 80;
-  const path10 = u3.pathname === "/" ? "" : u3.pathname.replace(/\/+$/, "");
-  const url = `${u3.protocol}//${u3.host}${path10}`;
+  const path12 = u3.pathname === "/" ? "" : u3.pathname.replace(/\/+$/, "");
+  const url = `${u3.protocol}//${u3.host}${path12}`;
   const token = u3.username ? decodeURIComponent(u3.username) : void 0;
   return { url, host, port, ...token ? { token } : {} };
 }
@@ -930,8 +930,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? dirname2(proce
     return decodedFile;
   };
 }
-function normalizeWindowsPath(path10) {
-  return path10.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+function normalizeWindowsPath(path12) {
+  return path12.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
 
 // ../../node_modules/@posthog/core/dist/featureFlagUtils.mjs
@@ -3483,9 +3483,9 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path10, ranges, output) {
+function getContextLinesFromFile(path12, ranges, output) {
   return new Promise((resolve3) => {
-    const stream = createReadStream(path10);
+    const stream = createReadStream(path12);
     const lineReaded = createInterface2({
       input: stream
     });
@@ -3500,7 +3500,7 @@ function getContextLinesFromFile(path10, ranges, output) {
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path10, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path12, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
       destroyStreamAndResolve();
@@ -3561,8 +3561,8 @@ function clearLineContext(frame) {
   delete frame.context_line;
   delete frame.post_context;
 }
-function shouldSkipContextLinesForFile(path10) {
-  return path10.startsWith("node:") || path10.endsWith(".min.js") || path10.endsWith(".min.cjs") || path10.endsWith(".min.mjs") || path10.startsWith("data:");
+function shouldSkipContextLinesForFile(path12) {
+  return path12.startsWith("node:") || path12.endsWith(".min.js") || path12.endsWith(".min.cjs") || path12.endsWith(".min.mjs") || path12.startsWith("data:");
 }
 function shouldSkipContextLinesForFrame(frame) {
   if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
@@ -6256,9 +6256,9 @@ function isReplitAgent(env) {
 }
 var DEVIN_MARKER_PATH = "/opt/.devin";
 var JULES_MARKER_PATH = "/opt/environment_summary.sh";
-function safeExists(fileExists, path10) {
+function safeExists(fileExists, path12) {
   try {
-    return fileExists(path10);
+    return fileExists(path12);
   } catch {
     return false;
   }
@@ -6712,108 +6712,137 @@ function getBaseProps(runtime) {
 }
 
 // ../telemetry/src/identity.ts
-import * as crypto from "node:crypto";
-import * as fs2 from "node:fs";
-import * as path5 from "node:path";
+import * as crypto2 from "node:crypto";
+import * as fs4 from "node:fs";
+import * as path8 from "node:path";
 
 // ../telemetry/src/paths.ts
-import * as os from "node:os";
+import * as path7 from "node:path";
+
+// ../configuration-core/src/flags.ts
+import * as fs2 from "node:fs";
 import * as path4 from "node:path";
-function nonEmpty(value) {
-  if (value == void 0) return null;
-  const trimmed = value.trim();
-  return trimmed === "" ? null : value;
-}
-function argentHomeDir() {
-  const home = process.platform === "win32" ? nonEmpty(process.env.USERPROFILE) ?? os.homedir() : nonEmpty(process.env.HOME) ?? os.homedir();
-  return path4.join(home, ".argent");
-}
-function identityFilePath() {
-  return path4.join(argentHomeDir(), "telemetry-id");
+import { homedir as homedir3 } from "node:os";
+var FLAG_REGISTRY = [
+  {
+    name: "disable-auto-screenshot",
+    description: "Disable the automatic screenshot captured after interaction tools."
+  },
+  {
+    name: "argent-lens",
+    description: "Argent Lens \u2014 the propose_variant / await_user_selection tools and the Electron preview window for staging UI design variants and letting a human pick among them. Off by default while the feature is in development."
+  },
+  {
+    name: "artifacts-list-endpoint",
+    description: "Expose GET /artifacts for remote artifact inventory consumers."
+  }
+];
+function getFlagDefinition(name, registry = FLAG_REGISTRY) {
+  return registry.find((def) => def.name === name);
 }
-function configFilePath() {
-  return path4.join(argentHomeDir(), "config.json");
+var PROJECT_MARKERS = [".argent", ".git", "package.json"];
+function resolveProjectRoot(startDir) {
+  const initial = path4.resolve(startDir);
+  let current = initial;
+  while (true) {
+    for (const marker of PROJECT_MARKERS) {
+      if (fs2.existsSync(path4.join(current, marker))) return current;
+    }
+    const parent = path4.dirname(current);
+    if (parent === current) return initial;
+    current = parent;
+  }
 }
-function debugLogPath() {
-  return path4.join(argentHomeDir(), "telemetry-debug.log");
+function getFlagsPath(scope, options = {}) {
+  const home = options.homeDir ?? homedir3();
+  if (scope === "global") {
+    return path4.join(home, ".argent", "flags.json");
+  }
+  const cwd = options.cwd ?? process.cwd();
+  return path4.join(resolveProjectRoot(cwd), ".argent", "flags.json");
 }
-
-// ../telemetry/src/identity.ts
-var cached = null;
-function readOrCreateAnonId() {
-  const finalPath = identityFilePath();
-  if (cached && cached.path === finalPath) return cached.id;
-  const existing = tryReadId(finalPath);
-  if (existing) {
-    cached = { path: finalPath, id: existing };
-    return existing;
+function readFlagsFile(filePath) {
+  let raw;
+  try {
+    raw = fs2.readFileSync(filePath, "utf8");
+  } catch {
+    return {};
   }
-  fs2.mkdirSync(argentHomeDir(), { recursive: true });
-  const uuid = crypto.randomUUID();
-  for (let attempt = 0; attempt < 3; attempt++) {
-    const tmpPath = path5.join(
-      argentHomeDir(),
-      `.telemetry-id.tmp.${process.pid}.${crypto.randomUUID()}`
-    );
-    let fd;
-    try {
-      fd = fs2.openSync(tmpPath, "wx", 384);
-    } catch (err) {
-      if (err.code === "EEXIST") continue;
-      throw err;
-    }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+  const flags2 = parsed.flags;
+  if (!flags2 || typeof flags2 !== "object" || Array.isArray(flags2)) return {};
+  const out = {};
+  for (const [k, v] of Object.entries(flags2)) {
+    if (typeof v === "boolean") out[k] = v;
+  }
+  return out;
+}
+function writeFlagsFile(filePath, flags2) {
+  if (Object.keys(flags2).length === 0) {
+    if (fs2.existsSync(filePath)) fs2.rmSync(filePath, { force: true });
+    const parent = path4.dirname(filePath);
     try {
-      try {
-        fs2.writeSync(fd, uuid);
-        fs2.fsyncSync(fd);
-      } finally {
-        fs2.closeSync(fd);
-      }
-      fs2.linkSync(tmpPath, finalPath);
-      cached = { path: finalPath, id: uuid };
-      return uuid;
-    } catch (err) {
-      if (err.code === "EEXIST") {
-        const beatUs = tryReadId(finalPath);
-        if (beatUs) {
-          cached = { path: finalPath, id: beatUs };
-          return beatUs;
-        }
-        continue;
-      }
-      throw err;
-    } finally {
-      try {
-        fs2.unlinkSync(tmpPath);
-      } catch {
+      if (fs2.existsSync(parent) && fs2.readdirSync(parent).length === 0) {
+        fs2.rmdirSync(parent);
       }
+    } catch {
     }
+    return;
   }
-  throw new Error("telemetry: failed to create anonymous identity after retries");
+  fs2.mkdirSync(path4.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.${process.pid}.tmp`;
+  fs2.writeFileSync(tmp, JSON.stringify({ flags: flags2 }, null, 2) + "\n");
+  fs2.renameSync(tmp, filePath);
 }
-function peekAnonId() {
-  return tryReadId(identityFilePath());
+function readFlags(scope, options = {}) {
+  return readFlagsFile(getFlagsPath(scope, options));
 }
-function tryReadId(filePath) {
-  let raw;
-  try {
-    const stats = fs2.lstatSync(filePath);
-    if (!stats.isFile()) return null;
-    raw = fs2.readFileSync(filePath, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT") return null;
-    return null;
-  }
-  const value = raw.trim();
-  if (/^[0-9a-fA-F-]{32,128}$/.test(value)) return value;
-  return null;
+function setFlag(name, value, scope, options = {}) {
+  const filePath = getFlagsPath(scope, options);
+  const current = readFlagsFile(filePath);
+  current[name] = value;
+  writeFlagsFile(filePath, current);
+}
+function unsetFlag(name, scope, options = {}) {
+  const filePath = getFlagsPath(scope, options);
+  const current = readFlagsFile(filePath);
+  if (!Object.hasOwn(current, name)) return false;
+  delete current[name];
+  writeFlagsFile(filePath, current);
+  return true;
+}
+function isFlagEnabled(name, options = {}) {
+  const projectFlags = readFlags("project", options);
+  if (Object.hasOwn(projectFlags, name)) return projectFlags[name];
+  const globalFlags = readFlags("global", options);
+  if (Object.hasOwn(globalFlags, name)) return globalFlags[name];
+  return false;
 }
 
-// ../telemetry/src/consent.ts
-import * as fs4 from "node:fs";
+// ../configuration-core/src/paths.ts
+import * as os from "node:os";
+import * as path5 from "node:path";
+function nonEmpty(value) {
+  if (value == void 0) return null;
+  const trimmed = value.trim();
+  return trimmed === "" ? null : value;
+}
+function argentHomeDir() {
+  const home = process.platform === "win32" ? nonEmpty(process.env.USERPROFILE) ?? os.homedir() : nonEmpty(process.env.HOME) ?? os.homedir();
+  return path5.join(home, ".argent");
+}
+function configFilePath() {
+  return path5.join(argentHomeDir(), "config.json");
+}
 
-// ../telemetry/src/config-file.ts
-import * as crypto2 from "node:crypto";
+// ../configuration-core/src/config.ts
+import * as crypto from "node:crypto";
 import * as fs3 from "node:fs";
 import * as path6 from "node:path";
 function readConfigObject() {
@@ -6876,7 +6905,7 @@ function updateConfig(mutate) {
     const next = readConfigObject();
     mutate(next);
     const finalPath = configFilePath();
-    const tmpPath = path6.join(argentHomeDir(), `.config.tmp.${process.pid}.${crypto2.randomUUID()}`);
+    const tmpPath = path6.join(argentHomeDir(), `.config.tmp.${process.pid}.${crypto.randomUUID()}`);
     const fd = fs3.openSync(tmpPath, "wx", 384);
     try {
       fs3.writeSync(fd, JSON.stringify(next, null, 2) + "\n");
@@ -6897,14 +6926,116 @@ function updateConfig(mutate) {
     if (lock) releaseConfigLock(lock);
   }
 }
+function readLensConfig() {
+  const lens2 = readConfigObject().lens;
+  return lens2 && typeof lens2 === "object" ? lens2 : {};
+}
+function getRememberedAgent() {
+  const agent = readLensConfig().agent;
+  return typeof agent === "string" && agent.trim() ? agent : null;
+}
+function setRememberedAgent(agentId) {
+  updateConfig((config) => {
+    const lens2 = config.lens && typeof config.lens === "object" ? config.lens : {};
+    lens2.agent = agentId;
+    config.lens = lens2;
+  });
+}
+function clearRememberedAgent() {
+  updateConfig((config) => {
+    if (config.lens && typeof config.lens === "object") {
+      delete config.lens.agent;
+    }
+  });
+}
+
+// ../telemetry/src/paths.ts
+function identityFilePath() {
+  return path7.join(argentHomeDir(), "telemetry-id");
+}
+function debugLogPath() {
+  return path7.join(argentHomeDir(), "telemetry-debug.log");
+}
+
+// ../telemetry/src/identity.ts
+var cached = null;
+function readOrCreateAnonId() {
+  const finalPath = identityFilePath();
+  if (cached && cached.path === finalPath) return cached.id;
+  const existing = tryReadId(finalPath);
+  if (existing) {
+    cached = { path: finalPath, id: existing };
+    return existing;
+  }
+  fs4.mkdirSync(argentHomeDir(), { recursive: true });
+  const uuid = crypto2.randomUUID();
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const tmpPath = path8.join(
+      argentHomeDir(),
+      `.telemetry-id.tmp.${process.pid}.${crypto2.randomUUID()}`
+    );
+    let fd;
+    try {
+      fd = fs4.openSync(tmpPath, "wx", 384);
+    } catch (err) {
+      if (err.code === "EEXIST") continue;
+      throw err;
+    }
+    try {
+      try {
+        fs4.writeSync(fd, uuid);
+        fs4.fsyncSync(fd);
+      } finally {
+        fs4.closeSync(fd);
+      }
+      fs4.linkSync(tmpPath, finalPath);
+      cached = { path: finalPath, id: uuid };
+      return uuid;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        const beatUs = tryReadId(finalPath);
+        if (beatUs) {
+          cached = { path: finalPath, id: beatUs };
+          return beatUs;
+        }
+        continue;
+      }
+      throw err;
+    } finally {
+      try {
+        fs4.unlinkSync(tmpPath);
+      } catch {
+      }
+    }
+  }
+  throw new Error("telemetry: failed to create anonymous identity after retries");
+}
+function peekAnonId() {
+  return tryReadId(identityFilePath());
+}
+function tryReadId(filePath) {
+  let raw;
+  try {
+    const stats = fs4.lstatSync(filePath);
+    if (!stats.isFile()) return null;
+    raw = fs4.readFileSync(filePath, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    return null;
+  }
+  const value = raw.trim();
+  if (/^[0-9a-fA-F-]{32,128}$/.test(value)) return value;
+  return null;
+}
 
 // ../telemetry/src/consent.ts
+import * as fs5 from "node:fs";
 var cache = { current: null };
 var sessionOverride = null;
 function readConfigOverride() {
   let stats;
   try {
-    stats = fs4.lstatSync(configFilePath());
+    stats = fs5.lstatSync(configFilePath());
   } catch (err) {
     if (err.code === "ENOENT") {
       cache.current = { mtimeMs: null, fingerprint: null, enabledOverride: null };
@@ -6924,7 +7055,7 @@ function readConfigOverride() {
   }
   let parsedEnabled = null;
   try {
-    const raw = fs4.readFileSync(configFilePath(), "utf8");
+    const raw = fs5.readFileSync(configFilePath(), "utf8");
     const json = JSON.parse(raw);
     if (json && typeof json === "object") {
       const t2 = json.telemetry;
@@ -6985,7 +7116,7 @@ function writeConsentFlag(enabled) {
 }
 
 // ../telemetry/src/debug.ts
-import * as fs5 from "node:fs";
+import * as fs6 from "node:fs";
 function isDebugEnabled(env = process.env) {
   const v = env.ARGENT_TELEMETRY_DEBUG;
   if (!v) return false;
@@ -7012,8 +7143,8 @@ function emitDebugPayload(payload) {
   } catch {
   }
   try {
-    fs5.mkdirSync(argentHomeDir(), { recursive: true });
-    fs5.appendFileSync(debugLogPath(), line + "\n");
+    fs6.mkdirSync(argentHomeDir(), { recursive: true });
+    fs6.appendFileSync(debugLogPath(), line + "\n");
   } catch {
   }
 }
@@ -7382,8 +7513,8 @@ async function fetchImageToFile(result, outPath) {
   const res = await fetch(url);
   if (!res.ok) throw new Error(`Failed to download image: ${res.status} ${res.statusText}`);
   const buf = Buffer.from(await res.arrayBuffer());
-  fs6.mkdirSync(path7.dirname(path7.resolve(outPath)), { recursive: true });
-  fs6.writeFileSync(outPath, buf);
+  fs7.mkdirSync(path9.dirname(path9.resolve(outPath)), { recursive: true });
+  fs7.writeFileSync(outPath, buf);
 }
 function renderResult(result, outputHint, images, json) {
   if (json) return JSON.stringify(result, null, 2);
@@ -7522,8 +7653,8 @@ Examples:
   if (outPath && meta.outputHint === "image") {
     try {
       if (images.length > 0) {
-        fs6.mkdirSync(path7.dirname(path7.resolve(outPath)), { recursive: true });
-        fs6.writeFileSync(outPath, images[0].data);
+        fs7.mkdirSync(path9.dirname(path9.resolve(outPath)), { recursive: true });
+        fs7.writeFileSync(outPath, images[0].data);
       } else if (result && typeof result === "object") {
         await fetchImageToFile(result, outPath);
       }
@@ -7623,16 +7754,16 @@ Options:
 }
 
 // ../argent-cli/src/server.ts
-import * as fs7 from "node:fs";
-import * as path8 from "node:path";
-import { homedir as homedir4, networkInterfaces } from "node:os";
+import * as fs8 from "node:fs";
+import * as path10 from "node:path";
+import { homedir as homedir5, networkInterfaces } from "node:os";
 import { spawn as spawn2 } from "node:child_process";
-var STATE_DIR2 = path8.join(homedir4(), ".argent");
-var STATE_FILE2 = path8.join(STATE_DIR2, "tool-server.json");
-var LOG_FILE2 = path8.join(STATE_DIR2, "tool-server.log");
+var STATE_DIR2 = path10.join(homedir5(), ".argent");
+var STATE_FILE2 = path10.join(STATE_DIR2, "tool-server.json");
+var LOG_FILE2 = path10.join(STATE_DIR2, "tool-server.log");
 function readState2() {
   try {
-    return JSON.parse(fs7.readFileSync(STATE_FILE2, "utf8"));
+    return JSON.parse(fs8.readFileSync(STATE_FILE2, "utf8"));
   } catch {
     return null;
   }
@@ -7682,12 +7813,12 @@ async function stopCmd() {
   console.log(`tool-server stopped (pid ${state2.pid}).`);
 }
 function logsCmd(follow) {
-  if (!fs7.existsSync(LOG_FILE2)) {
+  if (!fs8.existsSync(LOG_FILE2)) {
     console.log(`No log file at ${LOG_FILE2}`);
     return;
   }
   if (!follow) {
-    process.stdout.write(fs7.readFileSync(LOG_FILE2, "utf8"));
+    process.stdout.write(fs8.readFileSync(LOG_FILE2, "utf8"));
     return;
   }
   const child = spawn2("tail", ["-f", LOG_FILE2], { stdio: "inherit" });
@@ -8029,116 +8160,940 @@ async function server(argv, options) {
   }
 }
 
-// ../argent-cli/src/flags.ts
-var import_picocolors = __toESM(require_picocolors(), 1);
+// ../argent-cli/src/lens.ts
+import * as fs9 from "node:fs";
+import * as os2 from "node:os";
+import * as path11 from "node:path";
 
-// ../configuration-core/src/flags.ts
-import * as fs8 from "node:fs";
-import * as path9 from "node:path";
-import { homedir as homedir5 } from "node:os";
-var FLAG_REGISTRY = [
+// ../argent-cli/src/lens-terminal.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { existsSync as existsSync5 } from "node:fs";
+var ITERM_PATHS = ["/Applications/iTerm.app", `${process.env.HOME ?? ""}/Applications/iTerm.app`];
+function isITermInstalled(existsSync7 = defaultExists) {
+  return ITERM_PATHS.some((p) => p && existsSync7(p));
+}
+function defaultExists(p) {
+  return existsSync5(p);
+}
+function resolveTerminal(preferred = "iterm", existsSync7 = defaultExists) {
+  if (preferred === "iterm" && isITermInstalled(existsSync7)) return "iterm";
+  return "terminal";
+}
+function escapeAppleScript(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function shellQuote(s) {
+  return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+function flattenLine(s) {
+  return s.replace(/\s*[\r\n]+\s*/g, " ").trim();
+}
+function buildSpawnScript(app, shellCommand) {
+  const esc = escapeAppleScript(shellCommand);
+  if (app === "iterm") {
+    return [
+      'tell application "iTerm"',
+      "  activate",
+      "  set w to (create window with default profile)",
+      '  set _sid to ""',
+      '  set _tty to ""',
+      "  tell current session of w",
+      `    write text "${esc}"`,
+      "    set _tty to tty",
+      "    set _sid to id",
+      "  end tell",
+      "  set _wid to (id of w) as string",
+      "end tell",
+      'return _wid & "|" & _sid & "|" & _tty'
+    ].join("\n");
+  }
+  return [
+    'tell application "Terminal"',
+    "  activate",
+    `  set _tab to do script "${esc}"`,
+    "  set _tty to tty of _tab",
+    "  set _wid to (id of front window) as string",
+    "end tell",
+    'return _wid & "||" & _tty'
+  ].join("\n");
+}
+function buildWriteScript(session, text2) {
+  const esc = escapeAppleScript(flattenLine(text2));
+  if (session.app === "iterm") {
+    return [
+      'tell application "iTerm"',
+      "  set _found to false",
+      "  repeat with w in windows",
+      "    repeat with t in tabs of w",
+      "      repeat with s in sessions of t",
+      `        if (id of s) is "${session.sessionId}" then`,
+      "          tell s to write text (character id 27) newline no",
+      "          delay 0.15",
+      `          tell s to write text "${esc}"`,
+      "          delay 0.2",
+      '          tell s to write text ""',
+      "          set _found to true",
+      "        end if",
+      "      end repeat",
+      "    end repeat",
+      "  end repeat",
+      '  if not _found then error "session gone"',
+      "end tell"
+    ].join("\n");
+  }
+  return [
+    'tell application "Terminal"',
+    "  set _found to false",
+    "  repeat with w in windows",
+    `    if (id of w as string) is "${session.windowId}" then`,
+    "      do script (character id 27) in (selected tab of w)",
+    "      delay 0.15",
+    `      do script "${esc}" in (selected tab of w)`,
+    "      delay 0.2",
+    '      do script "" in (selected tab of w)',
+    "      set _found to true",
+    "    end if",
+    "  end repeat",
+    '  if not _found then error "window gone"',
+    "end tell"
+  ].join("\n");
+}
+function buildReadScript(session) {
+  if (session.app === "iterm") {
+    return [
+      'tell application "iTerm"',
+      "  repeat with w in windows",
+      "    repeat with t in tabs of w",
+      "      repeat with s in sessions of t",
+      `        if (id of s) is "${session.sessionId}" then return (text of s)`,
+      "      end repeat",
+      "    end repeat",
+      "  end repeat",
+      '  return ""',
+      "end tell"
+    ].join("\n");
+  }
+  return [
+    'tell application "Terminal"',
+    "  repeat with w in windows",
+    `    if (id of w as string) is "${session.windowId}" then return ((contents of selected tab of w) as text)`,
+    "  end repeat",
+    '  return ""',
+    "end tell"
+  ].join("\n");
+}
+function buildEnterScript(session) {
+  if (session.app === "iterm") {
+    return [
+      'tell application "iTerm"',
+      "  repeat with w in windows",
+      "    repeat with t in tabs of w",
+      "      repeat with s in sessions of t",
+      `        if (id of s) is "${session.sessionId}" then tell s to write text ""`,
+      "      end repeat",
+      "    end repeat",
+      "  end repeat",
+      "end tell"
+    ].join("\n");
+  }
+  return [
+    'tell application "Terminal"',
+    "  repeat with w in windows",
+    `    if (id of w as string) is "${session.windowId}" then do script "" in (selected tab of w)`,
+    "  end repeat",
+    "end tell"
+  ].join("\n");
+}
+function parseCapture(out) {
+  const parts = out.trim().split("|");
+  return {
+    windowId: parts[0]?.trim() ?? "",
+    sessionId: parts[1]?.trim() ?? "",
+    tty: parts[2]?.trim() ?? ""
+  };
+}
+function shortTty(tty) {
+  return tty.startsWith("/dev/") ? tty.slice(5) : tty;
+}
+function parseAliveTtys(psOutput) {
+  const set = /* @__PURE__ */ new Set();
+  for (const line of psOutput.split("\n")) {
+    const t2 = line.trim();
+    if (t2 && t2 !== "??") set.add(t2);
+  }
+  return set;
+}
+function runOsascript(script) {
+  try {
+    return execFileSync2("/usr/bin/osascript", ["-e", script], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (err) {
+    const e = err;
+    const stderr = (typeof e.stderr === "string" ? e.stderr : e.stderr?.toString()) ?? "";
+    throw new Error(`osascript failed: ${stderr.trim() || e.message || "unknown error"}`, {
+      cause: err
+    });
+  }
+}
+function spawnTerminalSession(command, app) {
+  const out = runOsascript(buildSpawnScript(app, command));
+  const { windowId, sessionId: sessionId2, tty } = parseCapture(out);
+  return { app, windowId, sessionId: sessionId2, tty };
+}
+function writeToSession(session, text2) {
+  try {
+    runOsascript(buildWriteScript(session, text2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readSessionText(session) {
+  try {
+    return runOsascript(buildReadScript(session));
+  } catch {
+    return null;
+  }
+}
+function pressEnter(session) {
+  try {
+    runOsascript(buildEnterScript(session));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function aliveTtys() {
+  try {
+    const out = execFileSync2("/bin/ps", ["-A", "-o", "tty="], { encoding: "utf8" });
+    return parseAliveTtys(out);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function isSessionAlive(session) {
+  if (!session.tty) return false;
+  return aliveTtys().has(shortTty(session.tty));
+}
+
+// ../argent-cli/src/lens-pty.ts
+import { createRequire } from "node:module";
+var nodeRequire = createRequire(import.meta.url);
+function loadNodePty(req = nodeRequire) {
+  try {
+    const mod = req("node-pty");
+    return mod && typeof mod.spawn === "function" ? mod : null;
+  } catch {
+    return null;
+  }
+}
+var ESC = "\x1B";
+var ENTER = "\r";
+var BEAT_AFTER_ESC_MS = 150;
+var BEAT_AFTER_TEXT_MS = 200;
+var QUIET_BEFORE_INJECT_MS = 600;
+var MAX_QUIET_WAIT_MS = 3e3;
+var QUIET_POLL_MS = 100;
+function ptyInjectBeats(text2) {
+  return [
+    { delayBeforeMs: 0, data: ESC },
+    { delayBeforeMs: BEAT_AFTER_ESC_MS, data: flattenLine(text2) },
+    { delayBeforeMs: BEAT_AFTER_TEXT_MS, data: ENTER }
+  ];
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+var DEFAULT_COLS = 80;
+var DEFAULT_ROWS = 24;
+function startPtyProxy(opts) {
+  const stdin2 = opts.stdin ?? process.stdin;
+  const stdout2 = opts.stdout ?? process.stdout;
+  const signals = opts.signals ?? process;
+  const cols = stdout2.columns ?? DEFAULT_COLS;
+  const rows = stdout2.rows ?? DEFAULT_ROWS;
+  const term = opts.pty.spawn("/bin/sh", ["-c", opts.command], {
+    name: process.env.TERM || "xterm-256color",
+    cols,
+    rows,
+    cwd: opts.cwd,
+    env: opts.env ?? process.env
+  });
+  const observers = [];
+  const exitCbs = [];
+  const dataSub = term.onData((d) => {
+    stdout2.write(d);
+    for (const cb of observers) cb(d);
+  });
+  const wasRaw = Boolean(stdin2.isRaw);
+  if (stdin2.isTTY && stdin2.setRawMode) stdin2.setRawMode(true);
+  stdin2.resume();
+  let lastUserInputAt = 0;
+  const onStdin = (d) => {
+    lastUserInputAt = Date.now();
+    term.write(d.toString("utf8"));
+  };
+  stdin2.on("data", onStdin);
+  const onResize = () => {
+    if (stdout2.columns && stdout2.rows) term.resize(stdout2.columns, stdout2.rows);
+  };
+  signals.on("SIGWINCH", onResize);
+  let disposed = false;
+  const cleanup = () => {
+    if (disposed) return;
+    disposed = true;
+    try {
+      dataSub.dispose();
+    } catch {
+    }
+    stdin2.off("data", onStdin);
+    signals.off("SIGWINCH", onResize);
+    if (stdin2.isTTY && stdin2.setRawMode) stdin2.setRawMode(wasRaw);
+    stdin2.pause();
+  };
+  term.onExit(({ exitCode }) => {
+    cleanup();
+    for (const cb of exitCbs) cb(exitCode ?? 0);
+  });
+  const waitForTypingPause = async () => {
+    const started = Date.now();
+    while (!disposed && lastUserInputAt > 0 && Date.now() - lastUserInputAt < QUIET_BEFORE_INJECT_MS && Date.now() - started < MAX_QUIET_WAIT_MS) {
+      await sleep(QUIET_POLL_MS);
+    }
+  };
+  let queue = Promise.resolve();
+  return {
+    pid: term.pid,
+    inject(text2) {
+      if (disposed) return false;
+      const beats = ptyInjectBeats(text2);
+      queue = queue.then(async () => {
+        await waitForTypingPause();
+        for (const beat of beats) {
+          if (beat.delayBeforeMs) await sleep(beat.delayBeforeMs);
+          if (disposed) return;
+          term.write(beat.data);
+        }
+      }).catch(() => {
+      });
+      return true;
+    },
+    write(data) {
+      if (disposed) return false;
+      try {
+        term.write(data);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    onData(cb) {
+      observers.push(cb);
+    },
+    onExit(cb) {
+      exitCbs.push(cb);
+    },
+    dispose() {
+      const wasDisposed = disposed;
+      cleanup();
+      if (!wasDisposed) {
+        try {
+          term.kill();
+        } catch {
+        }
+      }
+    }
+  };
+}
+
+// ../argent-cli/src/lens-stream.ts
+function parseSseBuffer(buffer) {
+  const normalised = buffer.replace(/\r\n/g, "\n");
+  const events = [];
+  let rest = normalised;
+  for (; ; ) {
+    const sep3 = rest.indexOf("\n\n");
+    if (sep3 === -1) break;
+    const rawFrame = rest.slice(0, sep3);
+    rest = rest.slice(sep3 + 2);
+    let event = "message";
+    const dataLines = [];
+    for (const line of rawFrame.split("\n")) {
+      if (line === "" || line.startsWith(":")) continue;
+      const colon = line.indexOf(":");
+      const field = colon === -1 ? line : line.slice(0, colon);
+      let value = colon === -1 ? "" : line.slice(colon + 1);
+      if (value.startsWith(" ")) value = value.slice(1);
+      if (field === "event") event = value;
+      else if (field === "data") dataLines.push(value);
+    }
+    if (dataLines.length > 0) events.push({ event, data: dataLines.join("\n") });
+  }
+  return { events, rest };
+}
+async function* lensEvents(baseUrl, signal) {
+  const res = await fetch(`${baseUrl}/preview/lens-stream`, {
+    signal,
+    headers: { Accept: "text/event-stream" }
+  });
+  if (!res.ok || !res.body) {
+    throw new Error(`lens-stream: HTTP ${res.status}`);
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  try {
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      if (done) return;
+      buf += decoder.decode(value, { stream: true });
+      const { events, rest } = parseSseBuffer(buf);
+      buf = rest;
+      for (const ev of events) yield ev;
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+
+// ../argent-cli/src/lens-agents.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+var AGENTS = [
   {
-    name: "disable-auto-screenshot",
-    description: "Disable the automatic screenshot captured after interaction tools."
+    id: "claude",
+    displayName: "Claude Code",
+    bin: "claude",
+    launch: (cwd, seed) => `cd ${cwd} 2>/dev/null; claude "$(cat ${seed})"`
   },
   {
-    name: "argent-lens",
-    description: "Argent Lens \u2014 the propose_variant / await_user_selection tools and the Electron preview window for staging UI design variants and letting a human pick among them. Off by default while the feature is in development."
+    id: "codex",
+    displayName: "Codex CLI",
+    bin: "codex",
+    launch: (cwd, seed) => `cd ${cwd} 2>/dev/null; codex "$(cat ${seed})"`
   },
   {
-    name: "artifacts-list-endpoint",
-    description: "Expose GET /artifacts for remote artifact inventory consumers."
+    id: "gemini",
+    displayName: "Gemini CLI",
+    bin: "gemini",
+    launch: (cwd, seed) => `cd ${cwd} 2>/dev/null; gemini -i "$(cat ${seed})"`
+  },
+  {
+    id: "opencode",
+    displayName: "OpenCode",
+    bin: "opencode",
+    launch: (cwd) => `cd ${cwd} 2>/dev/null; opencode`,
+    injectSeed: true
+  },
+  {
+    id: "cursor",
+    displayName: "Cursor CLI",
+    bin: "cursor-agent",
+    launch: (cwd, seed) => `cd ${cwd} 2>/dev/null; cursor-agent "$(cat ${seed})"`
   }
 ];
-function getFlagDefinition(name, registry = FLAG_REGISTRY) {
-  return registry.find((def) => def.name === name);
+function findAgentById(id) {
+  return AGENTS.find((a2) => a2.id === id);
 }
-var PROJECT_MARKERS = [".argent", ".git", "package.json"];
-function resolveProjectRoot(startDir) {
-  const initial = path9.resolve(startDir);
-  let current = initial;
-  while (true) {
-    for (const marker of PROJECT_MARKERS) {
-      if (fs8.existsSync(path9.join(current, marker))) return current;
+function agentIds() {
+  return AGENTS.map((a2) => a2.id);
+}
+function defaultIsOnPath(bin) {
+  try {
+    execFileSync3(process.platform === "win32" ? "where" : "which", [bin], {
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isAgentInstalled(agent, isOnPath = defaultIsOnPath) {
+  return isOnPath(agent.bin);
+}
+function detectInstalledAgents(isOnPath = defaultIsOnPath) {
+  return AGENTS.filter((a2) => isOnPath(a2.bin));
+}
+
+// ../argent-cli/src/lens.ts
+var LIVENESS_POLL_MS = 1200;
+var SPAWN_GRACE_MS = 8e3;
+var DEATH_CONFIRMATIONS = 3;
+var SSE_RECONNECT_MS = 1e3;
+function sleep2(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+var TRUST_PROMPT_RE = /trust this folder|do you trust|yes,? i trust|trust the files in this/i;
+async function dismissTrustPrompt(session) {
+  const deadline = Date.now() + 12e3;
+  while (Date.now() < deadline) {
+    await sleep2(700);
+    const text2 = readSessionText(session);
+    if (text2 == null) {
+      pressEnter(session);
+      return;
+    }
+    if (TRUST_PROMPT_RE.test(text2)) {
+      pressEnter(session);
+      return;
     }
-    const parent = path9.dirname(current);
-    if (parent === current) return initial;
-    current = parent;
   }
 }
-function getFlagsPath(scope, options = {}) {
-  const home = options.homeDir ?? homedir5();
-  if (scope === "global") {
-    return path9.join(home, ".argent", "flags.json");
+function dismissTrustPromptViaPty(proxy) {
+  let acc = "";
+  let done = false;
+  const deadline = Date.now() + 12e3;
+  proxy.onData((chunk) => {
+    if (done) return;
+    if (Date.now() > deadline) {
+      done = true;
+      return;
+    }
+    acc += chunk;
+    if (TRUST_PROMPT_RE.test(acc)) {
+      done = true;
+      proxy.write("\r");
+    }
+  });
+}
+async function injectSeedViaPty(proxy) {
+  await sleep2(5e3);
+  proxy.inject(buildSeedPrompt());
+}
+function isInteractiveTty() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+var errMsg = (e) => e instanceof Error ? e.message : String(e);
+function planAgent(agentId) {
+  if (agentId) {
+    const want = findAgentById(agentId);
+    if (!want) {
+      process.stderr.write(
+        `lens: unknown agent "${agentId}". Choose one of: ${agentIds().join(", ")}
+`
+      );
+      process.exit(2);
+    }
+    if (!isAgentInstalled(want)) {
+      process.stderr.write(
+        `lens: ${want.displayName} (${want.bin}) is not installed or not on PATH.
+`
+      );
+      process.exit(1);
+    }
+    return { agent: want };
   }
-  const cwd = options.cwd ?? process.cwd();
-  return path9.join(resolveProjectRoot(cwd), ".argent", "flags.json");
+  const installed = detectInstalledAgents();
+  if (installed.length === 0) {
+    process.stderr.write(
+      `lens: no supported coding-agent CLI found on PATH.
+  Install one of: ${AGENTS.map((a2) => a2.bin).join(", ")}, then re-run argent lens.
+`
+    );
+    process.exit(1);
+  }
+  const remembered = getRememberedAgent();
+  if (remembered) {
+    const found = installed.find((a2) => a2.id === remembered);
+    if (found) return { agent: found };
+  }
+  if (installed.length === 1) return { agent: installed[0] };
+  return { choose: installed };
 }
-function readFlagsFile(filePath) {
-  let raw;
+async function injectSeedAfterBoot(session) {
+  await sleep2(5e3);
+  writeToSession(session, buildSeedPrompt());
+}
+function buildSeedPrompt() {
+  return [
+    "You are running inside an Argent Lens CLI session. The user has the Argent Lens",
+    "preview window open and bound to THIS terminal.",
+    "",
+    "Match your response to the request. If it has a single obvious outcome \u2014 moving or",
+    "renaming something, tweaking one value, or anything with no meaningful design",
+    "alternatives \u2014 just make the change directly and report what you did; do not",
+    'manufacture variants. Only when the request is genuinely open-ended ("restyle",',
+    '"redesign", "make it nicer", or anything with a real design space) should you stage',
+    "variants with the `propose_variant` Argent tool \u2014 at least two per element so the",
+    "user has a real choice.",
+    "",
+    "Either way, end your turn when you're done \u2014 you never block waiting for a pick in",
+    "this session (feedback comes back to you as a message).",
+    "",
+    "The user reviews any staged variants in the Lens window; their feedback arrives here",
+    'as a normal message prefixed "[Argent Lens]" (the variants they chose, comments, and',
+    "change requests). Act on it the same way \u2014 direct edits for concrete fixes, fresh",
+    "variants only where the design is still open.",
+    "",
+    "Wait for the user's first instruction."
+  ].join(" ");
+}
+function formatLensFeedback(o2) {
+  const parts = [];
+  const sel = (m) => `[${m.by}=${m.value}]`;
+  const chosen = o2.selections.filter((s) => s.chosenVariant);
+  if (chosen.length) {
+    parts.push(
+      "Chosen variants \u2014 " + chosen.map((s) => {
+        const v = s.chosenVariant;
+        const summary = v.summary ? ` (${v.summary})` : "";
+        const where = v.filePath ? ` [src: ${v.filePath}]` : "";
+        const note = s.comment ? ` (note: ${s.comment})` : "";
+        return `"${s.element}" ${sel(s.match)} \u2192 "${v.name}"${summary}${where}${note}`;
+      }).join("; ")
+    );
+  }
+  const notedNoPick = o2.selections.filter((s) => !s.chosenVariant && s.comment);
+  if (notedNoPick.length) {
+    parts.push(
+      "Element notes \u2014 " + notedNoPick.map((s) => `"${s.element}" ${sel(s.match)}: ${s.comment}`).join("; ")
+    );
+  }
+  const touched = new Set([...chosen, ...notedNoPick].map((s) => s.element));
+  const leftAsIs = o2.unselected.map((u3) => u3.element).filter((e) => !touched.has(e));
+  if (leftAsIs.length) {
+    parts.push("Left as-is (reviewed, no change) \u2014 " + leftAsIs.map((e) => `"${e}"`).join(", "));
+  }
+  if (o2.annotations.length) {
+    parts.push(
+      "Comments on the screen \u2014 " + o2.annotations.map((a2) => `"${a2.target}" ${sel(a2.match)}: ${a2.comment}`).join("; ")
+    );
+  }
+  if (o2.globalComment) parts.push("Overall direction \u2014 " + o2.globalComment);
+  const body = parts.length ? parts.join(". ") : "No specific picks were made; review the current variants in the preview window.";
+  const chosenWithComment = chosen.filter((s) => s.comment);
+  const hasDirection = chosenWithComment.length > 0 || notedNoPick.length > 0 || o2.annotations.length > 0 || Boolean(o2.globalComment);
+  const applyChosen = chosen.length ? "Apply the chosen variants to their source files where given. " : "";
+  const closing = hasDirection ? "Handle each request with the smallest change that satisfies it: for a single obvious outcome (a move, rename, or one-value tweak) just make the edit and report it; stage fresh propose_variant options (at least two per element) only where the direction is genuinely open-ended. Then end your turn." : "Nothing further is requested \u2014 make no other changes unless the user asks, and end your turn.";
+  return flattenLine(
+    `[Argent Lens] Feedback from the preview window (round ${o2.round}). ${body}. ` + applyChosen + closing
+  );
+}
+function parseArgs(argv) {
+  let terminal;
+  let agent;
+  let help = false;
+  let forget2 = false;
+  for (let i2 = 0; i2 < argv.length; i2++) {
+    const tok = argv[i2];
+    if (tok === "--help" || tok === "-h") help = true;
+    else if (tok === "--forget") forget2 = true;
+    else if (tok === "--terminal" || tok === "-t") {
+      const v = argv[++i2];
+      if (v === "iterm" || v === "terminal") terminal = v;
+      else {
+        process.stderr.write(`lens: --terminal expects "iterm" or "terminal", got "${v ?? ""}"
+`);
+        process.exit(2);
+      }
+    } else if (tok === "--agent" || tok === "-a") {
+      agent = argv[++i2];
+      if (!agent) {
+        process.stderr.write(`lens: --agent expects one of: ${agentIds().join(", ")}
+`);
+        process.exit(2);
+      }
+    }
+  }
+  return { terminal, agent, help, forget: forget2 };
+}
+function printHelp() {
+  process.stdout.write(
+    `Usage: argent lens [--agent <id>] [--terminal iterm|terminal]
+
+Open Argent Lens bound to a fresh coding-agent session.
+
+  Opens the Lens preview window and runs your agent IN THIS terminal (it takes
+  over the current window). When you request changes in the preview window they
+  are typed into that agent session as its next prompt. Pick the agent in the
+  window when more than one is installed, or pass --agent. The window streams a
+  running simulator, or offers an in-window picker to boot one. Lens ends when
+  you close the agent.
+
+  If this terminal isn't iTerm or Terminal.app (e.g. tmux / VS Code), the agent
+  opens in a new window instead.
+
+Options:
+  -a, --agent <id>       Agent to bind: ${agentIds().join(", ")}
+  -t, --terminal <app>   Terminal for the new-window fallback (iterm preferred)
+      --forget           Forget the remembered agent, then exit
+  -h, --help             Show this help
+`
+  );
+}
+async function lens(argv, options) {
+  const { terminal: preferred, agent: agentId, help, forget: forget2 } = parseArgs(argv);
+  if (help) {
+    printHelp();
+    return;
+  }
+  if (forget2) {
+    const had = getRememberedAgent();
+    clearRememberedAgent();
+    process.stdout.write(
+      had ? `  Forgot the remembered agent ("${had}"). The picker will show again next run.
+` : "  No agent was remembered.\n"
+    );
+    return;
+  }
+  if (process.platform !== "darwin") {
+    process.stderr.write(
+      "argent lens is macOS-only \u2014 it drives Terminal/iTerm via osascript to run and\nfeed the agent session.\n"
+    );
+    process.exit(1);
+  }
+  if (!isFlagEnabled("argent-lens")) {
+    process.stderr.write(
+      "Argent Lens is behind a feature flag. Enable it first:\n\n  argent enable argent-lens\n\n"
+    );
+    process.exit(1);
+  }
+  const plan = planAgent(agentId);
+  const choices = "choose" in plan ? plan.choose : [];
+  const client2 = createToolsClient({ paths: options.paths });
+  let baseUrl;
   try {
-    raw = fs8.readFileSync(filePath, "utf8");
-  } catch {
-    return {};
+    baseUrl = (await client2.baseUrl()).url;
+  } catch (err) {
+    process.stderr.write(`lens: could not reach the tool-server: ${errMsg(err)}
+`);
+    process.exit(1);
   }
-  let parsed;
+  const previewUrl = `${baseUrl}/preview/`;
   try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return {};
+    const res = await fetch(`${baseUrl}/preview/cli-session`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        active: true,
+        agents: choices.map((a2) => ({ id: a2.id, name: a2.displayName }))
+      })
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  } catch (err) {
+    process.stderr.write(`lens: failed to start the Lens session: ${errMsg(err)}
+`);
+    process.exit(1);
   }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
-  const flags2 = parsed.flags;
-  if (!flags2 || typeof flags2 !== "object" || Array.isArray(flags2)) return {};
-  const out = {};
-  for (const [k, v] of Object.entries(flags2)) {
-    if (typeof v === "boolean") out[k] = v;
+  let agent = "agent" in plan ? plan.agent : void 0;
+  if (!agent) {
+    process.stdout.write(
+      `
+  Argent Lens window is open: ${previewUrl}
+  Pick an agent in the window to start\u2026
+`
+    );
+    const picked = await awaitAgentChoiceViaStream(baseUrl);
+    if (picked) {
+      agent = findAgentById(picked.id);
+      if (agent && picked.remember) setRememberedAgent(agent.id);
+    }
   }
-  return out;
-}
-function writeFlagsFile(filePath, flags2) {
-  if (Object.keys(flags2).length === 0) {
-    if (fs8.existsSync(filePath)) fs8.rmSync(filePath, { force: true });
-    const parent = path9.dirname(filePath);
+  if (!agent) {
+    process.stderr.write("lens: no agent was chosen \u2014 closing the Lens session.\n");
+    await endSession(baseUrl);
+    process.exit(1);
+  }
+  const seedFile = path11.join(os2.tmpdir(), `argent-lens-seed-${process.pid}-${Date.now()}.txt`);
+  fs9.writeFileSync(seedFile, buildSeedPrompt(), "utf8");
+  const launchCmd = agent.launch(shellQuote(process.cwd()), shellQuote(seedFile));
+  const removeSeedFile = () => {
     try {
-      if (fs8.existsSync(parent) && fs8.readdirSync(parent).length === 0) {
-        fs8.rmdirSync(parent);
-      }
+      fs9.rmSync(seedFile, { force: true });
     } catch {
     }
-    return;
+  };
+  const ptyMod = isInteractiveTty() ? loadNodePty() : null;
+  let inject;
+  let registerDeath;
+  let quiet = false;
+  let killAgent = () => {
+  };
+  if (ptyMod) {
+    let proxy;
+    try {
+      proxy = startPtyProxy({ pty: ptyMod, command: launchCmd, cwd: process.cwd() });
+    } catch (err) {
+      process.stderr.write(`lens: failed to start the agent PTY: ${errMsg(err)}
+`);
+      removeSeedFile();
+      await endSession(baseUrl);
+      process.exit(1);
+    }
+    quiet = true;
+    dismissTrustPromptViaPty(proxy);
+    if (agent.injectSeed) void injectSeedViaPty(proxy);
+    inject = (text2) => proxy.inject(text2);
+    registerDeath = (onDeath) => proxy.onExit(() => onDeath());
+    killAgent = () => proxy.dispose();
+  } else {
+    const term = resolveTerminal(preferred);
+    let session;
+    try {
+      session = spawnTerminalSession(launchCmd, term);
+    } catch (err) {
+      process.stderr.write(`lens: failed to spawn the agent: ${errMsg(err)}
+`);
+      removeSeedFile();
+      await endSession(baseUrl);
+      process.exit(1);
+    }
+    process.stdout.write(
+      `
+  Argent Lens is live.
+
+    \u2022 Agent:           ${agent.displayName} (new window)
+    \u2022 Preview window:  ${previewUrl}
+
+  Ask the agent to redesign something; review the variants in the window and
+  request changes \u2014 they're queued to the agent automatically. End it by
+  closing the agent terminal.
+
+`
+    );
+    void dismissTrustPrompt(session);
+    if (agent.injectSeed) void injectSeedAfterBoot(session);
+    inject = (text2) => writeToSession(session, text2);
+    registerDeath = (onDeath) => pollSessionDeath(session, onDeath);
+  }
+  let tearingDown = false;
+  const teardown = (code) => {
+    if (tearingDown) return;
+    tearingDown = true;
+    killAgent();
+    void endSession(baseUrl).finally(() => {
+      removeSeedFile();
+      process.exit(code);
+    });
+  };
+  const onSignal = () => {
+    teardown(0);
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  await runRelaySession(baseUrl, inject, registerDeath, quiet);
+  teardown(0);
+}
+var AGENT_CHOICE_MAX_RECONNECTS = 60;
+async function awaitAgentChoiceViaStream(baseUrl) {
+  const ac = new AbortController();
+  let reconnects = 0;
+  try {
+    while (!ac.signal.aborted && reconnects <= AGENT_CHOICE_MAX_RECONNECTS) {
+      try {
+        for await (const ev of lensEvents(baseUrl, ac.signal)) {
+          reconnects = 0;
+          if (ev.event === "session-end") return null;
+          if (ev.event === "agent-choice") {
+            try {
+              const payload = JSON.parse(ev.data);
+              if (payload && typeof payload.id === "string" && payload.id) {
+                return { id: payload.id, remember: Boolean(payload.remember) };
+              }
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+      reconnects++;
+      if (ac.signal.aborted || reconnects > AGENT_CHOICE_MAX_RECONNECTS) break;
+      await sleep2(SSE_RECONNECT_MS);
+    }
+  } finally {
+    ac.abort();
   }
-  fs8.mkdirSync(path9.dirname(filePath), { recursive: true });
-  const tmp = `${filePath}.${process.pid}.tmp`;
-  fs8.writeFileSync(tmp, JSON.stringify({ flags: flags2 }, null, 2) + "\n");
-  fs8.renameSync(tmp, filePath);
+  return null;
 }
-function readFlags(scope, options = {}) {
-  return readFlagsFile(getFlagsPath(scope, options));
+function pollSessionDeath(session, onDeath) {
+  const spawnedAt = Date.now();
+  let deathStreak = 0;
+  const timer = setInterval(() => {
+    if (Date.now() - spawnedAt <= SPAWN_GRACE_MS) return;
+    if (!isSessionAlive(session)) {
+      if (++deathStreak >= DEATH_CONFIRMATIONS) {
+        clearInterval(timer);
+        onDeath();
+      }
+    } else {
+      deathStreak = 0;
+    }
+  }, LIVENESS_POLL_MS);
+  timer.unref?.();
 }
-function setFlag(name, value, scope, options = {}) {
-  const filePath = getFlagsPath(scope, options);
-  const current = readFlagsFile(filePath);
-  current[name] = value;
-  writeFlagsFile(filePath, current);
+async function runRelaySession(baseUrl, inject, registerDeath, quiet) {
+  const log2 = (s) => {
+    if (!quiet) process.stdout.write(s);
+  };
+  const ac = new AbortController();
+  let alive = true;
+  const stop = () => {
+    if (!alive) return;
+    alive = false;
+    ac.abort();
+  };
+  registerDeath(() => {
+    log2("\n  Agent exited.\n");
+    stop();
+  });
+  let lastCompletedAt = 0;
+  try {
+    const seed = await fetchOutcomeOnce(baseUrl);
+    if (seed) lastCompletedAt = seed.completedAt;
+  } catch {
+  }
+  while (alive && !ac.signal.aborted) {
+    try {
+      for await (const ev of lensEvents(baseUrl, ac.signal)) {
+        if (!alive) break;
+        if (ev.event === "session-end") return;
+        if (ev.event !== "outcome") continue;
+        let outcome = null;
+        try {
+          outcome = JSON.parse(ev.data);
+        } catch {
+          continue;
+        }
+        if (outcome && outcome.status === "completed" && outcome.completedAt > lastCompletedAt) {
+          lastCompletedAt = outcome.completedAt;
+          const ok = inject(formatLensFeedback(outcome));
+          if (ok) {
+            const n2 = outcome.selections.filter((s) => s.chosenVariant).length;
+            log2(`  \u2192 relayed feedback to the agent (${n2} pick(s)).
+`);
+          } else {
+            log2("  ! could not reach the agent (it may have exited).\n");
+          }
+        }
+      }
+    } catch {
+    }
+    if (alive && !ac.signal.aborted) await sleep2(SSE_RECONNECT_MS);
+  }
 }
-function unsetFlag(name, scope, options = {}) {
-  const filePath = getFlagsPath(scope, options);
-  const current = readFlagsFile(filePath);
-  if (!Object.hasOwn(current, name)) return false;
-  delete current[name];
-  writeFlagsFile(filePath, current);
-  return true;
+async function fetchOutcomeOnce(baseUrl) {
+  const res = await fetch(`${baseUrl}/preview/outcome`, { cache: "no-store" });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  const body = await res.json();
+  return body.outcome && body.outcome.status === "completed" ? body.outcome : null;
 }
-function isFlagEnabled(name, options = {}) {
-  const projectFlags = readFlags("project", options);
-  if (Object.hasOwn(projectFlags, name)) return projectFlags[name];
-  const globalFlags = readFlags("global", options);
-  if (Object.hasOwn(globalFlags, name)) return globalFlags[name];
-  return false;
+async function endSession(baseUrl) {
+  try {
+    await fetch(`${baseUrl}/preview/cli-session`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ active: false })
+    });
+  } catch {
+  }
 }
 
 // ../argent-cli/src/flags.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
 function colorState(enabled) {
   const label = (enabled ? "enabled" : "disabled").padEnd(8);
   if (!process.stdout.isTTY) return label;
@@ -8468,7 +9423,7 @@ var fastStringWidth = (input, options = {}) => {
 var dist_default2 = fastStringWidth;
 
 // ../../node_modules/fast-wrap-ansi/lib/main.js
-var ESC = "\x1B";
+var ESC2 = "\x1B";
 var CSI = "\x9B";
 var END_CODE = 39;
 var ANSI_ESCAPE_BELL = "\x07";
@@ -8502,8 +9457,8 @@ var getClosingCode = (openingCode) => {
     return 0;
   return void 0;
 };
-var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
-var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapAnsiCode = (code) => `${ESC2}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC2}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
 var wrapWord = (rows, word, columns) => {
   const characters = word[Symbol.iterator]();
   let isInsideEscape = false;
@@ -8522,7 +9477,7 @@ var wrapWord = (rows, word, columns) => {
       rows.push(character);
       visible = 0;
     }
-    if (character === ESC || character === CSI) {
+    if (character === ESC2 || character === CSI) {
       isInsideEscape = true;
       isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
     }
@@ -8640,7 +9595,7 @@ var exec = (string, columns, options = {}) => {
     } else {
       inSurrogate = false;
     }
-    if (character === ESC || character === CSI) {
+    if (character === ESC2 || character === CSI) {
       GROUP_REGEX.lastIndex = i2 + 1;
       const groupsResult = GROUP_REGEX.exec(preString);
       const groups = groupsResult?.groups;
@@ -9052,8 +10007,8 @@ var n = class extends V {
 import { styleText as styleText2, stripVTControlCharacters } from "node:util";
 import process$1 from "node:process";
 var import_sisteransi2 = __toESM(require_src(), 1);
-import { existsSync as existsSync5, lstatSync as lstatSync3, readdirSync as readdirSync2 } from "node:fs";
-import { dirname as dirname5, join as join9 } from "node:path";
+import { existsSync as existsSync6, lstatSync as lstatSync3, readdirSync as readdirSync2 } from "node:fs";
+import { dirname as dirname5, join as join11 } from "node:path";
 function isUnicodeSupported() {
   if (process$1.platform !== "win32") {
     return process$1.env.TERM !== "linux";
@@ -10024,6 +10979,7 @@ export {
   flags,
   getFlagDefinition,
   isFlagEnabled,
+  lens,
   link,
   run,
   server,