gipity 1.0.427 → 1.0.429

package/dist/index.js

@@ -1166,7 +1166,7 @@ var require_command = __commonJS({
   "node_modules/commander/lib/command.js"(exports) {
     var EventEmitter = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
-    var path4 = __require("node:path");
+    var path5 = __require("node:path");
     var fs6 = __require("node:fs");
     var process2 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -2166,9 +2166,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path4.resolve(baseDir, baseName);
+          const localBin = path5.resolve(baseDir, baseName);
           if (fs6.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path4.extname(baseName))) return void 0;
+          if (sourceExt.includes(path5.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs6.existsSync(`${localBin}${ext}`)
           );
@@ -2186,17 +2186,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path4.resolve(
-            path4.dirname(resolvedScriptPath),
+          executableDir = path5.resolve(
+            path5.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path4.basename(
+            const legacyName = path5.basename(
               this._scriptPath,
-              path4.extname(this._scriptPath)
+              path5.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2207,7 +2207,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path4.extname(executableFile));
+        launchWithNode = sourceExt.includes(path5.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -3054,7 +3054,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path4.basename(filename, path4.extname(filename));
+        this._name = path5.basename(filename, path5.extname(filename));
         return this;
       }
       /**
@@ -3068,9 +3068,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path5) {
-        if (path5 === void 0) return this._executableDir;
-        this._executableDir = path5;
+      executableDir(path6) {
+        if (path6 === void 0) return this._executableDir;
+        this._executableDir = path6;
         return this;
       }
       /**
@@ -3639,7 +3639,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path4, checkUnignored, mode) {
+      test(path5, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -3648,7 +3648,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path4);
+          const matched = rule[mode].test(path5);
           if (!matched) {
             return;
           }
@@ -3669,17 +3669,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path4, originalPath, doThrow) => {
-      if (!isString(path4)) {
+    var checkPath = (path5, originalPath, doThrow) => {
+      if (!isString(path5)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path4) {
+      if (!path5) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path4)) {
+      if (checkPath.isNotRelative(path5)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -3688,7 +3688,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path4) => REGEX_TEST_INVALID_PATH.test(path4);
+    var isNotRelative = (path5) => REGEX_TEST_INVALID_PATH.test(path5);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -3718,19 +3718,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path4 = originalPath && checkPath.convert(originalPath);
+        const path5 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path4,
+          path5,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path4, cache, checkUnignored, slices);
+        return this._t(path5, cache, checkUnignored, slices);
       }
-      checkIgnore(path4) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path4)) {
-          return this.test(path4);
+      checkIgnore(path5) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path5)) {
+          return this.test(path5);
         }
-        const slices = path4.split(SLASH).filter(Boolean);
+        const slices = path5.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -3743,18 +3743,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path4, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path5, false, MODE_CHECK_IGNORE);
       }
-      _t(path4, cache, checkUnignored, slices) {
-        if (path4 in cache) {
-          return cache[path4];
+      _t(path5, cache, checkUnignored, slices) {
+        if (path5 in cache) {
+          return cache[path5];
         }
         if (!slices) {
-          slices = path4.split(SLASH).filter(Boolean);
+          slices = path5.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path4] = this._rules.test(path4, checkUnignored, MODE_IGNORE);
+          return cache[path5] = this._rules.test(path5, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -3762,29 +3762,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path4] = parent.ignored ? parent : this._rules.test(path4, checkUnignored, MODE_IGNORE);
+        return cache[path5] = parent.ignored ? parent : this._rules.test(path5, checkUnignored, MODE_IGNORE);
       }
-      ignores(path4) {
-        return this._test(path4, this._ignoreCache, false).ignored;
+      ignores(path5) {
+        return this._test(path5, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path4) => !this.ignores(path4);
+        return (path5) => !this.ignores(path5);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path4) {
-        return this._test(path4, this._testCache, true);
+      test(path5) {
+        return this._test(path5, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path4) => checkPath(path4 && checkPath.convert(path4), path4, RETURN_FALSE);
+    var isPathValid = (path5) => checkPath(path5 && checkPath.convert(path5), path5, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path4) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path4) || isNotRelative(path4);
+      checkPath.isNotRelative = (path5) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path5) || isNotRelative(path5);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -3944,10 +3944,10 @@ function prompt(question) {
     return Promise.reject(new Error(`prompt() called without a TTY: ${question.trim()}`));
   }
   const rl2 = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     rl2.question(question, (answer) => {
       rl2.close();
-      resolve18(answer.trim());
+      resolve19(answer.trim());
     });
   });
 }
@@ -3977,7 +3977,7 @@ async function confirm(question, opts = {}) {
   const wasRaw = stdin.isRaw ?? false;
   stdin.setRawMode(true);
   stdin.resume();
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     stdin.once("data", (key) => {
       stdin.setRawMode(wasRaw);
       stdin.pause();
@@ -3992,12 +3992,12 @@ async function confirm(question, opts = {}) {
       else if (k7 === "n") answer = false;
       else answer = defaultYes;
       console.log(answer ? "y" : "n");
-      resolve18(answer);
+      resolve19(answer);
     });
   });
 }
 function pickOne(label2, max, defaultIdx = 1) {
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     process.stdout.write(`  ${bold(label2)} (1-${max}) [${bold(String(defaultIdx))}]: `);
     const { stdin } = process;
     const wasRaw = stdin.isRaw ?? false;
@@ -4013,15 +4013,15 @@ function pickOne(label2, max, defaultIdx = 1) {
       }
       if (ch === "\r" || ch === "\n") {
         console.log(String(defaultIdx));
-        return resolve18(defaultIdx);
+        return resolve19(defaultIdx);
       }
       const n = parseInt(ch, 10);
       if (n >= 1 && n <= max) {
         console.log(String(n));
-        return resolve18(n);
+        return resolve19(n);
       }
       console.log(String(defaultIdx));
-      resolve18(defaultIdx);
+      resolve19(defaultIdx);
     });
   });
 }
@@ -5370,8 +5370,8 @@ var require_streamx = __commonJS({
             return this;
           },
           next() {
-            return new Promise(function(resolve18, reject) {
-              promiseResolve = resolve18;
+            return new Promise(function(resolve19, reject) {
+              promiseResolve = resolve19;
               promiseReject = reject;
               const data = stream.read();
               if (data !== null) ondata(data);
@@ -5401,11 +5401,11 @@ var require_streamx = __commonJS({
         }
         function destroy(err) {
           stream.destroy(err);
-          return new Promise((resolve18, reject) => {
-            if (stream._duplexState & DESTROYED) return resolve18({ value: void 0, done: true });
+          return new Promise((resolve19, reject) => {
+            if (stream._duplexState & DESTROYED) return resolve19({ value: void 0, done: true });
             stream.once("close", function() {
               if (err) reject(err);
-              else resolve18({ value: void 0, done: true });
+              else resolve19({ value: void 0, done: true });
             });
           });
         }
@@ -5449,8 +5449,8 @@ var require_streamx = __commonJS({
         const writes = pending + (ws2._duplexState & WRITE_WRITING ? 1 : 0);
         if (writes === 0) return Promise.resolve(true);
         if (state.drains === null) state.drains = [];
-        return new Promise((resolve18) => {
-          state.drains.push({ writes, resolve: resolve18 });
+        return new Promise((resolve19) => {
+          state.drains.push({ writes, resolve: resolve19 });
         });
       }
       write(data) {
@@ -5555,10 +5555,10 @@ var require_streamx = __commonJS({
       cb2(null);
     }
     function pipelinePromise(...streams) {
-      return new Promise((resolve18, reject) => {
+      return new Promise((resolve19, reject) => {
         return pipeline(...streams, (err) => {
           if (err) return reject(err);
-          resolve18();
+          resolve19();
         });
       });
     }
@@ -6213,16 +6213,16 @@ var require_extract = __commonJS({
           entryCallback = null;
           cb2(err);
         }
-        function onnext(resolve18, reject) {
+        function onnext(resolve19, reject) {
           if (error2) {
             return reject(error2);
           }
           if (entryStream) {
-            resolve18({ value: entryStream, done: false });
+            resolve19({ value: entryStream, done: false });
             entryStream = null;
             return;
           }
-          promiseResolve = resolve18;
+          promiseResolve = resolve19;
           promiseReject = reject;
           consumeCallback(null);
           if (extract3._finished && promiseResolve) {
@@ -6250,11 +6250,11 @@ var require_extract = __commonJS({
         function destroy(err) {
           extract3.destroy(err);
           consumeCallback(err);
-          return new Promise((resolve18, reject) => {
-            if (extract3.destroyed) return resolve18({ value: void 0, done: true });
+          return new Promise((resolve19, reject) => {
+            if (extract3.destroyed) return resolve19({ value: void 0, done: true });
             extract3.once("close", function() {
               if (err) reject(err);
-              else resolve18({ value: void 0, done: true });
+              else resolve19({ value: void 0, done: true });
             });
           });
         }
@@ -6662,16 +6662,16 @@ async function getAuthHeader() {
   const headers = await getHeaders();
   return headers.Authorization;
 }
-async function request(method, path4, body, retrying = false) {
+async function request(method, path5, body, retrying = false) {
   const headers = await getHeaders();
-  const url = `${baseUrl()}${path4}`;
+  const url = `${baseUrl()}${path5}`;
   const res = await fetchWithTimeout(url, {
     method,
     headers,
     body: body ? JSON.stringify(body) : void 0
-  }, REQUEST_TIMEOUT_MS, `${method} ${path4}`);
+  }, REQUEST_TIMEOUT_MS, `${method} ${path5}`);
   if (await shouldRetryAfter401(res.status, retrying)) {
-    return request(method, path4, body, true);
+    return request(method, path5, body, true);
   }
   if (!res.ok) {
     const json = await res.json().catch(() => ({ error: { code: "UNKNOWN", message: res.statusText } }));
@@ -6680,22 +6680,22 @@ async function request(method, path4, body, retrying = false) {
   }
   return res.json();
 }
-function get(path4) {
-  return request("GET", path4);
+function get(path5) {
+  return request("GET", path5);
 }
-function post(path4, body) {
-  return request("POST", path4, body);
+function post(path5, body) {
+  return request("POST", path5, body);
 }
-async function postForTarEntries(path4, body, retried = false) {
+async function postForTarEntries(path5, body, retried = false) {
   const headers = await getHeaders();
-  const url = `${baseUrl()}${path4}`;
+  const url = `${baseUrl()}${path5}`;
   const res = await fetch(url, {
     method: "POST",
     headers,
     body: body ? JSON.stringify(body) : void 0
   });
   if (await shouldRetryAfter401(res.status, retried)) {
-    return postForTarEntries(path4, body, true);
+    return postForTarEntries(path5, body, true);
   }
   if (!res.ok) {
     const json = await res.json().catch(() => ({ error: { code: "UNKNOWN", message: res.statusText } }));
@@ -6705,7 +6705,7 @@ async function postForTarEntries(path4, body, retried = false) {
   if (!res.body) throw new ApiError(500, "EMPTY_RESPONSE", "Server returned no body");
   const extract3 = tar.extract();
   const entries = [];
-  const done = new Promise((resolve18, reject) => {
+  const done = new Promise((resolve19, reject) => {
     extract3.on("entry", (header, stream, next) => {
       const chunks = [];
       stream.on("data", (c) => chunks.push(c));
@@ -6716,21 +6716,21 @@ async function postForTarEntries(path4, body, retried = false) {
       stream.on("error", reject);
       stream.resume();
     });
-    extract3.on("finish", () => resolve18());
+    extract3.on("finish", () => resolve19());
     extract3.on("error", reject);
   });
   Readable.fromWeb(res.body).pipe(extract3);
   await done;
   return entries;
 }
-function put(path4, body) {
-  return request("PUT", path4, body);
+function put(path5, body) {
+  return request("PUT", path5, body);
 }
-function patch(path4, body) {
-  return request("PATCH", path4, body);
+function patch(path5, body) {
+  return request("PATCH", path5, body);
 }
-function del(path4, body) {
-  return request("DELETE", path4, body);
+function del(path5, body) {
+  return request("DELETE", path5, body);
 }
 async function sendMessage(message) {
   const config = requireConfig();
@@ -6743,26 +6743,26 @@ async function sendMessage(message) {
   }
   return res.data.content;
 }
-async function download(path4, retried = false) {
-  const url = `${baseUrl()}${path4}`;
+async function download(path5, retried = false) {
+  const url = `${baseUrl()}${path5}`;
   const res = await fetch(url, {
     headers: { ...clientHeaders(), "Authorization": `Bearer ${await bearerToken()}` }
   });
   if (await shouldRetryAfter401(res.status, retried)) {
-    return download(path4, true);
+    return download(path5, true);
   }
   if (!res.ok) {
     throw new ApiError(res.status, "DOWNLOAD_ERROR", with401Hint(res.status, `Download failed: ${res.statusText}`));
   }
   return Buffer.from(await res.arrayBuffer());
 }
-async function downloadWithHeaders(path4, retried = false) {
-  const url = `${baseUrl()}${path4}`;
+async function downloadWithHeaders(path5, retried = false) {
+  const url = `${baseUrl()}${path5}`;
   const res = await fetch(url, {
     headers: { ...clientHeaders(), "Authorization": `Bearer ${await bearerToken()}` }
   });
   if (await shouldRetryAfter401(res.status, retried)) {
-    return downloadWithHeaders(path4, true);
+    return downloadWithHeaders(path5, true);
   }
   if (!res.ok) {
     const json = await res.json().catch(() => ({ error: { code: "UNKNOWN", message: res.statusText } }));
@@ -6771,8 +6771,8 @@ async function downloadWithHeaders(path4, retried = false) {
   }
   return { buffer: Buffer.from(await res.arrayBuffer()), headers: res.headers };
 }
-async function postBinary(path4, body, contentType = "application/zip", retried = false) {
-  const url = `${baseUrl()}${path4}`;
+async function postBinary(path5, body, contentType = "application/zip", retried = false) {
+  const url = `${baseUrl()}${path5}`;
   const headers = {
     ...clientHeaders(),
     "Authorization": `Bearer ${await bearerToken()}`,
@@ -6782,9 +6782,9 @@ async function postBinary(path4, body, contentType = "application/zip", retried
     method: "POST",
     headers,
     body: new Uint8Array(body)
-  }, putTimeoutMs(body.length), `POST ${path4}`);
+  }, putTimeoutMs(body.length), `POST ${path5}`);
   if (await shouldRetryAfter401(res.status, retried)) {
-    return postBinary(path4, body, contentType, true);
+    return postBinary(path5, body, contentType, true);
   }
   if (!res.ok) {
     const json = await res.json().catch(() => ({ error: { code: "UNKNOWN", message: res.statusText } }));
@@ -6793,9 +6793,9 @@ async function postBinary(path4, body, contentType = "application/zip", retried
   }
   return { status: res.status, json: await res.json() };
 }
-async function downloadStream(path4, retried = false) {
+async function downloadStream(path5, retried = false) {
   const { Readable: Readable2 } = await import("stream");
-  const url = `${baseUrl()}${path4}`;
+  const url = `${baseUrl()}${path5}`;
   const ac2 = new AbortController();
   const headerTimer = setTimeout(() => ac2.abort(), DOWNLOAD_HEADER_TIMEOUT_MS);
   let res;
@@ -6813,7 +6813,7 @@ async function downloadStream(path4, retried = false) {
     clearTimeout(headerTimer);
   }
   if (await shouldRetryAfter401(res.status, retried)) {
-    return downloadStream(path4, true);
+    return downloadStream(path5, true);
   }
   if (!res.ok) {
     throw new ApiError(res.status, "DOWNLOAD_ERROR", with401Hint(res.status, `Download failed: ${res.statusText}`));
@@ -6862,8 +6862,8 @@ async function getAccountSlug() {
   accountSlugCache = res.data.accountSlug;
   return accountSlugCache;
 }
-async function publicPost(path4, body, extraHeaders) {
-  const url = `${baseUrl()}${path4}`;
+async function publicPost(path5, body, extraHeaders) {
+  const url = `${baseUrl()}${path5}`;
   const res = await fetch(url, {
     method: "POST",
     headers: { ...clientHeaders(), "Content-Type": "application/json", ...extraHeaders },
@@ -6973,15 +6973,15 @@ function getConfigPath() {
   return cachedPath;
 }
 function getProjectRoot() {
-  const path4 = getConfigPath();
-  return path4 ? dirname2(path4) : null;
+  const path5 = getConfigPath();
+  return path5 ? dirname2(path5) : null;
 }
 function getConfig() {
   if (cached3) return cached3;
-  const path4 = getConfigPath();
-  if (!path4) return null;
+  const path5 = getConfigPath();
+  if (!path5) return null;
   try {
-    cached3 = JSON.parse(readFileSync3(path4, "utf-8"));
+    cached3 = JSON.parse(readFileSync3(path5, "utf-8"));
     return cached3;
   } catch {
     return null;
@@ -7063,21 +7063,21 @@ function clearConfigCache() {
   cachedPath = null;
 }
 function saveConfig(data) {
-  const path4 = getConfigPath();
-  if (!path4) {
+  const path5 = getConfigPath();
+  if (!path5) {
     throw new Error(
       "saveConfig: no .gipity.json found to update. Use saveConfigAt(dir, \u2026) to create a new project config."
     );
   }
-  writeFileSync2(path4, JSON.stringify(data, null, 2) + "\n");
+  writeFileSync2(path5, JSON.stringify(data, null, 2) + "\n");
   cached3 = data;
-  cachedPath = path4;
+  cachedPath = path5;
 }
 function saveConfigAt(dir, data) {
-  const path4 = resolve2(dir, CONFIG_FILE);
-  writeFileSync2(path4, JSON.stringify(data, null, 2) + "\n");
+  const path5 = resolve2(dir, CONFIG_FILE);
+  writeFileSync2(path5, JSON.stringify(data, null, 2) + "\n");
   cached3 = data;
-  cachedPath = path4;
+  cachedPath = path5;
 }
 function shouldIgnore(filePath, ignorePatterns) {
   if (ignorePatterns.length === 0) return false;
@@ -31860,7 +31860,7 @@ init_config();
 init_utils();
 import { readFileSync as readFileSync25 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname13, resolve as resolve17 } from "path";
+import { dirname as dirname13, resolve as resolve18 } from "path";
 
 // src/helpers/output.ts
 var frameOpen = false;
@@ -31900,16 +31900,16 @@ function printResult(text, opts, jsonData) {
   }
   console.log(text);
 }
-function pluckField(data, path4) {
-  return path4.split(".").reduce(
+function pluckField(data, path5) {
+  return path5.split(".").reduce(
     (acc, key) => acc == null ? void 0 : acc[key],
     data
   );
 }
-function emitField(data, path4) {
-  const value = pluckField(data, path4);
+function emitField(data, path5) {
+  const value = pluckField(data, path5);
   if (value === void 0) {
-    console.error(`Field not found: ${path4}`);
+    console.error(`Field not found: ${path5}`);
     process.exit(1);
   }
   console.log(typeof value === "object" && value !== null ? JSON.stringify(value) : String(value));
@@ -32171,13 +32171,13 @@ async function flushBugQueue() {
   let delivered = 0;
   for (const file of readdirSync(QUEUE_DIR)) {
     if (!file.endsWith(".json")) continue;
-    const path4 = join2(QUEUE_DIR, file);
+    const path5 = join2(QUEUE_DIR, file);
     let report;
     try {
-      report = JSON.parse(readFileSync4(path4, "utf-8"));
+      report = JSON.parse(readFileSync4(path5, "utf-8"));
     } catch {
       try {
-        unlinkSync2(path4);
+        unlinkSync2(path5);
       } catch {
       }
       continue;
@@ -32189,7 +32189,7 @@ async function flushBugQueue() {
         summary: report.summary,
         detail: report.detail
       });
-      unlinkSync2(path4);
+      unlinkSync2(path5);
       delivered++;
     } catch {
     }
@@ -32347,32 +32347,32 @@ var MIME_BY_EXT = {
   ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
   ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
 };
-function guessMime(path4) {
-  return MIME_BY_EXT[extname(path4).toLowerCase()] ?? "application/octet-stream";
+function guessMime(path5) {
+  return MIME_BY_EXT[extname(path5).toLowerCase()] ?? "application/octet-stream";
 }
-async function hashFile(path4) {
+async function hashFile(path5) {
   const hash = createHash("sha256");
   let size = 0;
-  const stream = createReadStream(path4);
-  await new Promise((resolve18, reject) => {
+  const stream = createReadStream(path5);
+  await new Promise((resolve19, reject) => {
     stream.on("data", (chunk) => {
       const buf = chunk;
       hash.update(buf);
       size += buf.length;
     });
-    stream.on("end", () => resolve18());
+    stream.on("end", () => resolve19());
     stream.on("error", reject);
   });
   return { sha256: hash.digest("hex"), size };
 }
-function readRange(path4, start, end) {
-  return new Promise((resolve18, reject) => {
+function readRange(path5, start, end) {
+  return new Promise((resolve19, reject) => {
     const chunks = [];
-    const stream = createReadStream(path4, { start, end });
+    const stream = createReadStream(path5, { start, end });
     stream.on("data", (c) => {
       chunks.push(c);
     });
-    stream.on("end", () => resolve18(Buffer.concat(chunks)));
+    stream.on("end", () => resolve19(Buffer.concat(chunks)));
     stream.on("error", reject);
   });
 }
@@ -32395,10 +32395,10 @@ async function withRetry(label2, fn, attempts = 3) {
   throw lastErr;
 }
 var UploadConflictError = class extends Error {
-  constructor(currentServerVersion, path4) {
-    super(`Version mismatch for ${path4}: current serverVersion is ${currentServerVersion}`);
+  constructor(currentServerVersion, path5) {
+    super(`Version mismatch for ${path5}: current serverVersion is ${currentServerVersion}`);
     this.currentServerVersion = currentServerVersion;
-    this.path = path4;
+    this.path = path5;
     this.name = "UploadConflictError";
   }
   currentServerVersion;
@@ -32645,10 +32645,10 @@ function stripGipityHooks(settings) {
   if (Object.keys(hooks).length === 0) delete settings.hooks;
   return changed;
 }
-function readSettingsFile(path4) {
-  if (!existsSync4(path4)) return {};
+function readSettingsFile(path5) {
+  if (!existsSync4(path5)) return {};
   try {
-    return JSON.parse(readFileSync5(path4, "utf-8"));
+    return JSON.parse(readFileSync5(path5, "utf-8"));
   } catch {
     return {};
   }
@@ -32767,12 +32767,12 @@ function applySkillsBlock(existing) {
   return next.endsWith("\n") ? next : next + "\n";
 }
 function writeSkillsFile(relPath, wrap) {
-  const path4 = resolve3(process.cwd(), relPath);
-  mkdirSync3(dirname3(path4), { recursive: true });
-  const existing = existsSync4(path4) ? readFileSync5(path4, "utf-8") : null;
+  const path5 = resolve3(process.cwd(), relPath);
+  mkdirSync3(dirname3(path5), { recursive: true });
+  const existing = existsSync4(path5) ? readFileSync5(path5, "utf-8") : null;
   const baseNext = applySkillsBlock(existing);
   const next = wrap && existing === null ? wrap(baseNext) : baseNext;
-  if (next !== existing) writeFileSync4(path4, next);
+  if (next !== existing) writeFileSync4(path5, next);
 }
 function setupClaudeMd() {
   writeSkillsFile(PRIMER_FILES.claude);
@@ -32811,10 +32811,10 @@ function applyAiderConf(existing) {
 }
 function setupAiderMd() {
   writeSkillsFile(PRIMER_FILES.aider);
-  const path4 = resolve3(process.cwd(), AIDER_CONF_FILE);
-  const existing = existsSync4(path4) ? readFileSync5(path4, "utf-8") : null;
+  const path5 = resolve3(process.cwd(), AIDER_CONF_FILE);
+  const existing = existsSync4(path5) ? readFileSync5(path5, "utf-8") : null;
   const next = applyAiderConf(existing);
-  if (next !== null) writeFileSync4(path4, next);
+  if (next !== null) writeFileSync4(path5, next);
 }
 function setupGeminiMd() {
   writeSkillsFile(PRIMER_FILES.gemini);
@@ -32888,12 +32888,12 @@ var LOCK_WAIT_MS2 = 3e4;
 var LOCK_POLL_MS2 = 500;
 var LOCK_HEARTBEAT_MS = 15e3;
 var LOCK_STALE_MS = 9e4;
-function isLockReclaimable(path4, now = Date.now()) {
+function isLockReclaimable(path5, now = Date.now()) {
   let raw;
   let mtimeMs;
   try {
-    raw = readFileSync6(path4, "utf-8").trim();
-    mtimeMs = statSync(path4).mtimeMs;
+    raw = readFileSync6(path5, "utf-8").trim();
+    mtimeMs = statSync(path5).mtimeMs;
   } catch {
     return false;
   }
@@ -32907,8 +32907,8 @@ function isLockReclaimable(path4, now = Date.now()) {
   return now - mtimeMs > LOCK_STALE_MS;
 }
 async function acquireLock(progress) {
-  const path4 = lockPath();
-  mkdirSync4(dirname4(path4), { recursive: true });
+  const path5 = lockPath();
+  mkdirSync4(dirname4(path5), { recursive: true });
   const start = Date.now();
   let waitSpinner = null;
   const settleWait = (ok) => {
@@ -32919,12 +32919,12 @@ async function acquireLock(progress) {
   };
   while (true) {
     try {
-      const fd2 = openSync2(path4, "wx");
+      const fd2 = openSync2(path5, "wx");
       writeFileSync5(fd2, String(process.pid));
       closeSync2(fd2);
       const beat = setInterval(() => {
         try {
-          utimesSync(path4, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+          utimesSync(path5, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
         } catch {
         }
       }, LOCK_HEARTBEAT_MS);
@@ -32933,14 +32933,14 @@ async function acquireLock(progress) {
       return () => {
         clearInterval(beat);
         try {
-          unlinkSync3(path4);
+          unlinkSync3(path5);
         } catch {
         }
       };
     } catch {
-      if (isLockReclaimable(path4)) {
+      if (isLockReclaimable(path5)) {
         try {
-          unlinkSync3(path4);
+          unlinkSync3(path5);
         } catch {
         }
         continue;
@@ -32948,7 +32948,7 @@ async function acquireLock(progress) {
       if (Date.now() - start > LOCK_WAIT_MS2) {
         settleWait(false);
         throw new Error(
-          `Another sync is in progress (${path4}). Waited ${LOCK_WAIT_MS2 / 1e3}s. Remove the file manually if you're sure no sync is running.`
+          `Another sync is in progress (${path5}). Waited ${LOCK_WAIT_MS2 / 1e3}s. Remove the file manually if you're sure no sync is running.`
         );
       }
       if (!waitSpinner) {
@@ -32959,10 +32959,10 @@ async function acquireLock(progress) {
   }
 }
 function readBaseline(projectGuid) {
-  const path4 = syncStatePath();
-  if (!existsSync5(path4)) return { projectGuid, files: {}, lastFullSync: null };
+  const path5 = syncStatePath();
+  if (!existsSync5(path5)) return { projectGuid, files: {}, lastFullSync: null };
   try {
-    const parsed = JSON.parse(readFileSync6(path4, "utf-8"));
+    const parsed = JSON.parse(readFileSync6(path5, "utf-8"));
     if (parsed.projectGuid !== projectGuid) {
       return { projectGuid, files: {}, lastFullSync: null };
     }
@@ -32977,9 +32977,9 @@ function readBaseline(projectGuid) {
   }
 }
 function writeBaseline(b7) {
-  const path4 = syncStatePath();
-  mkdirSync4(dirname4(path4), { recursive: true });
-  writeFileSync5(path4, JSON.stringify(b7, null, 2));
+  const path5 = syncStatePath();
+  mkdirSync4(dirname4(path5), { recursive: true });
+  writeFileSync5(path5, JSON.stringify(b7, null, 2));
 }
 function walkLocal(root, ignorePatterns, baseline) {
   const result = /* @__PURE__ */ new Map();
@@ -33014,11 +33014,11 @@ function walkLocal(root, ignorePatterns, baseline) {
   return result;
 }
 async function ensureLocalHashes(root, local, paths) {
-  for (const path4 of paths) {
-    const info2 = local.get(path4);
+  for (const path5 of paths) {
+    const info2 = local.get(path5);
     if (!info2 || info2.sha256) continue;
     try {
-      const { sha256: sha2562 } = await hashFile(join4(root, path4));
+      const { sha256: sha2562 } = await hashFile(join4(root, path5));
       info2.sha256 = sha2562;
     } catch {
     }
@@ -33051,9 +33051,9 @@ async function fetchRemote(projectGuid) {
   const out = /* @__PURE__ */ new Map();
   for (const f of res.data) {
     if (f.type !== "file") continue;
-    const path4 = normalizeTreePath(f.path);
-    out.set(path4, {
-      path: path4,
+    const path5 = normalizeTreePath(f.path);
+    out.set(path5, {
+      path: path5,
       size: f.size,
       sha256: f.contentHash,
       serverVersion: f.serverVersion,
@@ -33065,7 +33065,7 @@ async function fetchRemote(projectGuid) {
 function extractTarToMap(stream, idleMs, onBytes, keep) {
   const extract3 = tar2.extract();
   const files = /* @__PURE__ */ new Map();
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve19, reject) => {
     let settled = false;
     let idle;
     const arm = () => {
@@ -33101,7 +33101,7 @@ function extractTarToMap(stream, idleMs, onBytes, keep) {
       });
       entryStream.resume();
     });
-    extract3.on("finish", () => done(resolve18, files));
+    extract3.on("finish", () => done(resolve19, files));
     extract3.on("error", (e) => done(reject, e));
     stream.on("error", (e) => done(reject, e));
     arm();
@@ -33112,12 +33112,12 @@ async function downloadAll(projectGuid, onBytes) {
   const stream = await downloadStream(`/projects/${projectGuid}/files/tree?content=tar`);
   return extractTarToMap(stream, DOWNLOAD_IDLE_MS, onBytes);
 }
-async function fetchOneOutcome(projectGuid, path4, expectedSha) {
+async function fetchOneOutcome(projectGuid, path5, expectedSha) {
   try {
     const stream = await downloadStream(
-      `/projects/${projectGuid}/files/tree?content=tar&path=${encodeURIComponent(path4)}`
+      `/projects/${projectGuid}/files/tree?content=tar&path=${encodeURIComponent(path5)}`
     );
-    const want = normalizeTreePath(path4);
+    const want = normalizeTreePath(path5);
     const files = await extractTarToMap(stream, DOWNLOAD_IDLE_MS, void 0, (p) => p === want);
     const buf = files.get(want) ?? null;
     if (!buf) return { kind: "transient" };
@@ -33131,8 +33131,8 @@ async function fetchOneOutcome(projectGuid, path4, expectedSha) {
     return { kind: "transient" };
   }
 }
-async function fetchOne(projectGuid, path4, expectedSha) {
-  const out = await fetchOneOutcome(projectGuid, path4, expectedSha);
+async function fetchOne(projectGuid, path5, expectedSha) {
+  const out = await fetchOneOutcome(projectGuid, path5, expectedSha);
   return out.kind === "ok" ? out.buf : null;
 }
 function classifyLocal(info2, base) {
@@ -33153,11 +33153,11 @@ function classifyRemote(info2, base) {
   if (iSha && bSha) return iSha === bSha ? "unchanged" : "modified";
   return info2.size === base.size ? "unchanged" : "modified";
 }
-function conflictedCopyName(path4) {
+function conflictedCopyName(path5) {
   const ts2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:T]/g, "-").replace(/\..+$/, "");
   const host = hostname().replace(/[^A-Za-z0-9._-]/g, "_");
-  const ext = extname2(path4);
-  const base = ext ? path4.slice(0, -ext.length) : path4;
+  const ext = extname2(path5);
+  const base = ext ? path5.slice(0, -ext.length) : path5;
   return `${base} (conflict from ${host} ${ts2})${ext}`;
 }
 function plan(local, remote, baseline) {
@@ -33177,47 +33177,47 @@ function plan(local, remote, baseline) {
     }
   };
   const allPaths = /* @__PURE__ */ new Set([...local.keys(), ...remote.keys(), ...Object.keys(baseline)]);
-  for (const path4 of allPaths) {
-    const L7 = local.get(path4);
-    const R = remote.get(path4);
-    const B7 = baseline[path4];
+  for (const path5 of allPaths) {
+    const L7 = local.get(path5);
+    const R = remote.get(path5);
+    const B7 = baseline[path5];
     const lSide = classifyLocal(L7, B7);
     const rSide = classifyRemote(R, B7);
     if (lSide === "absent" && rSide === "absent") continue;
     const shasMatch = L7?.sha256 && R?.sha256 && L7.sha256 === R.sha256;
     if (lSide === "absent" && rSide === "added") {
-      actions.push({ path: path4, kind: "download", remoteSize: R.size });
+      actions.push({ path: path5, kind: "download", remoteSize: R.size });
       continue;
     }
     if (lSide === "added" && rSide === "absent") {
-      actions.push({ path: path4, kind: "upload", localSize: L7.size, expectedServerVersion: null });
+      actions.push({ path: path5, kind: "upload", localSize: L7.size, expectedServerVersion: null });
       continue;
     }
     if (lSide === "unchanged" && rSide === "unchanged") continue;
     if (lSide === "unchanged" && rSide === "modified") {
       if (B7 && R.serverVersion === B7.serverVersion && R.sha256 === B7.sha256) continue;
-      actions.push({ path: path4, kind: "download", remoteSize: R.size });
+      actions.push({ path: path5, kind: "download", remoteSize: R.size });
       continue;
     }
     if (lSide === "unchanged" && rSide === "deleted") {
-      actions.push({ path: path4, kind: "delete-local", localSize: L7.size });
+      actions.push({ path: path5, kind: "delete-local", localSize: L7.size });
       continue;
     }
     if (lSide === "modified" && rSide === "unchanged") {
-      actions.push({ path: path4, kind: "upload", localSize: L7.size, expectedServerVersion: B7.serverVersion });
+      actions.push({ path: path5, kind: "upload", localSize: L7.size, expectedServerVersion: B7.serverVersion });
       continue;
     }
     if (lSide === "modified" && rSide === "modified") {
       if (shasMatch) {
-        adoptIfNeeded(path4, L7, R);
+        adoptIfNeeded(path5, L7, R);
         continue;
       }
       actions.push({
-        path: path4,
+        path: path5,
         kind: "conflict",
         localSize: L7.size,
         remoteSize: R.size,
-        renamedLocalTo: conflictedCopyName(path4),
+        renamedLocalTo: conflictedCopyName(path5),
         expectedServerVersion: B7.serverVersion,
         reason: "both sides modified since last sync"
       });
@@ -33225,7 +33225,7 @@ function plan(local, remote, baseline) {
     }
     if (lSide === "modified" && rSide === "deleted") {
       actions.push({
-        path: path4,
+        path: path5,
         kind: "upload",
         localSize: L7.size,
         expectedServerVersion: null,
@@ -33235,32 +33235,32 @@ function plan(local, remote, baseline) {
     }
     if (lSide === "added" && rSide === "added") {
       if (shasMatch) {
-        adoptIfNeeded(path4, L7, R);
+        adoptIfNeeded(path5, L7, R);
         continue;
       }
       actions.push({
-        path: path4,
+        path: path5,
         kind: "conflict",
         localSize: L7.size,
         remoteSize: R.size,
-        renamedLocalTo: conflictedCopyName(path4),
+        renamedLocalTo: conflictedCopyName(path5),
         expectedServerVersion: null,
         reason: "both sides created the same path with different content"
       });
       continue;
     }
     if (lSide === "deleted" && rSide === "absent") {
-      baselineDrops.push(path4);
+      baselineDrops.push(path5);
       continue;
     }
     if (lSide === "deleted" && rSide === "unchanged") {
-      actions.push({ path: path4, kind: "delete-remote", remoteSize: R.size, expectedServerVersion: R.serverVersion });
+      actions.push({ path: path5, kind: "delete-remote", remoteSize: R.size, expectedServerVersion: R.serverVersion });
       continue;
     }
     if (lSide === "deleted" && rSide === "modified") {
       if (B7 && R.serverVersion === B7.serverVersion && R.sha256 === B7.sha256) continue;
       actions.push({
-        path: path4,
+        path: path5,
         kind: "download",
         remoteSize: R.size,
         reason: "local deleted but remote modified - remote preserved"
@@ -33268,7 +33268,7 @@ function plan(local, remote, baseline) {
       continue;
     }
     if (lSide === "deleted" && rSide === "deleted") {
-      baselineDrops.push(path4);
+      baselineDrops.push(path5);
       continue;
     }
   }
@@ -33325,9 +33325,9 @@ Plan deletes ${totalDeletes} files (${Math.round(fraction * 100)}% of the tree).
 }
 var GIPITY_IGNORE_FILE = ".gipityignore";
 function readGipityIgnore(root) {
-  const path4 = join4(root, GIPITY_IGNORE_FILE);
-  if (!existsSync5(path4)) return [];
-  return readFileSync6(path4, "utf8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((line) => line.replace(/^\.\//, "").replace(/^\//, ""));
+  const path5 = join4(root, GIPITY_IGNORE_FILE);
+  if (!existsSync5(path5)) return [];
+  return readFileSync6(path5, "utf8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((line) => line.replace(/^\.\//, "").replace(/^\//, ""));
 }
 function effectiveIgnore(root, configIgnore) {
   const base = configIgnore && configIgnore.length ? configIgnore : DEFAULT_SYNC_IGNORE;
@@ -33343,8 +33343,8 @@ function isLocalTreeClean() {
     const local = walkLocal(root, effectiveIgnore(root, config.ignore), baseline.files);
     const baselineFiles = baseline.files;
     if (local.size !== Object.keys(baselineFiles).length) return false;
-    for (const [path4, info2] of local) {
-      const prior = baselineFiles[path4];
+    for (const [path5, info2] of local) {
+      const prior = baselineFiles[path5];
       if (!prior || prior.size !== info2.size || prior.mtime !== info2.mtime) return false;
     }
     return true;
@@ -33372,14 +33372,14 @@ async function syncInner(projectGuid, root, ignore2, opts, interactive) {
   const local = walkLocal(root, ignore2, baseline.files);
   p?.phase("Checking Gipity for changes\u2026");
   const remote = await fetchRemote(projectGuid);
-  for (const path4 of [...remote.keys()]) {
-    if (shouldIgnore(path4, ignore2)) remote.delete(path4);
+  for (const path5 of [...remote.keys()]) {
+    if (shouldIgnore(path5, ignore2)) remote.delete(path5);
   }
   const needHash = [];
-  for (const [path4, l7] of local) {
+  for (const [path5, l7] of local) {
     if (l7.sha256) continue;
-    const r = remote.get(path4);
-    if (r?.sha256 || baseline.files[path4]) needHash.push(path4);
+    const r = remote.get(path5);
+    if (r?.sha256 || baseline.files[path5]) needHash.push(path5);
   }
   if (needHash.length) p?.phase(`Hashing ${needHash.length} file${needHash.length === 1 ? "" : "s"}\u2026`);
   await ensureLocalHashes(root, local, needHash);
@@ -33843,8 +33843,8 @@ async function syncInner(projectGuid, root, ignore2, opts, interactive) {
     delete baseline.deletesSkippedStreak;
   }
   cleanupEmptyDirs(root, dirsTouchedByDelete);
-  for (const { path: path4, entry } of planned.baselineAdopts) baseline.files[path4] = entry;
-  for (const path4 of planned.baselineDrops) delete baseline.files[path4];
+  for (const { path: path5, entry } of planned.baselineAdopts) baseline.files[path5] = entry;
+  for (const path5 of planned.baselineDrops) delete baseline.files[path5];
   baseline.lastFullSync = (/* @__PURE__ */ new Date()).toISOString();
   writeBaseline(baseline);
   p?.finish();
@@ -34837,11 +34837,11 @@ import { existsSync as existsSync9, readFileSync as readFileSync10 } from "fs";
 import { join as join9, resolve as resolve8 } from "path";
 import { homedir as homedir7 } from "os";
 function checkGipityPlugin() {
-  const path4 = join9(homedir7(), ".claude", "settings.json");
+  const path5 = join9(homedir7(), ".claude", "settings.json");
   let settings = {};
-  if (existsSync9(path4)) {
+  if (existsSync9(path5)) {
     try {
-      settings = JSON.parse(readFileSync10(path4, "utf-8"));
+      settings = JSON.parse(readFileSync10(path5, "utf-8"));
     } catch {
     }
   }
@@ -35104,9 +35104,48 @@ init_config();
 
 // src/page-fixtures.ts
 init_api();
-import { readFileSync as readFileSync11, statSync as statSync5 } from "node:fs";
-import { basename as basename3 } from "node:path";
-async function uploadPublicFixture(projectGuid, localPath) {
+init_config();
+import { readFileSync as readFileSync11, statSync as statSync5, existsSync as existsSync10, readdirSync as readdirSync6 } from "node:fs";
+import { basename as basename3, resolve as resolve11, relative as relative3, join as join11 } from "node:path";
+var FIND_SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", ".gipity", "dist", "build", ".next", "coverage"]);
+function findByBasename(root, name, limit = 3) {
+  const hits = [];
+  const queue = [root];
+  let visited = 0;
+  while (queue.length && hits.length < limit && visited < 500) {
+    const dir = queue.shift();
+    visited++;
+    let entries;
+    try {
+      entries = readdirSync6(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        if (!FIND_SKIP.has(e.name)) queue.push(join11(dir, e.name));
+      } else if (e.name === name && hits.length < limit) {
+        hits.push(join11(dir, e.name));
+      }
+    }
+  }
+  return hits;
+}
+function assertLocalAsset(flag, localPath) {
+  const abs = resolve11(localPath);
+  if (existsSync10(abs)) return;
+  const root = getProjectRoot() ?? process.cwd();
+  const elsewhere = findByBasename(root, basename3(localPath)).filter((p) => p !== abs);
+  const found = elsewhere.length ? `
+That file DOES exist here \u2014 pass this path instead:
+${elsewhere.map((p) => `  ${flag} ${relative3(process.cwd(), p) || p}`).join("\n")}` : `
+Nothing named "${basename3(localPath)}" under ${root} either. Generate a frame with \`gipity generate image "<description>" -o ${localPath}\`, or check the path.`;
+  throw new Error(
+    `${flag} ${localPath}: no such file \u2014 looked for ${abs} (relative paths resolve against the current directory, ${process.cwd()}).${found}`
+  );
+}
+async function uploadPublicFixture(projectGuid, localPath, flag = "--fixture") {
+  assertLocalAsset(flag, localPath);
   const name = basename3(localPath);
   const size = statSync5(localPath).size;
   const contentType = guessMime(localPath);
@@ -35134,6 +35173,21 @@ async function uploadPublicFixture(projectGuid, localPath) {
 async function deleteFixture(projectGuid, guid) {
   await del(`/api/${projectGuid}/uploads/${guid}`);
 }
+var CAMERA_EXTS = [".png", ".jpg", ".jpeg", ".webp", ".mp4", ".webm", ".y4m", ".mjpeg"];
+function assertCameraFile(localPath) {
+  assertLocalAsset("--camera", localPath);
+  const ext = localPath.slice(localPath.lastIndexOf(".")).toLowerCase();
+  if (CAMERA_EXTS.includes(ext)) return;
+  throw new Error(
+    `--camera ${basename3(localPath)}: unsupported file type "${ext || "(none)"}" \u2014 the camera feed must be an image or video (${CAMERA_EXTS.join(", ")}).
+A still image is played as a looping single-frame feed, which is what a gesture/pose/object model needs.
+No frame to hand? Generate one: gipity generate image "a hand making a closed fist, palm to camera, plain background"`
+  );
+}
+async function uploadCameraFeed(projectGuid, localPath) {
+  assertCameraFile(localPath);
+  return uploadPublicFixture(projectGuid, localPath, "--camera");
+}
 
 // src/commands/page-eval.ts
 var EVAL_NO_VALUE_HINT = "The eval ran but returned no JSON-serializable value. A statement body with no `return`, an assignment, a void call, or a DOM node/function all serialize to null. End the script with an expression \u2014 or an explicit `return` \u2014 that yields plain data, e.g. `return { label: input.value, count: items.length }` or `return JSON.stringify(payload)`.";
@@ -35156,6 +35210,21 @@ function normalizeEvalResult(raw) {
   }
   return { result: raw, noValue: false };
 }
+var EVAL_EMPTY_STATE_HINT = "The eval returned an empty value \u2014 the script ran, but the state it read was not there at that instant. A fixed --wait samples ONE moment; transient state (a round result, a toast, a detection) can be gone by then. Poll INSIDE the body and return the moment the condition holds (raise --timeout if the sequence needs longer), or gate the read on the app's own signal with --wait-for '<selector>'.";
+var CAMERA_FRAME_CHECK = "in the eval body, run the model on the frame YOURSELF (grab the app's <video> element, or the app's own detector on it) and return its RAW output alongside the app's state. Model saw nothing => the frame is at fault: regenerate it (subject filling the frame, plain background, even light), do not re-run the same one. Model saw it but the app's state is empty => the bug is in the app's wiring, not the picture.";
+var EVAL_CAMERA_EMPTY_HINT = `The eval returned an empty value on a --camera run. --camera loops ONE still image, and the model is deterministic on it, so a longer --wait/--timeout re-runs the identical inference and returns the identical nothing \u2014 do not escalate. Two suspects: the frame, or the app's wiring. Tell them apart in one run: ${CAMERA_FRAME_CHECK} (If the app only starts its pipeline on a click, a headless run never clicks \u2014 start it on load and gate this eval on the app's own ready signal with --wait-for '<selector>'.)`;
+function isEmptyStateResult(result) {
+  let parsed;
+  try {
+    parsed = JSON.parse(result);
+  } catch {
+    return false;
+  }
+  if (Array.isArray(parsed)) return parsed.length === 0;
+  if (!parsed || typeof parsed !== "object") return false;
+  const values = Object.values(parsed);
+  return values.every((v7) => v7 === null || v7 === void 0 || v7 === "");
+}
 var EXPR_ECHO_MAX_CHARS = 120;
 function summarizeExpr(expr) {
   const lines = expr.split("\n");
@@ -35178,6 +35247,71 @@ function capWaitMs(rawWait, url) {
   ));
   return MAX_WAIT_MS;
 }
+var MAX_EVAL_STEPS = 4;
+var WAIT_FOR_MAX_MS = 3e4;
+function capWaitForTimeoutMs(raw) {
+  const parsed = parseInt(raw, 10);
+  const ms2 = Number.isFinite(parsed) && parsed >= 0 ? parsed : 5e3;
+  if (ms2 <= WAIT_FOR_MAX_MS) return ms2;
+  console.error(warning(
+    `--wait-timeout ${ms2}ms exceeds the ${WAIT_FOR_MAX_MS}ms cap on the selector gate \u2014 using ${WAIT_FOR_MAX_MS}ms. A state that takes longer than that to appear is not a settling delay: have the page reach it on load, or watch for it INSIDE the script (--timeout ${EVAL_SCRIPT_BUDGET_MAX_MS}).`
+  ));
+  return WAIT_FOR_MAX_MS;
+}
+function parsesAsExpression(s) {
+  try {
+    new Function(`return (${s}
+);`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function withPrelude(script, prelude) {
+  if (!prelude) return script;
+  return parsesAsExpression(script) ? `${prelude}
+return (${script});` : `${prelude}
+${script}`;
+}
+var CAMERA_DEFAULT_WAIT_MS = 15e3;
+var CAMERA_SETUP_BUDGET_MS = 3e4;
+var EVAL_SCRIPT_BUDGET_MS = 3e4;
+var EVAL_SCRIPT_BUDGET_CAMERA_MS = 45e3;
+var EVAL_SCRIPT_BUDGET_MAX_MS = 9e4;
+function capScriptBudgetMs(rawTimeout, hasMedia) {
+  const fallback = hasMedia ? EVAL_SCRIPT_BUDGET_CAMERA_MS : EVAL_SCRIPT_BUDGET_MS;
+  if (rawTimeout === void 0) return fallback;
+  const parsed = parseInt(rawTimeout, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  if (parsed > EVAL_SCRIPT_BUDGET_MAX_MS) {
+    console.error(warning(
+      `--timeout ${parsed}ms exceeds the ${EVAL_SCRIPT_BUDGET_MAX_MS}ms max in-page budget \u2014 using ${EVAL_SCRIPT_BUDGET_MAX_MS}ms. A body that needs longer than that is doing its waiting in the wrong place: start the slow work on page load and absorb it in the pre-eval window (--wait-for '<ready-selector>'), keeping the body to a quick read.`
+    ));
+    return EVAL_SCRIPT_BUDGET_MAX_MS;
+  }
+  return Math.max(1e3, parsed);
+}
+function evalWorkBudgetMs(o) {
+  const script = o.scriptBudgetMs ?? (o.hasCamera ? EVAL_SCRIPT_BUDGET_CAMERA_MS : EVAL_SCRIPT_BUDGET_MS);
+  const legs = Math.max(1, o.legs ?? 1);
+  const settle = o.waitMs + (o.waitForTimeoutMs ?? 0);
+  const firstPass = settle + script * legs;
+  return firstPass + (o.hasReload ? settle + script : 0) + (o.hasCamera ? CAMERA_SETUP_BUDGET_MS : 0);
+}
+function budgetOverrunHint(reason, usedBudgetMs) {
+  if (!/in-page budget/i.test(reason)) return null;
+  if (usedBudgetMs >= EVAL_SCRIPT_BUDGET_MAX_MS) {
+    return `This run already used the maximum in-page budget (--timeout ${EVAL_SCRIPT_BUDGET_MAX_MS}). More time is not the answer: have the page start its slow work on load, wait it out in the pre-eval window (--wait-for '<ready-selector>' --wait-timeout ${MAX_WAIT_MS}), and keep the body to a quick read.`;
+  }
+  return `That budget was ${Math.round(usedBudgetMs / 1e3)}s. Raise it with --timeout <ms> (up to ${EVAL_SCRIPT_BUDGET_MAX_MS}), e.g. --timeout ${EVAL_SCRIPT_BUDGET_MAX_MS} \u2014 or gate on a ready signal instead: --wait-for '<selector>' --wait-timeout ${MAX_WAIT_MS}.`;
+}
+function slowRenderMessage(fps, o) {
+  if (o.camera) {
+    const frames = Math.max(1, Math.round(fps * (o.waitMs / 1e3)));
+    return `${warning("\u26A0 Slow render:")} page painted at ${fps} fps, so the app's vision pipeline ran on roughly ${bold(`${frames} frame${frames === 1 ? "" : "s"}`)} during the ${Math.round(o.waitMs / 1e3)}s before this eval (it infers once per painted frame). ${bold("That is enough:")} --camera loops your still image, so every one of those frames is the SAME pixels and the model returns the SAME answer on each \u2014 re-running with a bigger --wait/--timeout cannot change the result. ${bold("Do not escalate the wait.")} If a detection landed, it is real. If nothing was detected, the suspect is the ${bold("frame")} (a model needs the whole subject in shot \u2014 a tight crop, an odd angle or a busy background reads as nothing) or the ${bold("app")} (frames never reach the model) \u2014 never the frame rate. Settle it in ONE run: ${CAMERA_FRAME_CHECK}`;
+  }
+  return `${warning("\u26A0 Slow render:")} page painted at ${fps} fps. Waiting on real time (setTimeout) advances animation/physics time far slower than it looks \u2014 assertions after a wall-clock wait can report a false negative. Step the app's own loop deterministically instead (3D templates: ${bold("core.advance(seconds)")}).`;
+}
 async function pollEvalResult(evalJobId, expectedWorkMs) {
   const deadline = Date.now() + expectedWorkMs + 6e4;
   let missCount = 0;
@@ -35196,10 +35330,13 @@ async function pollEvalResult(evalJobId, expectedWorkMs) {
     if (rec.status === "error") throw new ApiError(rec.httpStatus, rec.code, rec.reason);
     await sleep(1e3);
   }
-  throw new ApiError(504, "EVAL_TIMEOUT", "Eval did not finish in time; narrow the expression or lower --wait");
+  throw new ApiError(
+    504,
+    "EVAL_TIMEOUT",
+    `the browser did not report back within ${Math.round((expectedWorkMs + 6e4) / 1e3)}s \u2014 that budget already covers --wait, --wait-for, the eval body and any --camera setup, so this is the browser itself being slow or stuck (a cold sandbox, a heavy page), not your expression being too big. Lowering --wait does NOT help and on a --camera run actively hurts (the wait is what lets the vision model load \u2014 cut it and the eval reads an empty page instead). Just run the same command again: the sandbox is warm on the second hit.`
+  );
 }
-var EVAL_EXEC_BUDGET_MS = 2e4;
-function evalExecTimeoutMessage(result) {
+function evalExecTimeoutMessage(result, budgetMs) {
   let parsed;
   try {
     parsed = JSON.parse(result);
@@ -35208,10 +35345,18 @@ function evalExecTimeoutMessage(result) {
   }
   if (!parsed || parsed.success !== false || typeof parsed.error !== "string") return null;
   if (!/CDP command timed out:\s*Runtime\.evaluate/i.test(parsed.error)) return null;
-  return `the expression hit the ~${EVAL_EXEC_BUDGET_MS / 1e3}s in-page execution budget \u2014 the eval body (including its own await/setTimeout pauses) ran longer than that. This budget is the time the expression itself is allowed to run; it is separate from --wait, which only sleeps BEFORE the eval and cannot extend it. Split a long interactive check into several shorter 'page eval' calls (e.g. one per state to verify), keeping each body's in-page waits well under ${EVAL_EXEC_BUDGET_MS / 1e3}s.`;
+  const budget = Math.round(budgetMs / 1e3);
+  return `the script hit its ${budget}s in-page budget \u2014 the body (including its own await/setTimeout pauses) ran longer than that. --wait sleeps BEFORE the script and does not extend it.
+` + (budgetOverrunHint("in-page budget", budgetMs) ?? "") + `
+If the slow part is a ONE-TIME page init (a WASM/model download, a big asset, a first-frame pipeline warm-up), do NOT split the body across several 'page eval' calls \u2014 every call is a fresh page load that re-pays that init, so each one hits this same wall. Have the page kick it off on load (not behind a click) and absorb it in the pre-eval window instead.`;
 }
 var JS_DECOY_FLAGS = ["--js", "--javascript", "--script", "--code", "--expr", "--eval", "--exec"];
-var pageEvalCommand = new Command("eval").description("Evaluate JS in a real browser on a page (DOM, computed styles, element rects; inline expr or --file script). ONE client per call - to verify realtime/presence across concurrent clients use `page test --observe` instead").argument("<url>", "URL to load").argument("[expr]", "JavaScript to evaluate in page context (inline expression or statement body with return/await; result is JSON-serialized). Omit when using --file. Time budget: the body has ~20s to finish after page load - keep driver scripts within it.").option("--file <path>", "Read the script body from a file instead of the inline <expr> arg (mutually exclusive). Runs as an async function body, so top-level return/await work. Same ~20s post-load budget as <expr>.").option(
+var pageEvalCommand = new Command("eval").description("Evaluate JS in a real browser on a page (DOM, computed styles, element rects; inline expr or --file script). ONE client per call - to verify realtime/presence across concurrent clients use `page test --observe` instead").argument("<url>", "URL to load").argument("[expr]", `JavaScript to evaluate in page context (inline expression or statement body with return/await; result is JSON-serialized). Omit when using --file. Time budget: the body has ${EVAL_SCRIPT_BUDGET_MS / 1e3}s to finish after page load (${EVAL_SCRIPT_BUDGET_CAMERA_MS / 1e3}s with --camera) - raise it with --timeout, max ${EVAL_SCRIPT_BUDGET_MAX_MS / 1e3}s.`).option("--file <path>", `Read the script body from a file instead of the inline <expr> arg (mutually exclusive). Runs as an async function body, so top-level return/await work. Same post-load budget as <expr> (--timeout).`).option(
+  "--step <expr>",
+  `Run another expression against the SAME loaded page, after <expr> (repeat, max ${MAX_EVAL_STEPS}). Whatever that page load paid for \u2014 a vision model coming up, a game booting, a socket connecting \u2014 stays up for every step, so an N-part check costs ONE page load instead of N. Each step gets its own in-page budget and its own reported result.`,
+  (val, prev) => [...prev, val],
+  []
+).option(
   "--fixture <path>",
   "Host a local file and expose it to the eval as `fixtureUrl` (and under `fixtures` by basename) to fetch in-page. For verifying a render/parse path against a real binary (an MP3, an image) - no size limit, auto-deleted after the run. Repeat for several files (single-value so it never swallows the inline <expr>).",
   (val, prev) => [...prev, val],
@@ -35219,7 +35364,13 @@ var pageEvalCommand = new Command("eval").description("Evaluate JS in a real bro
 ).option(
   "--reload <expr>",
   "After the first eval, reload the page IN PLACE (localStorage/sessionStorage/cookies preserved) and evaluate this second expression against the post-reload DOM. One command verifies persisted state survives a reload: seed/assert state with <expr>, then assert the restored UI here."
-).option("--reload-file <path>", "Read the post-reload expression from a file instead of inline --reload (mutually exclusive)").option("--wait <ms>", "Sleep this many ms after DOMContentLoaded before evaluating (lets late async work settle; max 30000)", "500").option("--wait-for <selector>", "Wait until this CSS selector appears before evaluating (deterministic; replaces --wait)").option("--wait-timeout <ms>", "Max ms to wait for --wait-for before giving up", "5000").option("--auth", "Evaluate signed in as you (your Gipity account), so a page behind a Sign-in-with-Gipity login is reachable. Only works for apps using Sign in with Gipity, hosted on *.gipity.ai.").option("--json", "Output as JSON").action((url, exprArg, opts) => run("Page eval", async () => {
+).option("--reload-file <path>", "Read the post-reload expression from a file instead of inline --reload (mutually exclusive)").option(
+  "--camera <path>",
+  `Play a local image or video (.png/.jpg/.webp/.mp4/.webm/.y4m/.mjpeg) as the browser's WEBCAM feed, so a camera app's real pipeline (getUserMedia \u2192 MediaPipe/YOLOX \u2192 your app logic) runs headlessly on a frame you choose. Implies --fake-media and waits ${CAMERA_DEFAULT_WAIT_MS / 1e3}s for the vision model to load. No frame handy? gipity generate image "a hand making a closed fist, palm to camera".`
+).option("--fake-media", "Grant a synthetic microphone + camera and auto-accept the getUserMedia prompt, so a voice/camera app runs headlessly instead of hitting its no-camera path. The feed is a built-in test pattern (and a tone) \u2014 nothing a vision model can recognize; to drive a vision app use --camera <path> instead.").option("--wait <ms>", "Sleep this many ms after DOMContentLoaded before evaluating (lets late async work settle; max 30000). With --wait-for, it elapses AFTER the selector appears - gate, then settle.", "500").option("--wait-for <selector>", `Wait until this CSS selector appears before evaluating, then evaluate (deterministic - beats guessing a --wait). Gate on the state you are ASSERTING, not just a ready flag: '#verdict:not(:empty)' returns the instant the round lands, where a fixed wait snapshots mid-sequence. Same flag on page inspect/screenshot. Max ${WAIT_FOR_MAX_MS}ms (--wait-timeout).`).option("--wait-timeout <ms>", `Max ms to wait for --wait-for before giving up (max ${WAIT_FOR_MAX_MS})`, "5000").option(
+  "--timeout <ms>",
+  `How long the script itself may run IN the page - its own await/setTimeout pauses count (default ${EVAL_SCRIPT_BUDGET_MS}, ${EVAL_SCRIPT_BUDGET_CAMERA_MS} with --camera/--fake-media; max ${EVAL_SCRIPT_BUDGET_MAX_MS}). Raise it to trace a sequence that unfolds over time (a game round, an animation). Distinct from --wait, which only sleeps BEFORE the script.`
+).option("--auth", "Evaluate signed in as you (your Gipity account), so a page behind a Sign-in-with-Gipity login is reachable. Only works for apps using Sign in with Gipity, hosted on *.gipity.ai.").option("--json", "Output as JSON").action((url, exprArg, opts) => run("Page eval", async () => {
   const decoy = JS_DECOY_FLAGS.find((f) => opts[f.slice(2)] !== void 0);
   if (decoy) {
     pageEvalCommand.error(
@@ -35258,17 +35409,44 @@ var pageEvalCommand = new Command("eval").description("Evaluate JS in a real bro
       pageEvalCommand.error(`error: Cannot read file: ${opts.reloadFile}`);
     }
   }
-  const waitMs = capWaitMs(opts.wait, url);
-  const parsedTimeout = parseInt(opts.waitTimeout, 10);
-  const waitForTimeoutMs = Number.isFinite(parsedTimeout) && parsedTimeout >= 0 ? parsedTimeout : 5e3;
+  const steps = opts.step ?? [];
+  if (steps.length > MAX_EVAL_STEPS) {
+    pageEvalCommand.error(
+      `error: at most ${MAX_EVAL_STEPS} --step expressions ride on one page load (got ${steps.length}) \u2014 do more per step, or split this into two evals`
+    );
+  }
+  let waitMs = capWaitMs(opts.wait, url);
+  const waitForTimeoutMs = capWaitForTimeoutMs(opts.waitTimeout);
+  const hasMedia = !!opts.camera || !!opts.fakeMedia;
+  const scriptBudgetMs = capScriptBudgetMs(opts.timeout, hasMedia);
+  const explicitWait = pageEvalCommand.getOptionValueSource("wait") !== "default";
+  const chosenWait = explicitWait || !!opts.waitFor;
+  if (opts.camera && !chosenWait) {
+    waitMs = CAMERA_DEFAULT_WAIT_MS;
+    console.error(muted(
+      `--camera: waiting ${CAMERA_DEFAULT_WAIT_MS / 1e3}s before the eval so the camera and the app's vision model finish loading (they cannot warm up inside the eval body \u2014 that has a ${scriptBudgetMs / 1e3}s budget of its own, --timeout to change it). Override with --wait <ms>, or use --wait-for '<ready-selector>' to stop as soon as the app is ready.`
+    ));
+  }
+  const settleAfterGateMs = opts.waitFor && explicitWait ? waitMs : 0;
+  const sentWaitMs = settleAfterGateMs > 0 ? 0 : waitMs;
+  const sentScriptBudgetMs = Math.min(scriptBudgetMs + settleAfterGateMs, EVAL_SCRIPT_BUDGET_MAX_MS);
   const fixturePaths = opts.fixture ?? [];
   const hosted = [];
+  let camera;
   let projectGuid;
   let sentExpr = expr;
+  let sentSteps = steps;
+  if (opts.camera) assertCameraFile(opts.camera);
   try {
-    if (fixturePaths.length) {
+    if (fixturePaths.length || opts.camera) {
       const { config } = await resolveProjectContext({});
       projectGuid = config.projectGuid;
+    }
+    if (opts.camera) {
+      console.log(muted(`Hosting camera feed ${opts.camera}\u2026`));
+      camera = await uploadCameraFeed(projectGuid, opts.camera);
+    }
+    if (fixturePaths.length) {
       for (const p of fixturePaths) {
         console.log(muted(`Hosting fixture ${p}\u2026`));
         hosted.push(await uploadPublicFixture(projectGuid, p));
@@ -35276,30 +35454,63 @@ var pageEvalCommand = new Command("eval").description("Evaluate JS in a real bro
       const map = {};
       for (const h of hosted) map[h.name] = h.url;
       const prelude = `const fixtures=${JSON.stringify(map)};const fixtureUrl=${JSON.stringify(hosted[0].url)};`;
-      sentExpr = opts.file ? `${prelude}
-${expr}` : `${prelude}
-return (${expr});`;
+      sentExpr = withPrelude(sentExpr, prelude);
+      sentSteps = sentSteps.map((s) => withPrelude(s, prelude));
+    }
+    if (settleAfterGateMs > 0) {
+      sentExpr = withPrelude(sentExpr, `await new Promise((r) => setTimeout(r, ${settleAfterGateMs}));`);
     }
     const kickoff = await post("/tools/browser/eval", {
       url,
       expr: sentExpr,
-      waitMs,
+      waitMs: sentWaitMs,
+      steps: sentSteps.length ? sentSteps : void 0,
       reloadExpr,
       waitForSelector: opts.waitFor || void 0,
       waitForTimeoutMs: opts.waitFor ? waitForTimeoutMs : void 0,
-      auth: opts.auth || void 0
+      timeoutMs: sentScriptBudgetMs,
+      auth: opts.auth || void 0,
+      // A camera feed needs the synthetic devices in place to be played into,
+      // so --camera implies --fake-media rather than failing on the pairing.
+      fakeMedia: opts.fakeMedia || !!camera || void 0,
+      cameraUrl: camera?.url
     });
-    const d = await pollEvalResult(kickoff.data.evalJobId, reloadExpr !== void 0 ? waitMs * 2 : waitMs);
+    let d;
+    try {
+      d = await pollEvalResult(kickoff.data.evalJobId, evalWorkBudgetMs({
+        waitMs: sentWaitMs,
+        waitForTimeoutMs: opts.waitFor ? waitForTimeoutMs : 0,
+        hasReload: reloadExpr !== void 0,
+        hasCamera: !!camera,
+        scriptBudgetMs: sentScriptBudgetMs,
+        legs: 1 + sentSteps.length
+      }));
+    } catch (err) {
+      const msg = err?.message ?? "";
+      const hint = budgetOverrunHint(msg, scriptBudgetMs);
+      if (!hint) throw err;
+      throw new Error(`${msg}
+${hint}`);
+    }
     const { result, noValue } = normalizeEvalResult(d.result);
     const reload = d.reloadResult !== void 0 ? normalizeEvalResult(d.reloadResult) : void 0;
-    const execTimeout = evalExecTimeoutMessage(d.result);
+    const execTimeout = evalExecTimeoutMessage(d.result, scriptBudgetMs);
     if (execTimeout) throw new Error(execTimeout);
+    const stepOut = steps.map((stepExpr, i) => {
+      const raw = d.stepResults?.[i];
+      const norm = raw !== void 0 ? normalizeEvalResult(raw) : void 0;
+      return { expr: stepExpr, result: norm?.result ?? "", noValue: norm?.noValue ?? true };
+    });
+    const emptyState2 = !noValue && isEmptyStateResult(result);
+    const emptyHint = camera ? EVAL_CAMERA_EMPTY_HINT : EVAL_EMPTY_STATE_HINT;
     if (opts.json) {
       console.log(JSON.stringify({
         ...d,
         result,
+        ...stepOut.length ? { stepResults: stepOut.map((s) => s.result) } : {},
         ...reload ? { reloadResult: reload.result } : {},
-        ...noValue ? { hint: EVAL_NO_VALUE_HINT } : {}
+        ...noValue ? { hint: EVAL_NO_VALUE_HINT } : {},
+        ...emptyState2 ? { hint: emptyHint } : {}
       }));
       return;
     }
@@ -35308,19 +35519,29 @@ return (${expr});`;
       console.log(`${warning("\u26A0 Navigation incomplete:")} ${d.note || "page did not reach full load"}`);
     }
     if (d.slowRender) {
-      console.log(`${warning("\u26A0 Slow render:")} page painted at ${d.slowRender.fps} fps. Waiting on real time (setTimeout) advances animation/physics time far slower than it looks \u2014 assertions after a wall-clock wait can report a false negative. Step the app's own loop deterministically instead (3D templates: ${bold("core.advance(seconds)")}).`);
+      console.log(slowRenderMessage(d.slowRender.fps, { camera: !!camera, waitMs }));
     }
     if (d.auth?.requested) {
       const who = getAuth()?.email;
       console.log(d.auth.established ? `${muted("Auth:")} ${success("session established")}${who ? muted(` as ${who}`) : ""} ${muted("(what the page renders with it is app-defined)")}` : `${warning("Auth: session NOT established")}${d.auth.detail ? ` \u2014 ${d.auth.detail}` : ""} ${muted("(this is the anonymous view)")}`);
     }
+    if (camera) console.log(`${muted("Camera:")} ${camera.name} ${muted("(played as the webcam feed; getUserMedia resolves)")}`);
     if (hosted.length) console.log(`${muted("Fixtures:")} ${hosted.map((h) => h.name).join(", ")}`);
     console.log(opts.file ? `${muted("Script:")} ${opts.file}` : `${muted("Expression:")} ${summarizeExpr(expr)}`);
     console.log(`
 ${result.trim() ? result : muted("(empty result)")}`);
     if (noValue) console.log(muted(`
 ${EVAL_NO_VALUE_HINT}`));
+    if (emptyState2) console.log(muted(`
+${emptyHint}`));
     if (d.truncated) console.log(muted("\n(result truncated to fit context - narrow the expression for the full value)"));
+    for (let i = 0; i < stepOut.length; i++) {
+      const s = stepOut[i];
+      console.log(`
+${bold(`Step ${i + 1}`)} ${muted(summarizeExpr(s.expr))} ${muted("(same page load)")}`);
+      console.log(s.result.trim() ? s.result : muted("(empty result)"));
+      if (s.noValue) console.log(muted(EVAL_NO_VALUE_HINT));
+    }
     if (reload) {
       console.log(`
 ${bold("After reload")} ${muted("(page reloaded in place \u2014 storage preserved)")}`);
@@ -35329,7 +35550,7 @@ ${bold("After reload")} ${muted("(page reloaded in place \u2014 storage preserve
       if (d.reloadTruncated) console.log(muted("(reload result truncated to fit context - narrow the expression for the full value)"));
     }
   } finally {
-    for (const h of hosted) {
+    for (const h of [...hosted, ...camera ? [camera] : []]) {
       try {
         await deleteFixture(projectGuid, h.guid);
       } catch (err) {
@@ -35355,15 +35576,52 @@ Examples:
     "localStorage.setItem('todo','milk'); document.title" \\
     --reload "({ restored: localStorage.getItem('todo'), heading: document.querySelector('h1')?.textContent })"
 
+  # Camera app (MediaPipe / YOLOX / any getUserMedia app): play a real image as
+  # the webcam so the app's OWN pipeline runs on a frame you control \u2014 no need to
+  # stub the model or export internals just to test around a missing camera.
+  # --camera waits ${CAMERA_DEFAULT_WAIT_MS / 1e3}s before evaluating (model load + first frame); the script
+  # itself then gets ${EVAL_SCRIPT_BUDGET_CAMERA_MS / 1e3}s in the page (--timeout, max ${EVAL_SCRIPT_BUDGET_MAX_MS / 1e3}s).
+  gipity generate image "a hand making a closed fist, palm to camera, plain background" -o fist.png
+  gipity page eval "https://dev.gipity.ai/me/app/" --camera fist.png \\
+    "document.querySelector('#detected-gesture').textContent"
+  # Camera app that only starts on a click? Start it on page load instead (a headless
+  # run has no user), and expose a ready signal so the wait ends the moment it's up:
+  gipity page eval "https://dev.gipity.ai/me/app/" --camera fist.png \\
+    --wait-for "#detected-gesture:not(:empty)" --wait-timeout ${WAIT_FOR_MAX_MS} \\
+    "document.querySelector('#detected-gesture').textContent"
+  # Several assertions about the SAME page? Use --step, not several commands: a camera
+  # page load pays for getUserMedia + the vision model ONCE and every step reuses it.
+  gipity page eval "https://dev.gipity.ai/me/app/" --camera fist.png \\
+    --wait-for '[data-vision="ready"]' \\
+    "window.__vision.gesture()" \\
+    --step "document.getElementById('see').textContent" \\
+    --step "({ score: score.textContent, verdict: verdict.textContent })"
+
 Module resolution: dynamic import() specifiers starting with ./ or ../ resolve
 against the PAGE URL, so import('./packages/i18n/index.js') loads the app's own
 module without hand-building the deployed /account/project/ path. Absolute paths
 and full URLs pass through unchanged.
 
-The eval body runs under a ~20s in-page execution budget (its own await/setTimeout
-pauses count; --wait only sleeps BEFORE the eval and does not extend it). For a long
-interactive sequence, split it into several shorter evals (one per state to verify)
-rather than one body with many long waits.
+Time budget: the script runs under a ${EVAL_SCRIPT_BUDGET_MS / 1e3}s in-page budget (${EVAL_SCRIPT_BUDGET_CAMERA_MS / 1e3}s with --camera/--fake-media),
+counting its own await/setTimeout pauses. Two separate knobs:
+  --timeout <ms>  how long the SCRIPT may run in the page (max ${EVAL_SCRIPT_BUDGET_MAX_MS}) \u2014 raise this to
+                  trace a sequence that unfolds over time (a game round, an animation)
+  --wait / --wait-for  how long to settle BEFORE the script runs \u2014 a blind sleep, a
+                  selector gate, or both (gate first, then sleep). Neither extends --timeout.
+Which one:
+  - waiting for the app to REACH a state before you read it \u2192 --wait-for '<selector>'
+    (gate on the end state \u2014 '#verdict:not(:empty)' \u2014 not just a ready flag; a bare
+    --wait samples one arbitrary instant and can land mid-sequence). Passing both means
+    gate first, then settle --wait ms.
+  - watching state evolve (poll until a result lands, record a trace) \u2192 --timeout
+  - a slow ONE-TIME init (WASM/model download, big asset) \u2192 do NOT split the body across
+    calls; every call re-loads the page and re-pays it. Start that work on page load and
+    absorb it in the pre-eval window: --wait <ms> (max ${MAX_WAIT_MS}) or, better,
+    --wait-for '<ready-selector>' --wait-timeout ${WAIT_FOR_MAX_MS}.
+
+Several things to check on one page? Pass --step (max ${MAX_EVAL_STEPS}) instead of running
+'page eval' N times: the steps run in order against the ONE loaded page, so a slow
+boot (vision model, game, socket) is paid once, not once per assertion.
 
 Testing realtime/shared state across clients?
   Separate 'page eval' calls run sequentially (one finishes before the next
@@ -35378,7 +35636,7 @@ init_auth();
 init_colors();
 init_utils();
 import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname7, join as join11, resolve as resolvePath } from "path";
+import { dirname as dirname7, join as join12, resolve as resolvePath } from "path";
 var DEVICE_PRESETS = {
   default: { width: 1280, height: 720 },
   desktop: { width: 1920, height: 1080 },
@@ -35401,8 +35659,17 @@ function printAuthLine(auth) {
 }
 function printActionErrorLine(actionError) {
   if (!actionError) return;
+  if (/wait-for:/.test(actionError)) {
+    console.log(`${warning("\u26A0 --wait-for never matched:")} ${actionError.replace(/^EvalError:\s*/, "")} ${muted("(the image below is the state the page WAS in when the gate gave up)")}`);
+    return;
+  }
   console.log(`${warning("\u26A0 --action failed:")} ${actionError} ${muted("(this image shows the page BEFORE the action ran)")}`);
 }
+function augmentSandboxTimeout(message) {
+  if (!/did not respond within/i.test(message)) return message;
+  return `${message}
+A pre-capture script was set (--action and/or the --wait-for gate), and its runtime is spent INSIDE that same sandbox budget \u2014 a script that waits on slow work (a WASM/model download, a network fetch, a long animation) can exhaust the budget on its own. Keep --action to the interaction itself (a click, a keypress), let the page do the slow work on load, and absorb that with --wait <ms> or a tighter --wait-for '<selector>' gate instead.`;
+}
 function fmtPerformance(p) {
   const parts = [
     `TTFB ${fmtMs(p.ttfb)}`,
@@ -35430,7 +35697,7 @@ function dimSuffix(vp2) {
 }
 function defaultScreenshotDir() {
   const root = getProjectRoot();
-  return join11(root ?? ".", ".gipity", "screenshots");
+  return join12(root ?? ".", "screenshots");
 }
 function timestampSlug(d = /* @__PURE__ */ new Date()) {
   const p = (n) => String(n).padStart(2, "0");
@@ -35485,17 +35752,51 @@ function appendOption(value, previous = []) {
   return [...previous, value];
 }
 var ACTION_DECOY_FLAGS = ["--eval", "--js", "--javascript", "--script", "--code", "--exec"];
-var pageScreenshotCommand = new Command("screenshot").description("Screenshot a web page").argument("<url>", "URL to screenshot").option("--post-load-delay <ms>", "Delay after DOMContentLoaded before capture, in ms (default: 1000)").option("--action <js>", `Run JS in the page before capturing \u2014 e.g. click a button to enter a state ("document.getElementById('play').click()"). Runs as an async function body, so const/await and app-relative import('./\u2026') work. Runs after the post-load delay, then settles again before the shot. If it throws, the capture still happens and the failure is reported.`).option("--full", "Capture the full scrollable page (default: viewport only). Scrolls the page through first so scroll-reveal/fade-in-on-scroll (IntersectionObserver) sections render into the shot instead of capturing blank.").option("-o, --output <file>", "Output path (single viewport only; default .gipity/screenshots/ss-<host>-<timestamp>.png)").option("--device <names>", `Device preset(s): ${Object.keys(DEVICE_PRESETS).join(", ")} (comma-separated or repeat flag). mobile/tablet emulate a real touch device \u2014 touch events, mobile user-agent, DPR \u2014 so touch-gated mobile UI actually renders.`, appendOption, []).option("--viewport <dims>", "Raw viewport(s): WxH or WxH@dpr (comma-separated or repeat flag)", appendOption, []).option("--no-reload-between", "Skip reload between viewports (faster, lower fidelity - only safe for static pages)").option("--fake-media", "Grant a synthetic microphone + camera and auto-accept the getUserMedia prompt, so voice/camera apps render headlessly (audio is a built-in tone, not real speech)").option("--auth", "Capture the page signed in as you (your Gipity account), so UI behind a Sign-in-with-Gipity login is shown. Only works for apps using Sign in with Gipity, hosted on *.gipity.ai.").option("--json", "Output JSON metadata instead of a friendly summary").addOption(new Option("--wait <ms>", "Alias for --post-load-delay").hideHelp()).addOption(new Option("--full-page", "Alias for --full").hideHelp()).action((url, opts) => run("Page screenshot", async () => {
+function buildWaitForGate(selector, timeoutMs) {
+  const sel = JSON.stringify(selector);
+  return `await (async () => { const __t0 = Date.now(); while (Date.now() - __t0 < ${timeoutMs}) { try { if (document.querySelector(${sel})) return; } catch (e) { throw new Error('wait-for: invalid selector ' + ${sel}); } await new Promise((r) => setTimeout(r, 100)); } throw new Error('wait-for: nothing matched ' + ${sel} + ' within ${timeoutMs}ms \u2014 the page never reached that state (raise --wait-timeout, fix the selector, or check the app actually gets there headlessly)'); })();`;
+}
+var WAIT_FOR_MAX_MS2 = 15e3;
+var WAIT_FOR_DEFAULT_MS = 15e3;
+var MAX_POST_LOAD_DELAY_MS = 3e4;
+var CAMERA_DEFAULT_DELAY_MS = 15e3;
+var pageScreenshotCommand = new Command("screenshot").description("Screenshot a web page").argument("<url>", "URL to screenshot").option("--wait <ms>", `Sleep this many ms after DOMContentLoaded before capturing (default 1000, max ${MAX_POST_LOAD_DELAY_MS}). With --camera it defaults to ${CAMERA_DEFAULT_DELAY_MS} so the vision model is up. Same flag as page eval/inspect.`).option("--wait-for <selector>", `Wait until this CSS selector appears before capturing, then capture (deterministic - beats guessing a --wait). Same flag as page eval/inspect. Gate on what you are photographing ('[data-vision="ready"]', '#verdict:not(:empty)'). Max ${WAIT_FOR_MAX_MS2}ms (--wait-timeout).`).option("--wait-timeout <ms>", `Max ms to wait for --wait-for before giving up (default ${WAIT_FOR_DEFAULT_MS}, max ${WAIT_FOR_MAX_MS2}). Timing out is reported - the capture still happens, so you see the state it got stuck in.`).option("--action <js>", `Run JS in the page before capturing \u2014 e.g. click a button to enter a state ("document.getElementById('play').click()"). Runs as an async function body, so const/await and app-relative import('./\u2026') work. Runs after the post-load delay, then settles again before the shot. If it throws, the capture still happens and the failure is reported.`).option("--full", "Capture the full scrollable page (default: viewport only). Scrolls the page through first so scroll-reveal/fade-in-on-scroll (IntersectionObserver) sections render into the shot instead of capturing blank.").option("-o, --output <file>", "Output path (single viewport only; default .gipity/screenshots/ss-<host>-<timestamp>.png)").option("--device <names>", `Device preset(s): ${Object.keys(DEVICE_PRESETS).join(", ")} (comma-separated or repeat flag). mobile/tablet emulate a real touch device \u2014 touch events, mobile user-agent, DPR \u2014 so touch-gated mobile UI actually renders.`, appendOption, []).option("--viewport <dims>", "Raw viewport(s): WxH or WxH@dpr (comma-separated or repeat flag)", appendOption, []).option("--no-reload-between", "Skip reload between viewports (faster, lower fidelity - only safe for static pages)").option("--fake-media", "Grant a synthetic microphone + camera and auto-accept the getUserMedia prompt, so voice/camera apps render headlessly. The video feed is a built-in test pattern \u2014 to capture what the app does with a REAL frame (a hand, a face, an object), use --camera <path> instead.").option("--camera <path>", "Play a local image or video (.png/.jpg/.webp/.mp4/.webm/.y4m/.mjpeg) as the browser's WEBCAM feed, then capture \u2014 so the shot shows the app reacting to a frame you chose (detected gesture, boxes, labels). Implies --fake-media.").option("--auth", "Capture the page signed in as you (your Gipity account), so UI behind a Sign-in-with-Gipity login is shown. Only works for apps using Sign in with Gipity, hosted on *.gipity.ai.").option("--ephemeral", "Skip the project screenshot history: do not persist this capture to Gipity (screenshots/ in the project). Local file is still written.").option("--json", "Output JSON metadata instead of a friendly summary").addOption(new Option("--post-load-delay <ms>", "Alias for --wait").hideHelp()).addOption(new Option("--full-page", "Alias for --full").hideHelp()).action((url, opts) => run("Page screenshot", async () => {
   const decoy = ACTION_DECOY_FLAGS.find((f) => opts[f.slice(2)] !== void 0);
   if (decoy) {
     pageScreenshotCommand.error(
       `error: ${decoy} is not a flag on screenshot \u2014 use --action "<js>" to run JavaScript in the page before the capture, e.g. gipity page screenshot "<url>" --action "document.getElementById('play').click()"`
     );
   }
-  const delayRaw = opts.postLoadDelay ?? opts.wait ?? "1000";
-  const postLoadDelayMs = delayRaw !== void 0 ? parseInt(String(delayRaw), 10) : void 0;
-  if (postLoadDelayMs !== void 0 && (!Number.isFinite(postLoadDelayMs) || postLoadDelayMs < 0)) {
-    throw new Error("--post-load-delay must be a non-negative integer (ms)");
+  const delayRaw = opts.wait ?? opts.postLoadDelay;
+  const chosenDelay = delayRaw !== void 0;
+  let postLoadDelayMs = chosenDelay ? parseInt(String(delayRaw), 10) : 1e3;
+  if (!Number.isFinite(postLoadDelayMs) || postLoadDelayMs < 0) {
+    throw new Error("--wait must be a non-negative integer (ms)");
+  }
+  if (postLoadDelayMs > MAX_POST_LOAD_DELAY_MS) {
+    console.error(warning(
+      `--wait ${postLoadDelayMs}ms exceeds the ${MAX_POST_LOAD_DELAY_MS}ms cap \u2014 using ${MAX_POST_LOAD_DELAY_MS}ms. Waiting longer is rarely the fix: gate on the state you want with --wait-for '<selector>' instead of guessing a duration.`
+    ));
+    postLoadDelayMs = MAX_POST_LOAD_DELAY_MS;
+  }
+  const waitForTimeoutRaw = opts.waitTimeout !== void 0 ? parseInt(String(opts.waitTimeout), 10) : WAIT_FOR_DEFAULT_MS;
+  if (!Number.isFinite(waitForTimeoutRaw) || waitForTimeoutRaw < 0) {
+    throw new Error("--wait-timeout must be a non-negative integer (ms)");
+  }
+  const waitForTimeoutMs = Math.min(waitForTimeoutRaw, WAIT_FOR_MAX_MS2);
+  if (waitForTimeoutRaw > WAIT_FOR_MAX_MS2) {
+    console.error(warning(
+      `--wait-timeout ${waitForTimeoutRaw}ms exceeds the ${WAIT_FOR_MAX_MS2}ms the capture's browser budget covers \u2014 using ${WAIT_FOR_MAX_MS2}ms. A state that takes longer than that to appear is not a screenshot problem: watch for it with \`gipity page eval <url> --wait-for '<selector>' --wait-timeout 30000\` (a wider budget), then capture it.`
+    ));
+  }
+  if (opts.waitTimeout !== void 0 && !opts.waitFor) {
+    throw new Error("--wait-timeout only means something with --wait-for '<selector>' (it bounds that gate)");
+  }
+  if (opts.camera && !chosenDelay && !opts.waitFor) {
+    postLoadDelayMs = CAMERA_DEFAULT_DELAY_MS;
+    console.error(muted(
+      `--camera: waiting ${CAMERA_DEFAULT_DELAY_MS / 1e3}s before the capture so the camera and the app's vision model finish loading. Override with --wait <ms>, or use --wait-for '<ready-selector>' to shoot the moment it's ready.`
+    ));
   }
   const deviceNames = splitCsv(opts.device);
   const viewportStrs = splitCsv(opts.viewport);
@@ -35507,18 +35808,54 @@ var pageScreenshotCommand = new Command("screenshot").description("Screenshot a
     throw new Error("--output can only be used with a single viewport");
   }
   const userSpecifiedViewports = customViewports.length > 0;
+  const slug = slugFromUrl(url);
+  const ts2 = timestampSlug();
+  const shotName = (vp2) => defaultFilename(slug, ts2, vp2 && userSpecifiedViewports ? dimSuffix(vp2) : void 0);
+  const names = userSpecifiedViewports ? customViewports.map(shotName) : [shotName()];
+  const projectGuid = getConfig()?.projectGuid;
+  const save = !opts.ephemeral && projectGuid ? { project_guid: projectGuid, names } : void 0;
+  let camera;
+  if (opts.camera) {
+    assertCameraFile(opts.camera);
+    if (!projectGuid) throw new Error("--camera needs a linked project (the frame is hosted for the browser to fetch) \u2014 run `gipity link` first.");
+    console.log(muted(`Hosting camera feed ${opts.camera}\u2026`));
+    camera = await uploadCameraFeed(projectGuid, opts.camera);
+  }
+  const preCapture = [
+    opts.waitFor ? buildWaitForGate(opts.waitFor, waitForTimeoutMs) : "",
+    opts.action ?? ""
+  ].filter(Boolean).join("\n");
   const body = {
     url,
     postLoadDelayMs,
     full: !!(opts.full || opts.fullPage),
     reloadBetween: opts.reloadBetween !== false,
     ...userSpecifiedViewports ? { viewports: customViewports } : {},
-    ...opts.fakeMedia ? { fakeMedia: true } : {},
+    // A camera feed is played into the synthetic devices, so --camera implies
+    // --fake-media rather than failing on the pairing.
+    ...opts.fakeMedia || camera ? { fakeMedia: true } : {},
+    ...camera ? { cameraUrl: camera.url } : {},
     ...opts.auth ? { auth: true } : {},
-    ...opts.action ? { action: opts.action } : {}
+    ...preCapture ? { action: preCapture } : {},
+    ...save ? { save } : {}
   };
   const doShoot = () => postForTarEntries("/tools/browser/screenshot", body);
-  const entries = opts.json ? await doShoot() : await withSpinner("Capturing\u2026", doShoot, { done: null });
+  let entries;
+  try {
+    try {
+      entries = opts.json ? await doShoot() : await withSpinner("Capturing\u2026", doShoot, { done: null });
+    } catch (err) {
+      throw preCapture ? new Error(augmentSandboxTimeout(err.message)) : err;
+    }
+  } finally {
+    if (camera) {
+      try {
+        await deleteFixture(projectGuid, camera.guid);
+      } catch (err) {
+        console.error(warning(`\u26A0 Could not auto-delete camera feed "${camera.name}" (${camera.guid}) \u2014 still hosted at ${camera.url}: ${err.message}`));
+      }
+    }
+  }
   const metaEntry = entries.find((e) => e.name === "meta.json");
   if (!metaEntry) throw new Error("Server response missing meta.json");
   const meta = JSON.parse(metaEntry.buffer.toString("utf8"));
@@ -35526,14 +35863,10 @@ var pageScreenshotCommand = new Command("screenshot").description("Screenshot a
   if (pngs.length !== meta.screenshots.length) {
     throw new Error(`Server returned ${pngs.length} PNGs but ${meta.screenshots.length} metadata entries`);
   }
-  const slug = slugFromUrl(url);
-  const ts2 = timestampSlug();
   const dir = defaultScreenshotDir();
   const savedFiles = [];
   for (let i = 0; i < pngs.length; i++) {
-    const shot = meta.screenshots[i];
-    const suffix = userSpecifiedViewports ? dimSuffix(shot.viewport) : void 0;
-    const target = opts.output ? opts.output : join11(dir, defaultFilename(slug, ts2, suffix));
+    const target = opts.output ? opts.output : join12(dir, names[i] ?? shotName(meta.screenshots[i].viewport));
     mkdirSync7(dirname7(target), { recursive: true });
     writeFileSync8(target, pngs[i].buffer);
     savedFiles.push(resolvePath(target));
@@ -35561,11 +35894,20 @@ var pageScreenshotCommand = new Command("screenshot").description("Screenshot a
         height: s.height,
         size_bytes: s.screenshotSizeBytes,
         full_page: meta.full,
-        phase: s.phase
+        phase: s.phase,
+        ...s.vfs ? { gipity: s.vfs } : {}
       }))
     }));
     return;
   }
+  const printVfsLine = (s) => {
+    if (!s.vfs) return;
+    if ("error" in s.vfs) {
+      console.log(`${warning("\u26A0 Gipity save failed:")} ${s.vfs.error} ${muted("(local file is fine)")}`);
+    } else {
+      console.log(`${label("Gipity history")} ${s.vfs.path} ${muted("(synced, not deployed)")}`);
+    }
+  };
   if (meta.screenshots.length === 1) {
     const s = meta.screenshots[0];
     console.log(`${brand("Screenshot")} ${bold(url)}`);
@@ -35580,6 +35922,7 @@ var pageScreenshotCommand = new Command("screenshot").description("Screenshot a
     console.log(`${label("Screenshot size")} ${sizePart}`);
     if (s.width && s.height) console.log(`${label("Screenshot dims")} ${s.width} \xD7 ${s.height}`);
     console.log(`${label("Screenshot file")} ${success(savedFiles[0])}`);
+    printVfsLine(s);
     return;
   }
   console.log(`${brand("Loading")} ${bold(url)} ${muted(`once \u2192 ${meta.screenshots.length} viewports`)}`);
@@ -35599,6 +35942,7 @@ ${brand("@ " + dims)}${deviceTag}`);
     console.log(`${label("Screenshot size")} ${sizePart}`);
     if (s.width && s.height) console.log(`${label("Screenshot dims")} ${s.width} \xD7 ${s.height}`);
     console.log(`${label("Screenshot file")} ${success(savedFiles[i])}`);
+    printVfsLine(s);
   }
 }));
 for (const f of ACTION_DECOY_FLAGS) pageScreenshotCommand.addOption(new Option(`${f} <value>`).hideHelp());
@@ -35609,11 +35953,21 @@ Examples:
   gipity page screenshot "https://dev.gipity.ai/me/app/" --device mobile,desktop
   gipity page screenshot "https://dev.gipity.ai/me/app/" \\
     --action "document.getElementById('play').click()"                   # capture an in-game frame
+  # Camera / vision app: play a real frame in as the webcam and shoot once the app
+  # says it's ready \u2014 same --camera / --wait-for flags as 'page eval', no guessed delay:
+  gipity page screenshot "https://dev.gipity.ai/me/app/" --camera fist.png \\
+    --wait-for '[data-vision="ready"]'
+
+Waiting for the page to reach a state before the shot?
+  --wait-for '<selector>' gates the capture on the app's own signal (deterministic).
+  Reach for --wait <ms> only when there is nothing to gate on \u2014 a guessed duration
+  either shoots too early or wastes the difference.
 
 Capturing a state that needs an interaction (start a game, open a menu, dismiss a modal)?
-  Use --action to run JS in the page before the shot \u2014 it fires after the post-load
-  delay, then settles again so the result has painted. Do NOT hand-roll a 'page eval'
-  that returns a base64 image: the eval result is capped (~16KB) and truncates the PNG.
+  Use --action to run JS in the page before the shot \u2014 it fires after the wait
+  (and after any --wait-for gate), then settles again so the result has painted. Do
+  NOT hand-roll a 'page eval' that returns a base64 image: the eval result is capped
+  (~16KB) and truncates the PNG.
 
 Capturing an off-screen region or reading element data?
     \u2022 --full captures the ENTIRE scrollable page (then crop to the region).
@@ -35638,7 +35992,7 @@ function shortUrl(url, truncate = true, maxLen = 100) {
   const tailLen = Math.floor(keep / 2);
   return result.slice(0, headLen) + "\u2026" + result.slice(-tailLen);
 }
-var pageInspectCommand = new Command("inspect").description("Inspect a web page (console, failed resources, timing, layout overflow). ONE passive load - to verify realtime/presence across concurrent clients use `page test --observe`").argument("<url>", "URL to inspect").option("--wait <ms>", "Sleep this many ms after DOMContentLoaded before capturing (lets late async/LCP work settle; max 30000)", "500").option("--wait-for <selector>", "Wait until this CSS selector appears before capturing (deterministic; replaces --wait)").option("--wait-timeout <ms>", "Max ms to wait for --wait-for before giving up", "5000").option("--json", "Output as JSON").option("--no-reprobe", "Skip the automatic second probe that filters one-time transient console errors - roughly halves inspect time on a page with any console error, at the cost of possibly reporting a cold-load transient as real").option("--no-truncate", "Show full URLs instead of truncating long ones with middle-ellipsis").option("--all", "Include render-blocking, large resources, oversized images, overflow culprits, and LCP detail").option("--fake-media", "Grant a synthetic microphone + camera and auto-accept the getUserMedia prompt, so voice/camera apps run headlessly (audio is a built-in tone, not real speech)").option("--device <name>", `Inspect as a real touch device: ${TOUCH_DEVICES.join(", ")}. Emulates touch events, mobile user-agent and DPR, so a touch-gated mobile layout is what gets inspected.`).option("--auth", "Load the page signed in as you (your Gipity account), so pages behind a Sign-in-with-Gipity login are reachable. Only works for apps using Sign in with Gipity, hosted on *.gipity.ai.").addOption(new Option("--screenshot [path]", "Capture a screenshot").hideHelp()).action((url, opts) => {
+var pageInspectCommand = new Command("inspect").description("Inspect a web page (console, failed resources, timing, layout overflow). ONE passive load - to verify realtime/presence across concurrent clients use `page test --observe`").argument("<url>", "URL to inspect").option("--wait <ms>", "Sleep this many ms after DOMContentLoaded before capturing (lets late async/LCP work settle; max 30000)", "500").option("--wait-for <selector>", "Wait until this CSS selector appears before capturing (deterministic; replaces --wait)").option("--wait-timeout <ms>", "Max ms to wait for --wait-for before giving up", "5000").option("--json", "Output as JSON").option("--no-reprobe", "Skip the automatic second probe that filters one-time transient console errors - roughly halves inspect time on a page with any console error, at the cost of possibly reporting a cold-load transient as real").option("--no-truncate", "Show full URLs instead of truncating long ones with middle-ellipsis").option("--all", "Include render-blocking, large resources, oversized images, overflow culprits, and LCP detail").option("--no-fake-media", "Inspect with NO camera or microphone present, so a getUserMedia app takes its no-device error path (use this only when that fallback IS what you're inspecting)").option("--device <name>", `Inspect as a real touch device: ${TOUCH_DEVICES.join(", ")}. Emulates touch events, mobile user-agent and DPR, so a touch-gated mobile layout is what gets inspected.`).option("--auth", "Load the page signed in as you (your Gipity account), so pages behind a Sign-in-with-Gipity login are reachable. Only works for apps using Sign in with Gipity, hosted on *.gipity.ai.").addOption(new Option("--screenshot [path]", "Capture a screenshot").hideHelp()).action((url, opts) => {
   if (opts.screenshot !== void 0) {
     console.error(error("page inspect does not capture screenshots. Use page screenshot:"));
     console.error(`  gipity page screenshot ${url}${typeof opts.screenshot === "string" ? ` -o ${opts.screenshot}` : ""}`);
@@ -35657,7 +36011,7 @@ async function inspectPage(url, opts = {}) {
     waitMs,
     waitForSelector: opts.waitFor || void 0,
     waitForTimeoutMs: opts.waitFor ? waitForTimeoutMs : void 0,
-    fakeMedia: opts.fakeMedia || void 0,
+    fakeMedia: opts.fakeMedia !== false ? true : void 0,
     device: opts.device ? resolveTouchDevice(opts.device) : void 0,
     auth: opts.auth || void 0
   };
@@ -35818,11 +36172,14 @@ function statusIcon(status) {
   if (status === "warning") return warning("\u26A0");
   return muted("\u2192");
 }
-var deployCommand = new Command("deploy").description("Deploy to dev or prod").argument("[target]", "dev or prod", "dev").option("--source-dir <dir>", "Source directory to deploy from").option("--only <phases>", "Run only specific phases (comma-separated)").option("--force", "Re-run all phases (ignore checksums) and bypass the sync bulk-deletion guard").option("--no-sync", "Skip sync-up before deploy").option("--optimize", "Force Vite build optimization on (default for prod; use this to optimize a dev deploy too)").option("--no-optimize", 'Skip build optimization and upload files as-is - the escape hatch for plain-HTML apps whose <script src> tags are not type="module"').option("--json", "Output as JSON").option("--inspect [path]", "After a successful deploy, run `page inspect` on the deployed URL (or URL + path) in the same command - one build-loop step instead of two. With --json, emits two JSON lines: deploy, then inspect.").action((target, opts) => run("Deploy", async () => {
+var deployCommand = new Command("deploy").description("Deploy to dev or prod").argument("[target]", "dev or prod", "dev").option("--source-dir <dir>", "Source directory to deploy from").option("--only <phases>", "Run only specific phases (comma-separated)").option("--force", "Re-run all phases (ignore checksums) and bypass the sync bulk-deletion guard").option("--no-sync", "Skip sync-up before deploy").option("--optimize", "Force Vite build optimization on (default for prod; use this to optimize a dev deploy too)").option("--no-optimize", 'Skip build optimization and upload files as-is - the escape hatch for plain-HTML apps whose <script src> tags are not type="module"').option("--json", "Output as JSON").option("--inspect [path]", "After a successful deploy, run `page inspect` on the deployed URL (or URL + path) in the same command - one build-loop step instead of two. With --json, emits two JSON lines: deploy, then inspect.").option("--wait <ms>", "With --inspect: sleep this many ms before capturing (max 30000)").option("--wait-for <selector>", "With --inspect: wait until this CSS selector appears before capturing (deterministic; the app's own ready signal)").option("--wait-timeout <ms>", "With --inspect: max ms to wait for --wait-for before giving up", "5000").action((target, opts) => run("Deploy", async () => {
   if (target !== "dev" && target !== "prod") {
     console.error(error('Target must be "dev" or "prod"'));
     process.exit(1);
   }
+  if (!opts.inspect && (opts.waitFor || deployCommand.getOptionValueSource("wait") !== void 0)) {
+    opts.inspect = true;
+  }
   const config = requireConfig();
   await syncBeforeAction(opts);
   const doDeploy = () => post(`/projects/${config.projectGuid}/deploy`, {
@@ -35843,7 +36200,12 @@ var deployCommand = new Command("deploy").description("Deploy to dev or prod").a
     const url = typeof opts.inspect === "string" ? new URL(opts.inspect, d.url).toString() : d.url;
     if (!opts.json) console.log("");
     try {
-      await inspectPage(url, { json: opts.json });
+      await inspectPage(url, {
+        json: opts.json,
+        wait: opts.wait,
+        waitFor: opts.waitFor,
+        waitTimeout: opts.waitTimeout
+      });
     } catch (err) {
       console.error(warning(`Inspect failed (deploy itself succeeded): ${err?.message ?? err}`));
     }
@@ -36066,8 +36428,8 @@ memoryCommand.command("delete <topic>").description("Delete a topic").option("--
 // src/commands/sandbox.ts
 init_api();
 init_config();
-import { readFileSync as readFileSync13, existsSync as existsSync10, statSync as statSync6 } from "fs";
-import { dirname as dirname8, extname as extname4, relative as relative3, resolve as resolve11 } from "path";
+import { readFileSync as readFileSync13, existsSync as existsSync11, statSync as statSync6 } from "fs";
+import { dirname as dirname8, extname as extname4, relative as relative4, resolve as resolve12 } from "path";
 init_colors();
 var LANG_MAP = {
   js: "javascript",
@@ -36180,7 +36542,7 @@ function resolveRelativeCwd() {
   const configPath = getConfigPath();
   if (!configPath) return void 0;
   const projectRoot = dirname8(configPath);
-  const rel2 = relative3(projectRoot, process.cwd());
+  const rel2 = relative4(projectRoot, process.cwd());
   if (!rel2 || rel2.startsWith("..")) return void 0;
   return rel2.split(/[\\/]/).filter(Boolean).join("/");
 }
@@ -36239,7 +36601,7 @@ GCC/Rust).
   if (args.length >= 2 && INTERPRETERS[args[0].toLowerCase()] !== void 0) {
     langFromInterp = INTERPRETERS[args[0].toLowerCase()];
     const rest = args.slice(1).join(" ");
-    if (existsSync10(rest) && statSync6(rest).isFile()) filePath = rest;
+    if (existsSync11(rest) && statSync6(rest).isFile()) filePath = rest;
     else inlineCode = rest;
   } else if (args.length === 1) {
     inlineCode = args[0];
@@ -36319,7 +36681,7 @@ GCC/Rust).
     }
     if (res.data.outputFiles && res.data.outputFiles.length > 0) {
       const projectRoot = getProjectRoot();
-      const landed = (f) => pulledLocal && !!projectRoot && existsSync10(resolve11(projectRoot, f));
+      const landed = (f) => pulledLocal && !!projectRoot && existsSync11(resolve12(projectRoot, f));
       const onDisk = res.data.outputFiles.filter(landed);
       const notOnDisk = res.data.outputFiles.filter((f) => !landed(f));
       if (onDisk.length > 0) {
@@ -36436,7 +36798,7 @@ chatCommand.command("delete <guid>").description("Delete a chat").option("--json
 // src/commands/project.ts
 init_api();
 init_config();
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import { mkdirSync as mkdirSync8 } from "fs";
 init_colors();
 init_utils();
@@ -36494,7 +36856,7 @@ projectCommand.command("create <name>").description("Create a project").option("
   }
   const res = await post("/projects", body);
   const project = res.data;
-  const dir = join12(getProjectsRoot(), project.slug);
+  const dir = join13(getProjectsRoot(), project.slug);
   mkdirSync8(dir, { recursive: true });
   const accountSlug = await getAccountSlug();
   let agentGuid = "";
@@ -36750,7 +37112,7 @@ function printStepRuns(steps, emptyNote) {
   }
 }
 var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
-var sleep2 = (ms2) => new Promise((resolve18) => setTimeout(resolve18, ms2));
+var sleep2 = (ms2) => new Promise((resolve19) => setTimeout(resolve19, ms2));
 async function waitForRun(wfGuid, prevGuid, timeoutSec) {
   const deadline = Date.now() + timeoutSec * 1e3;
   let runGuid;
@@ -37189,9 +37551,9 @@ init_config();
 init_utils();
 init_colors();
 var fileCommand = new Command("file").description("Browse remote files");
-fileCommand.command("ls [path]").description("List files").option("--json", "Output as JSON").action((path4, opts) => run("List", async () => {
+fileCommand.command("ls [path]").description("List files").option("--json", "Output as JSON").action((path5, opts) => run("List", async () => {
   const { config } = await resolveProjectContext();
-  const query = path4 ? `?path=${encodeURIComponent(path4)}` : "";
+  const query = path5 ? `?path=${encodeURIComponent(path5)}` : "";
   const res = await get(`/projects/${config.projectGuid}/files${query}`);
   printList(res.data, opts, "(empty)", (f) => {
     const size = f.type === "directory" ? "<DIR>" : formatSize(Number(f.size));
@@ -37199,10 +37561,10 @@ fileCommand.command("ls [path]").description("List files").option("--json", "Out
     return `${muted(size.padStart(10))}  ${name}`;
   });
 }));
-fileCommand.command("cat <path>").description("Read a file").option("--json", "Output as JSON").action((path4, opts) => run("Read", async () => {
+fileCommand.command("cat <path>").description("Read a file").option("--json", "Output as JSON").action((path5, opts) => run("Read", async () => {
   const { config } = await resolveProjectContext();
   const res = await get(
-    `/projects/${config.projectGuid}/files/read?path=${encodeURIComponent(path4)}`
+    `/projects/${config.projectGuid}/files/read?path=${encodeURIComponent(path5)}`
   );
   if (opts.json) {
     console.log(JSON.stringify(res.data));
@@ -37210,9 +37572,9 @@ fileCommand.command("cat <path>").description("Read a file").option("--json", "O
     process.stdout.write(res.data.content);
   }
 }));
-fileCommand.command("tree [path]").description("Show the file tree").option("--json", "Output as JSON").action((path4, opts) => run("Tree", async () => {
+fileCommand.command("tree [path]").description("Show the file tree").option("--json", "Output as JSON").action((path5, opts) => run("Tree", async () => {
   const { config } = await resolveProjectContext();
-  const query = path4 ? `?path=${encodeURIComponent(path4)}` : "";
+  const query = path5 ? `?path=${encodeURIComponent(path5)}` : "";
   const res = await get(
     `/projects/${config.projectGuid}/files/tree${query}`
   );
@@ -37221,16 +37583,16 @@ fileCommand.command("tree [path]").description("Show the file tree").option("--j
     return `${f.path}${size}`;
   });
 }));
-fileCommand.command("rm <path>").description("Delete a file or folder").option("--json", "Output as JSON").action((path4, opts) => run("Delete", async () => {
+fileCommand.command("rm <path>").description("Delete a file or folder").option("--json", "Output as JSON").action((path5, opts) => run("Delete", async () => {
   const { config } = await resolveProjectContext();
   const res = await del(
-    `/projects/${config.projectGuid}/files?path=${encodeURIComponent(path4)}`
+    `/projects/${config.projectGuid}/files?path=${encodeURIComponent(path5)}`
   );
-  printResult(`Deleted: ${path4}`, opts, res);
+  printResult(`Deleted: ${path5}`, opts, res);
 }));
-fileCommand.command("versions <path>").description("List file versions").option("--limit <n>", "Max versions to return", "20").option("--json", "Output as JSON").action((path4, opts) => run("Versions", async () => {
+fileCommand.command("versions <path>").description("List file versions").option("--limit <n>", "Max versions to return", "20").option("--json", "Output as JSON").action((path5, opts) => run("Versions", async () => {
   const { config } = await resolveProjectContext();
-  const query = `?path=${encodeURIComponent(path4)}&limit=${opts.limit}`;
+  const query = `?path=${encodeURIComponent(path5)}&limit=${opts.limit}`;
   const res = await get(
     `/projects/${config.projectGuid}/files/versions${query}`
   );
@@ -37240,11 +37602,11 @@ fileCommand.command("versions <path>").description("List file versions").option(
     return `${info(`v${v7.version}`)}  ${muted(date)}  ${formatSize(v7.size).padStart(8)}  [${v7.source}]${marker}`;
   });
 }));
-fileCommand.command("restore <path> <version>").description("Restore a file to a version").option("--json", "Output as JSON").action((path4, version, opts) => run("Restore", async () => {
+fileCommand.command("restore <path> <version>").description("Restore a file to a version").option("--json", "Output as JSON").action((path5, version, opts) => run("Restore", async () => {
   const { config } = await resolveProjectContext();
   const res = await post(
     `/projects/${config.projectGuid}/files/version-restore`,
-    { path: path4, version: Number(version) }
+    { path: path5, version: Number(version) }
   );
   printResult(`Restored ${res.data.path} to v${res.data.version} (${formatSize(res.data.size)}).`, opts, res.data);
 }));
@@ -37371,8 +37733,8 @@ storageCommand.command("retention").description("View or adjust your file versio
 init_platform();
 init_auth();
 init_api();
-import { join as join15, dirname as dirname10, resolve as resolve13, basename as basename4, sep as sep4 } from "path";
-import { existsSync as existsSync12, mkdirSync as mkdirSync10, readFileSync as readFileSync16, writeFileSync as writeFileSync10, renameSync as renameSync2, readdirSync as readdirSync6, statSync as statSync7 } from "fs";
+import { join as join16, dirname as dirname10, resolve as resolve14, basename as basename4, sep as sep4 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync16, writeFileSync as writeFileSync10, renameSync as renameSync2, readdirSync as readdirSync7, statSync as statSync7 } from "fs";
 import { homedir as homedir11 } from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -37523,7 +37885,7 @@ import { readFileSync as readFileSync15 } from "node:fs";
 
 // src/relay/installers.ts
 import { homedir as homedir8, platform as osPlatform } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 var UnsupportedPlatformError = class extends Error {
   constructor(plat) {
     super(`gipity relay install does not support ${plat}`);
@@ -37541,8 +37903,8 @@ function display(argvs) {
 }
 function launchdPlan(cliPath) {
   const label2 = "ai.gipity.relay";
-  const path4 = join13(homedir8(), "Library", "LaunchAgents", `${label2}.plist`);
-  const logDir = join13(homedir8(), "Library", "Logs", "Gipity");
+  const path5 = join14(homedir8(), "Library", "LaunchAgents", `${label2}.plist`);
+  const logDir = join14(homedir8(), "Library", "Logs", "Gipity");
   const uid = process.getuid?.() ?? 0;
   const target = `gui/${uid}`;
   const content = `<?xml version="1.0" encoding="UTF-8"?>
@@ -37566,18 +37928,18 @@ function launchdPlan(cliPath) {
   <dict>
     <key>SuccessfulExit</key><false/>
   </dict>
-  <key>StandardOutPath</key><string>${join13(logDir, "relay.out.log")}</string>
-  <key>StandardErrorPath</key><string>${join13(logDir, "relay.err.log")}</string>
+  <key>StandardOutPath</key><string>${join14(logDir, "relay.out.log")}</string>
+  <key>StandardErrorPath</key><string>${join14(logDir, "relay.err.log")}</string>
   <key>ProcessType</key><string>Background</string>
 </dict>
 </plist>
 `;
-  const enableCmds = [["launchctl", "bootstrap", target, path4]];
-  const disableCmds = [["launchctl", "bootout", target, path4]];
+  const enableCmds = [["launchctl", "bootstrap", target, path5]];
+  const disableCmds = [["launchctl", "bootout", target, path5]];
   const statusCmd = ["launchctl", "print", `${target}/${label2}`];
   return {
     platform: "darwin",
-    path: path4,
+    path: path5,
     content,
     enableCmds,
     disableCmds,
@@ -37590,7 +37952,7 @@ function launchdPlan(cliPath) {
 }
 function systemdUserPlan(cliPath) {
   const unitName = "gipity-relay.service";
-  const path4 = join13(homedir8(), ".config", "systemd", "user", unitName);
+  const path5 = join14(homedir8(), ".config", "systemd", "user", unitName);
   const content = `[Unit]
 Description=Gipity relay - local Claude Code control from the Gipity web CLI
 After=network-online.target
@@ -37615,7 +37977,7 @@ WantedBy=default.target
   const statusCmd = ["systemctl", "--user", "status", unitName];
   return {
     platform: "linux",
-    path: path4,
+    path: path5,
     content,
     enableCmds,
     disableCmds,
@@ -37628,7 +37990,7 @@ WantedBy=default.target
 }
 function windowsTaskPlan(cliPath) {
   const taskName = "GipityRelay";
-  const path4 = join13(homedir8(), "AppData", "Local", "Gipity", "relay-task.xml");
+  const path5 = join14(homedir8(), "AppData", "Local", "Gipity", "relay-task.xml");
   const runsViaNode = /\.[cm]?js$/i.test(cliPath);
   const command = runsViaNode ? process.execPath : cliPath;
   const argLine = runsViaNode ? `"${cliPath}" relay run` : "relay run";
@@ -37664,7 +38026,7 @@ function windowsTaskPlan(cliPath) {
 </Task>
 `;
   const enableCmds = [
-    ["schtasks", "/Create", "/TN", taskName, "/XML", path4, "/F"],
+    ["schtasks", "/Create", "/TN", taskName, "/XML", path5, "/F"],
     ["schtasks", "/Run", "/TN", taskName]
   ];
   const disableCmds = [
@@ -37674,7 +38036,7 @@ function windowsTaskPlan(cliPath) {
   const statusCmd = ["schtasks", "/Query", "/TN", taskName, "/V", "/FO", "LIST"];
   return {
     platform: "win32",
-    path: path4,
+    path: path5,
     content,
     enableCmds,
     disableCmds,
@@ -37690,7 +38052,7 @@ function windowsTaskPlan(cliPath) {
 init_platform();
 init_api();
 import { hostname as hostname3, userInfo, platform as osPlatform2 } from "os";
-import { resolve as resolve12, dirname as dirname9 } from "path";
+import { resolve as resolve13, dirname as dirname9 } from "path";
 import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
 
 // src/relay/machine-id.ts
@@ -37703,9 +38065,9 @@ function rawMachineId() {
   if (override) return `override:${override}`;
   try {
     if (platform() === "linux") {
-      for (const path4 of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
+      for (const path5 of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
         try {
-          const id2 = readFileSync14(path4, "utf-8").trim();
+          const id2 = readFileSync14(path5, "utf-8").trim();
           if (id2) return `linux:${id2}`;
         } catch {
         }
@@ -37752,7 +38114,7 @@ function friendlyDeviceName() {
   return host || `My ${kind}`;
 }
 function resolveCliPath() {
-  return resolve12(process.argv[1] ?? "gipity");
+  return resolve13(process.argv[1] ?? "gipity");
 }
 async function pairDevice(opts = {}) {
   const existing = getDevice();
@@ -38204,9 +38566,9 @@ function printFull(opts, outerW) {
 
 // src/claude-setup.ts
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { homedir as homedir10 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var CLAUDE_PACKAGE = "@anthropic-ai/claude-code";
 function claudeInstallPlan(platformOverride) {
   const plat = platformOverride ?? process.platform;
@@ -38225,7 +38587,7 @@ function isClaudeInstalled(platformOverride) {
 }
 function isClaudeAuthenticated() {
   if (process.env.CLAUDE_CODE_OAUTH_TOKEN || process.env.ANTHROPIC_API_KEY) return true;
-  return existsSync11(join14(homedir10(), ".claude", ".credentials.json"));
+  return existsSync12(join15(homedir10(), ".claude", ".credentials.json"));
 }
 function probeClaudeAuthenticated() {
   if (!isClaudeInstalled()) return false;
@@ -38255,8 +38617,8 @@ function ensureClaudeInstalled(opts = {}) {
 var __clDir = dirname10(fileURLToPath2(import.meta.url));
 function readOwnPkg(fromDir) {
   for (let d = fromDir; ; d = dirname10(d)) {
-    const p = join15(d, "package.json");
-    if (existsSync12(p)) {
+    const p = join16(d, "package.json");
+    if (existsSync13(p)) {
       try {
         const pkg2 = JSON.parse(readFileSync16(p, "utf-8"));
         if (pkg2.name === "gipity") return pkg2;
@@ -38307,12 +38669,12 @@ function localFsFallback(dir) {
   const topLevelEntries = [];
   const walk = (d, depth) => {
     try {
-      for (const name of readdirSync6(d).sort()) {
+      for (const name of readdirSync7(d).sort()) {
         if (isSyncIgnored(name)) continue;
         let isDir = false;
         let size = 0;
         try {
-          const st2 = statSync7(join15(d, name));
+          const st2 = statSync7(join16(d, name));
           isDir = st2.isDirectory();
           size = st2.isFile() ? st2.size : 0;
         } catch {
@@ -38321,7 +38683,7 @@ function localFsFallback(dir) {
         if (isDir) {
           folderCount++;
           if (depth === 0) topLevelEntries.push(`${name}/`);
-          walk(join15(d, name), depth + 1);
+          walk(join16(d, name), depth + 1);
         } else {
           fileCount++;
           totalBytes += size;
@@ -38354,8 +38716,8 @@ function hasStreamJsonFlag(args) {
 }
 function markFolderTrusted(dir) {
   try {
-    const file = join15(homedir11(), ".claude.json");
-    const cfg = existsSync12(file) ? JSON.parse(readFileSync16(file, "utf-8")) : {};
+    const file = join16(homedir11(), ".claude.json");
+    const cfg = existsSync13(file) ? JSON.parse(readFileSync16(file, "utf-8")) : {};
     if (typeof cfg !== "object" || cfg === null) return;
     if (typeof cfg.projects !== "object" || cfg.projects === null) cfg.projects = {};
     const entry = typeof cfg.projects[dir] === "object" && cfg.projects[dir] !== null ? cfg.projects[dir] : {};
@@ -38468,7 +38830,7 @@ var claudeCommand = new Command("claude").description("Set up and run Claude Cod
     let existing = getConfig();
     let forceAdoptCwd = false;
     if (existing && !opts.newProject && !opts.project && !nonInteractive) {
-      const cwdHasConfig = existsSync12(resolve13(process.cwd(), ".gipity.json"));
+      const cwdHasConfig = existsSync13(resolve14(process.cwd(), ".gipity.json"));
       if (!cwdHasConfig && isLikelyEmpty(process.cwd())) {
         const ancestorRoot = dirname10(getConfigPath());
         console.log(`  ${bold("You are inside an existing Gipity project.")}
@@ -38517,7 +38879,7 @@ var claudeCommand = new Command("claude").description("Set up and run Claude Cod
         }
         project = found;
       }
-      const projectDir2 = opts.here ? process.cwd() : join15(getProjectsRoot(), project.slug);
+      const projectDir2 = opts.here ? process.cwd() : join16(getProjectsRoot(), project.slug);
       mkdirSync10(projectDir2, { recursive: true });
       process.chdir(projectDir2);
       clearConfigCache();
@@ -38646,7 +39008,7 @@ var claudeCommand = new Command("claude").description("Set up and run Claude Cod
       } else {
         project = result.project;
         isNewProject = result.kind === "create-new";
-        const projectDir2 = join15(getProjectsRoot(), project.slug);
+        const projectDir2 = join16(getProjectsRoot(), project.slug);
         mkdirSync10(projectDir2, { recursive: true });
         process.chdir(projectDir2);
         clearConfigCache();
@@ -39813,8 +40175,8 @@ Examples:
 init_colors();
 init_utils();
 import { createHash as createHash5 } from "crypto";
-function expectedType(path4) {
-  const p = path4.toLowerCase().split("?")[0].split("#")[0];
+function expectedType(path5) {
+  const p = path5.toLowerCase().split("?")[0].split("#")[0];
   if (p.endsWith(".json")) return "json";
   if (p.endsWith(".xml")) return "xml";
   if (p.endsWith(".html") || p.endsWith(".htm")) return "html";
@@ -39845,8 +40207,8 @@ function sha256(s) {
 function baseWithSlash(url) {
   return url.endsWith("/") ? url : url + "/";
 }
-function resolveUrl(base, path4) {
-  return new URL(path4.replace(/^\/+/, ""), baseWithSlash(base)).toString();
+function resolveUrl(base, path5) {
+  return new URL(path5.replace(/^\/+/, ""), baseWithSlash(base)).toString();
 }
 async function fetchRaw(url) {
   try {
@@ -39868,12 +40230,12 @@ async function probeShell(base) {
     isHtml: looksLikeHtml(r.body)
   };
 }
-function classify(path4, r, shell) {
+function classify(path5, r, shell) {
   if (!r) return { status: null, contentType: null, bytes: 0, verdict: "MISSING", detail: "fetch failed (host unreachable)" };
   const bytes = Buffer.byteLength(r.body);
   const base = { status: r.status, contentType: r.contentType, bytes };
   if (r.status >= 400) return { ...base, verdict: "MISSING", detail: `HTTP ${r.status}` };
-  const expect = expectedType(path4);
+  const expect = expectedType(path5);
   if (shell.served && shell.sha256 && sha256(r.body) === shell.sha256) {
     return { ...base, verdict: "MISSING", detail: `HTTP ${r.status} but served the SPA shell (file not deployed)` };
   }
@@ -40073,8 +40435,8 @@ fnCommand.command("call <name> [body]").description("Call a function").option("-
   const config = requireConfig();
   const raw = bodyArg || opts.data || "{}";
   const body = JSON.parse(raw);
-  const path4 = `/api/${config.projectGuid}/fn/${encodeURIComponent(name)}`;
-  const res = opts.anon ? await callAnon(config.projectGuid, name, body) : await post(path4, body);
+  const path5 = `/api/${config.projectGuid}/fn/${encodeURIComponent(name)}`;
+  const res = opts.anon ? await callAnon(config.projectGuid, name, body) : await post(path5, body);
   if (opts.field) {
     emitField(res.data, opts.field);
     return;
@@ -40127,8 +40489,8 @@ serviceCommand.command("list").description("List callable app services").action(
 }));
 serviceCommand.command("call <name> [body]").description("Call an app service by name (e.g. llm, image, music). Uses your logged-in session - no token wrangling.").option("--data <json>", "JSON request body (alternative to the positional [body])").option("--get", "Issue a GET (for listing endpoints like llm/models, tts/voices)").option("--json", "Output compact JSON").action((name, bodyArg, opts) => run("Call", async () => {
   const config = requireConfig();
-  const path4 = name.split("/").map(encodeURIComponent).join("/");
-  const url = `/api/${config.projectGuid}/services/${path4}`;
+  const path5 = name.split("/").map(encodeURIComponent).join("/");
+  const url = `/api/${config.projectGuid}/services/${path5}`;
   const res = opts.get ? await get(url) : await post(url, JSON.parse(bodyArg || opts.data || "{}"));
   console.log(opts.json ? JSON.stringify(res) : JSON.stringify(res, null, 2));
 }));
@@ -40557,11 +40919,11 @@ jobCommand.command("cancel <runGuid>").description("Cancel a queued or running j
   }
 }));
 jobCommand.command("run-local <name>").description("Run the job in a local Docker container against your local filesystem (no platform round-trip)").option("--image <image>", "Docker image to run inside", "easyclaw/sandbox:latest").option("--no-deps", "Skip pip/npm install even if a deps file is present").action(async (name, opts) => {
-  const { existsSync: existsSync22, statSync: statSync10 } = await import("node:fs");
-  const { resolve: resolve18, join: join24 } = await import("node:path");
+  const { existsSync: existsSync23, statSync: statSync10 } = await import("node:fs");
+  const { resolve: resolve19, join: join25 } = await import("node:path");
   const { spawnCommand: spawnCommand2, spawnSyncCommand: spawnSyncCommand2 } = await Promise.resolve().then(() => (init_platform(), platform_exports));
-  const jobDir = resolve18(process.cwd(), "jobs", name);
-  if (!existsSync22(jobDir) || !statSync10(jobDir).isDirectory()) {
+  const jobDir = resolve19(process.cwd(), "jobs", name);
+  if (!existsSync23(jobDir) || !statSync10(jobDir).isDirectory()) {
     console.error(error(`jobs/${name}/ not found in current directory`));
     process.exit(1);
   }
@@ -40582,7 +40944,7 @@ jobCommand.command("run-local <name>").description("Run the job in a local Docke
     },
     { file: "main.sh", runtime: "bash", entry: "bash" }
   ];
-  const picked = variants.find((v7) => existsSync22(join24(jobDir, v7.file)));
+  const picked = variants.find((v7) => existsSync23(join25(jobDir, v7.file)));
   if (!picked) {
     console.error(error(`No main.py / main.js / main.sh found under jobs/${name}/`));
     process.exit(1);
@@ -40607,7 +40969,7 @@ jobCommand.command("run-local <name>").description("Run the job in a local Docke
     "-v",
     `${jobDir}:/work`
   ];
-  const needsDeps = opts.deps !== false && picked.depsFile && picked.installCmd && existsSync22(join24(jobDir, picked.depsFile));
+  const needsDeps = opts.deps !== false && picked.depsFile && picked.installCmd && existsSync23(join25(jobDir, picked.depsFile));
   const handlerCmd = `${picked.entry} /work/${picked.file}`;
   let shellCmd;
   if (needsDeps && picked.installCmd) {
@@ -40783,30 +41145,59 @@ init_api();
 init_config();
 init_colors();
 import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
-import { resolve as resolvePath2, dirname as dirname11, relative as relative4, isAbsolute } from "path";
+import { resolve as resolvePath2, dirname as dirname11, relative as relative5, isAbsolute } from "path";
 
 // src/provider-docs.ts
 var IMAGE_GEMINI_ASPECT_RATIOS = `1:1, 16:9, 9:16, 4:3, 3:4, 3:2, 2:3, 4:5, 5:4, 21:9`;
 var IMAGE_GEMINI_SIZES = `512, 1K, 2K, 4K`;
-var IMAGE_MODELS_DOC = `openai: gpt-image-2, gpt-image-1.5. bfl: flux-2-pro, flux-2-flex, flux-2-max, flux-dev. gemini: gemini-2.5-flash-image, gemini-3.1-flash-image, gemini-3-pro-image`;
+var IMAGE_MODELS_DOC = `openai: gpt-image-2. bfl: flux-2-pro, flux-2-flex, flux-2-max, flux-2-klein-9b, flux-2-klein-4b. gemini: gemini-3.1-flash-lite-image, gemini-2.5-flash-image, gemini-3.1-flash-image, gemini-3-pro-image`;
 var TTS_PROVIDER_DESCRIPTIONS = {
   "elevenlabs": `ElevenLabs (many voices - use voice_set list to discover)`,
   "openai": `OpenAI (alloy, ash, ballad, coral, echo, fable, nova, onyx, sage, shimmer, verse)`,
   "gemini": `Gemini (30 voices: Kore, Puck, Zephyr, Charon, Fenrir, Leda, Orus, Aoede, and 22 more). Multi-speaker (up to 2) and 60+ languages`
 };
-var VIDEO_MODELS_DOC = `veo-3.1-generate-preview (best quality, ~$0.40/sec), veo-3.1-fast-generate-preview (faster, ~$0.15/sec), veo-3.1-lite-generate-preview (budget, ~$0.07/sec)`;
+var VIDEO_MODELS_DOC = `veo-3.1-generate-preview (best quality, up to 4K, ~$0.40/sec), veo-3.1-fast-generate-preview (faster, ~$0.10/sec), veo-3.1-lite-generate-preview (budget, ~$0.05/sec), gemini-omni-flash-preview (3-10s @ 720p, conversational editing, ~$0.10/sec)`;
 
 // src/commands/generate.ts
 async function downloadFile(url, filename) {
   const res = await fetch(url);
   if (!res.ok) throw new Error(`Download failed: ${res.status}`);
   const buffer = Buffer.from(await res.arrayBuffer());
-  ensureOutputDir(filename);
-  writeFileSync11(filename, buffer);
-  const savedPath = resolvePath2(filename);
+  const outPath = correctExtension(filename, buffer);
+  ensureOutputDir(outPath);
+  writeFileSync11(outPath, buffer);
+  const savedPath = resolvePath2(outPath);
   await pushGenerated(savedPath);
   return savedPath;
 }
+function sniffExt(buf) {
+  const ascii = (start, end) => buf.subarray(start, end).toString("latin1");
+  if (buf.length < 4) return void 0;
+  if (buf[0] === 255 && buf[1] === 216 && buf[2] === 255) return "jpg";
+  if (ascii(0, 8) === "\x89PNG\r\n\n") return "png";
+  if (ascii(0, 4) === "RIFF" && ascii(8, 12) === "WEBP") return "webp";
+  if (ascii(0, 4) === "RIFF" && ascii(8, 12) === "WAVE") return "wav";
+  if (ascii(0, 3) === "GIF") return "gif";
+  if (ascii(4, 8) === "ftyp") return "mp4";
+  if (buf[0] === 26 && buf[1] === 69 && buf[2] === 223 && buf[3] === 163) return "webm";
+  if (ascii(0, 3) === "ID3" || buf[0] === 255 && (buf[1] & 224) === 224) return "mp3";
+  return void 0;
+}
+var EXT_ALIASES = { jpeg: "jpg", htm: "html", yml: "yaml" };
+var canonicalExt = (ext) => EXT_ALIASES[ext] ?? ext;
+var formatName = (ext) => canonicalExt(ext) === "jpg" ? "JPEG" : ext.toUpperCase();
+function correctExtension(filename, buf) {
+  const actual = sniffExt(buf);
+  if (!actual) return filename;
+  const dot = filename.lastIndexOf(".");
+  const asked = dot > 0 ? filename.slice(dot + 1).toLowerCase() : "";
+  if (canonicalExt(asked) === actual) return filename;
+  const corrected = `${dot > 0 ? filename.slice(0, dot) : filename}.${actual}`;
+  console.error(muted(
+    `Note: the model returned ${formatName(actual)}, not ${asked ? formatName(asked) : "the requested format"} \u2014 saving as ${corrected} so the extension matches the actual bytes.`
+  ));
+  return corrected;
+}
 function ensureOutputDir(output) {
   const dir = dirname11(resolvePath2(output));
   try {
@@ -40818,7 +41209,7 @@ function ensureOutputDir(output) {
 async function pushGenerated(savedPath) {
   const configPath = getConfigPath();
   if (!configPath) return;
-  const rel2 = relative4(dirname11(configPath), savedPath);
+  const rel2 = relative5(dirname11(configPath), savedPath);
   if (rel2.startsWith("..") || isAbsolute(rel2)) return;
   try {
     await pushFile(savedPath);
@@ -40861,10 +41252,10 @@ Examples:
     } else {
       const sizeKb = Math.round(result.size_bytes / 1024);
       console.log(`${muted(`Generated with ${result.provider}/${result.model} (${sizeKb}KB)`)}`);
-      console.log(success(`Saved to ${savedPath}`));
       if (result.seed !== void 0) {
         console.log(muted(`Seed ${result.seed} \u2014 pass --seed ${result.seed} to keep the next image coherent`));
       }
+      console.log(success(`Saved to ${savedPath}`));
     }
   } catch (err) {
     printCommandError("Image generation", err);
@@ -41043,14 +41434,14 @@ var generateCommand = new Command("generate").description("Generate images, vide
 init_api();
 init_config();
 init_colors();
-import { existsSync as existsSync13, readFileSync as readFileSync17 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync17 } from "fs";
+import { join as join17 } from "path";
 function readInstalledKitReadme(name) {
   const root = getProjectRoot() ?? process.cwd();
-  const kitDir = join16(root, "src", "packages", name);
-  if (!existsSync13(join16(kitDir, "package.json"))) return null;
-  const readme = join16(kitDir, "README.md");
-  return existsSync13(readme) ? readFileSync17(readme, "utf-8") : null;
+  const kitDir = join17(root, "src", "packages", name);
+  if (!existsSync14(join17(kitDir, "package.json"))) return null;
+  const readme = join17(kitDir, "README.md");
+  return existsSync14(readme) ? readFileSync17(readme, "utf-8") : null;
 }
 var skillCommand = new Command("skill").description("Task docs - read the matching skill before building");
 skillCommand.command("list").description("List skills").option("--json", "Output as JSON").action((opts) => run("List", async () => {
@@ -41223,15 +41614,15 @@ var domainCommand = new Command("domain").description("Manage custom domains").a
 }));
 
 // src/commands/realtime.ts
-import { existsSync as existsSync14 } from "fs";
-import { dirname as dirname12, resolve as resolve14 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { dirname as dirname12, resolve as resolve15 } from "path";
 init_api();
 init_config();
 init_colors();
 function hasDeployManifest() {
   const cfgPath = getConfigPath();
   if (!cfgPath) return false;
-  return existsSync14(resolve14(dirname12(cfgPath), "gipity.yaml"));
+  return existsSync15(resolve15(dirname12(cfgPath), "gipity.yaml"));
 }
 var roomCommand = new Command("room").description("Manage realtime rooms").argument("[action]", "list | create | delete | info", "list").argument("[name]", "room name (for create | delete | info)").option("--type <type>", "room type for create: state | relay", "state").option("--auth <level>", "auth level for create: public | user", "public").option("--max-clients <n>", "max clients for create (1-200)").option("--json", "Output as JSON").action((action, name, opts) => run("Realtime room", async () => {
   const config = requireConfig();
@@ -41364,10 +41755,10 @@ async function pollTestStatus(projectGuid, runGuid, opts) {
         if (!groups.has(key)) groups.set(key, []);
         groups.get(key).push(r);
       }
-      for (const [path4, results] of groups) {
+      for (const [path5, results] of groups) {
         const existingPaths = new Set(data.results.slice(0, lastResultCount).map((r) => r.path));
-        if (!existingPaths.has(path4)) {
-          console.log(`  ${dim(path4)}`);
+        if (!existingPaths.has(path5)) {
+          console.log(`  ${dim(path5)}`);
         }
         for (const r of results) {
           const icon = r.isFlaky ? warning("~") : statusIcon2(r.status);
@@ -41407,7 +41798,7 @@ async function pollTestStatus(projectGuid, runGuid, opts) {
         }
       }
     }
-    await new Promise((resolve18) => setTimeout(resolve18, getPollInterval()));
+    await new Promise((resolve19) => setTimeout(resolve19, getPollInterval()));
   }
 }
 var testCommand = new Command("test").description("Run tests").argument("[path]", 'Test path filter (e.g. "api", "e2e/portal")').option("--filter <path>", "Alias for the positional test path filter").option("--timeout <ms>", "Per-test timeout in ms", "30000").option("--retry <n>", "Retry failed tests N times", "0").option("--no-sync", "Skip sync-up before tests").option("--json", "Output as JSON").action((pathFilter, opts) => run("Test", async () => {
@@ -41617,21 +42008,21 @@ var locationCommand = new Command("location").description("Show location").argum
 }));
 
 // src/commands/doctor.ts
-import { existsSync as existsSync16, readFileSync as readFileSync19, statSync as statSync8 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync19, statSync as statSync8 } from "fs";
+import { join as join19 } from "path";
 import { homedir as homedir13 } from "os";
 
 // src/updater/state.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync12, mkdirSync as mkdirSync12, existsSync as existsSync15 } from "fs";
-import { join as join17 } from "path";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync12, mkdirSync as mkdirSync12, existsSync as existsSync16 } from "fs";
+import { join as join18 } from "path";
 import { homedir as homedir12 } from "os";
-var GIPITY_DIR = join17(homedir12(), ".gipity");
-var LOCAL_DIR = join17(GIPITY_DIR, "local");
-var LOCAL_PKG_DIR = join17(LOCAL_DIR, "node_modules", "gipity");
-var LOCAL_ENTRY = join17(LOCAL_PKG_DIR, "dist", "index.js");
-var STATE_FILE = join17(GIPITY_DIR, "update-state.json");
-var SETTINGS_FILE = join17(GIPITY_DIR, "settings.json");
-var UPDATE_LOG = join17(GIPITY_DIR, "update.log");
+var GIPITY_DIR = join18(homedir12(), ".gipity");
+var LOCAL_DIR = join18(GIPITY_DIR, "local");
+var LOCAL_PKG_DIR = join18(LOCAL_DIR, "node_modules", "gipity");
+var LOCAL_ENTRY = join18(LOCAL_PKG_DIR, "dist", "index.js");
+var STATE_FILE = join18(GIPITY_DIR, "update-state.json");
+var SETTINGS_FILE = join18(GIPITY_DIR, "settings.json");
+var UPDATE_LOG = join18(GIPITY_DIR, "update.log");
 var DEFAULT_STATE = {
   installedVersion: null,
   lastCheckAt: 0,
@@ -41645,7 +42036,7 @@ function ensureDir() {
   mkdirSync12(GIPITY_DIR, { recursive: true });
 }
 function readState() {
-  if (!existsSync15(STATE_FILE)) return { ...DEFAULT_STATE };
+  if (!existsSync16(STATE_FILE)) return { ...DEFAULT_STATE };
   try {
     return { ...DEFAULT_STATE, ...JSON.parse(readFileSync18(STATE_FILE, "utf-8")) };
   } catch {
@@ -41657,7 +42048,7 @@ function writeState(state) {
   writeFileSync12(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function readSettings() {
-  if (!existsSync15(SETTINGS_FILE)) return { ...DEFAULT_SETTINGS };
+  if (!existsSync16(SETTINGS_FILE)) return { ...DEFAULT_SETTINGS };
   try {
     return { ...DEFAULT_SETTINGS, ...JSON.parse(readFileSync18(SETTINGS_FILE, "utf-8")) };
   } catch {
@@ -41692,8 +42083,8 @@ function versionManagerNode(execPath, env = process.env, home = homedir13()) {
   return null;
 }
 function localVersion() {
-  const pkgPath = join18(LOCAL_PKG_DIR, "package.json");
-  if (!existsSync16(pkgPath)) return null;
+  const pkgPath = join19(LOCAL_PKG_DIR, "package.json");
+  if (!existsSync17(pkgPath)) return null;
   try {
     return JSON.parse(readFileSync19(pkgPath, "utf-8")).version ?? null;
   } catch {
@@ -41718,7 +42109,7 @@ function rel(t) {
 }
 function relayAutostartInstalled() {
   try {
-    return existsSync16(planFor({ cliPath: resolveCliPath() }).path);
+    return existsSync17(planFor({ cliPath: resolveCliPath() }).path);
   } catch (err) {
     if (err instanceof UnsupportedPlatformError) return null;
     return null;
@@ -41756,7 +42147,7 @@ function gatherEnv(opts = {}) {
   const cli = {
     shim_version: shimVersion(),
     local_version: localVersion(),
-    local_install_ok: existsSync16(LOCAL_ENTRY),
+    local_install_ok: existsSync17(LOCAL_ENTRY),
     auto_updates: !dis.disabled,
     updates_disabled_reason: dis.disabled ? dis.reason ?? null : null,
     last_check_at: updState.lastCheckAt,
@@ -41791,7 +42182,7 @@ var doctorCommand = new Command("doctor").description("Check install + environme
   const settings = readSettings();
   const dis = updatesDisabled();
   const local = localVersion();
-  const localOk = existsSync16(LOCAL_ENTRY);
+  const localOk = existsSync17(LOCAL_ENTRY);
   console.log("");
   console.log(bold("CLI install"));
   console.log(`${muted("shim version    ")} ${shimVersion()}`);
@@ -41799,17 +42190,17 @@ var doctorCommand = new Command("doctor").description("Check install + environme
   console.log(`${muted("local install   ")} ${LOCAL_PKG_DIR}`);
   console.log("");
   console.log(`${muted("auto-updates    ")} ${dis.disabled ? warning(`disabled (${dis.reason})`) : success("enabled")}`);
-  console.log(`${muted("settings file   ")} ${existsSync16(SETTINGS_FILE) ? SETTINGS_FILE : dim("(default)")}  autoUpdates=${settings.autoUpdates}`);
+  console.log(`${muted("settings file   ")} ${existsSync17(SETTINGS_FILE) ? SETTINGS_FILE : dim("(default)")}  autoUpdates=${settings.autoUpdates}`);
   console.log(`${muted("last check      ")} ${rel(state.lastCheckAt)}`);
   console.log(`${muted("last error      ")} ${state.lastError ? error(state.lastError) : dim("none")}`);
-  console.log(`${muted("state file      ")} ${existsSync16(STATE_FILE) ? STATE_FILE : dim("(none yet)")}`);
-  console.log(`${muted("update log      ")} ${existsSync16(UPDATE_LOG) ? `${UPDATE_LOG} (${statSync8(UPDATE_LOG).size} bytes)` : dim("(none yet)")}`);
+  console.log(`${muted("state file      ")} ${existsSync17(STATE_FILE) ? STATE_FILE : dim("(none yet)")}`);
+  console.log(`${muted("update log      ")} ${existsSync17(UPDATE_LOG) ? `${UPDATE_LOG} (${statSync8(UPDATE_LOG).size} bytes)` : dim("(none yet)")}`);
   console.log("");
   console.log(dim("Force an update with: gipity update"));
 });
 
 // src/updater/check.ts
-import { appendFileSync, existsSync as existsSync17 } from "fs";
+import { appendFileSync, existsSync as existsSync18 } from "fs";
 init_platform();
 var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
 function log(line) {
@@ -41844,7 +42235,7 @@ function installVersion(version) {
     stdio: "ignore"
   });
   if (res.error) log(`npm spawn failed: ${res.error.message}`);
-  return res.status === 0 && existsSync17(LOCAL_ENTRY);
+  return res.status === 0 && existsSync18(LOCAL_ENTRY);
 }
 async function runCheck(opts = {}) {
   const state = readState();
@@ -41918,17 +42309,17 @@ var updateCommand = new Command("update").description("Update the CLI").action(a
 init_api();
 init_utils();
 init_colors();
-import { existsSync as existsSync20, readFileSync as readFileSync22, unlinkSync as unlinkSync7 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync22, unlinkSync as unlinkSync7 } from "fs";
 import { spawn as spawn2 } from "child_process";
 
 // src/relay/daemon.ts
 init_platform();
 init_config();
-import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync14, existsSync as existsSync19, readFileSync as readFileSync21, writeFileSync as writeFileSync13, chmodSync as chmodSync3, closeSync as closeSync4, openSync as openSync4, unlinkSync as unlinkSync6 } from "fs";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync14, existsSync as existsSync20, readFileSync as readFileSync21, writeFileSync as writeFileSync13, chmodSync as chmodSync3, closeSync as closeSync4, openSync as openSync4, unlinkSync as unlinkSync6 } from "fs";
 import { stat, readFile } from "fs/promises";
 import { createInterface as createInterface2 } from "readline";
 import { homedir as homedir15, hostname as hostname5, platform as osPlatform3, loadavg as loadavg2, freemem as freemem2, totalmem as totalmem2, cpus as cpus2 } from "os";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 init_auth();
 init_api();
 
@@ -42218,6 +42609,214 @@ var IngestQueue = class {
   }
 };
 
+// src/relay/media-upload.ts
+import path4 from "path";
+
+// src/relay/device-http.ts
+init_config();
+function apiBase() {
+  return resolveApiBase();
+}
+function deviceToken() {
+  const d = getDevice();
+  if (!d) throw new Error("No device registered. Run: gipity login");
+  return d.token;
+}
+function bridgeAbort(outer, inner) {
+  if (outer.aborted) {
+    inner.abort(outer.reason);
+    return () => {
+    };
+  }
+  const onAbort = () => {
+    inner.abort(outer.reason);
+  };
+  outer.addEventListener("abort", onAbort, { once: true });
+  return () => outer.removeEventListener("abort", onAbort);
+}
+async function deviceFetchBinary(method, path5, body, contentType, timeoutMs) {
+  const controller = timeoutMs ? new AbortController() : null;
+  const timer = controller ? setTimeout(() => controller.abort("timeout"), timeoutMs) : null;
+  try {
+    return await fetch(`${apiBase()}${path5}`, {
+      method,
+      headers: {
+        "Authorization": `Bearer ${deviceToken()}`,
+        "Content-Type": contentType
+      },
+      body: new Uint8Array(body),
+      signal: controller?.signal
+    });
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function deviceFetch(method, path5, body, timeoutMs, signal) {
+  const controller = timeoutMs ? new AbortController() : null;
+  const timer = controller ? setTimeout(() => controller.abort("timeout"), timeoutMs) : null;
+  const detach = signal && controller ? bridgeAbort(signal, controller) : null;
+  try {
+    return await fetch(`${apiBase()}${path5}`, {
+      method,
+      headers: {
+        "Authorization": `Bearer ${deviceToken()}`,
+        "Content-Type": "application/json"
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0,
+      signal: controller?.signal ?? signal
+    });
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (detach) detach();
+  }
+}
+
+// src/relay/media-upload.ts
+var MIN_UPLOAD_BYTES = 4 * 1024;
+var MAX_UPLOAD_BYTES = 10 * 1024 * 1024;
+var INLINE_SAFE_B64_CHARS = 12e4;
+var PATH_MAP_CAP = 500;
+var uploadViaDevice = async (convGuid, buf, opts) => {
+  const qs = new URLSearchParams({ filename: opts.filename, media_type: opts.mediaType });
+  if (opts.suggestedPath) qs.set("suggested_path", opts.suggestedPath);
+  const res = await deviceFetchBinary(
+    "POST",
+    `/remote-sessions/${encodeURIComponent(convGuid)}/media?${qs.toString()}`,
+    buf,
+    opts.mediaType,
+    3e4
+  );
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`HTTP ${res.status} ${body.slice(0, 120)}`);
+  }
+  const json = await res.json();
+  return json.data;
+};
+function extForMime(mime) {
+  switch (mime) {
+    case "image/jpeg":
+      return ".jpg";
+    case "image/gif":
+      return ".gif";
+    case "image/webp":
+      return ".webp";
+    case "image/svg+xml":
+      return ".svg";
+    default:
+      return ".png";
+  }
+}
+function isBase64ImageBlock(b7) {
+  return b7?.type === "image" && b7.source?.type === "base64" && typeof b7.source.data === "string" && b7.source.data.length > 0;
+}
+var ImageBlockRewriter = class {
+  constructor(convGuid, onWarn, upload = uploadViaDevice) {
+    this.convGuid = convGuid;
+    this.onWarn = onWarn;
+    this.upload = upload;
+  }
+  convGuid;
+  onWarn;
+  upload;
+  /** tool_use_id → the file_path the tool was asked to read (for naming +
+   *  server-side dedup against the synced node at that path). */
+  pathsByToolUseId = /* @__PURE__ */ new Map();
+  /** Project root on this machine, once the dispatch resolves it — lets an
+   *  absolute Read path map to its project-relative VFS path. */
+  cwd = null;
+  setCwd(cwd) {
+    this.cwd = cwd;
+  }
+  /** Rewrite every base64 image block in the batch to an image_ref. Never
+   *  throws — per-image failures degrade per the policy above. */
+  async rewrite(entries) {
+    const out = [];
+    for (const entry of entries) {
+      if (entry.kind === "tool_use") {
+        this.recordToolPath(entry);
+        out.push(entry);
+        continue;
+      }
+      if (entry.kind !== "tool_result" || !Array.isArray(entry.content) || typeof entry.tool_use_id !== "string") {
+        out.push(entry);
+        continue;
+      }
+      const blocks = [];
+      for (const block of entry.content) {
+        blocks.push(isBase64ImageBlock(block) ? await this.rewriteBlock(block, entry.tool_use_id) : block);
+      }
+      out.push({ ...entry, content: blocks });
+    }
+    return out;
+  }
+  recordToolPath(entry) {
+    if (typeof entry.tool_use_id !== "string") return;
+    const input = entry.tool_input;
+    const p = input && typeof input === "object" ? input.file_path ?? input.path ?? input.notebook_path : void 0;
+    if (typeof p !== "string" || !p) return;
+    if (this.pathsByToolUseId.size >= PATH_MAP_CAP) {
+      const oldest = this.pathsByToolUseId.keys().next().value;
+      if (oldest !== void 0) this.pathsByToolUseId.delete(oldest);
+    }
+    this.pathsByToolUseId.set(entry.tool_use_id, p);
+  }
+  async rewriteBlock(block, toolUseId) {
+    const b64 = block.source.data;
+    let buf;
+    try {
+      buf = Buffer.from(b64, "base64");
+    } catch {
+      return block;
+    }
+    if (buf.length < MIN_UPLOAD_BYTES) return block;
+    const mediaType = block.source.media_type || "image/png";
+    const sourcePath = this.pathsByToolUseId.get(toolUseId);
+    const filename = sourcePath ? path4.basename(sourcePath) : `image${extForMime(mediaType)}`;
+    const suggested = this.projectRelative(sourcePath);
+    if (buf.length > MAX_UPLOAD_BYTES) {
+      this.onWarn?.("transcript image exceeds upload cap - stubbed", { bytes: buf.length, filename });
+      return this.stub(filename, buf.length, "too large to store");
+    }
+    try {
+      const ref = await this.upload(this.convGuid, buf, {
+        filename,
+        mediaType,
+        ...suggested ? { suggestedPath: suggested } : {}
+      });
+      return {
+        type: "image_ref",
+        url: ref.url,
+        ...ref.thumb_url ? { thumb_url: ref.thumb_url } : {},
+        media_type: mediaType,
+        path: ref.path,
+        ...ref.width != null ? { width: ref.width } : {},
+        ...ref.height != null ? { height: ref.height } : {},
+        bytes: ref.bytes
+      };
+    } catch (err) {
+      this.onWarn?.("transcript image upload failed", { filename, err: err?.message });
+      if (b64.length <= INLINE_SAFE_B64_CHARS) return block;
+      return this.stub(filename, buf.length, `upload failed: ${err?.message || "unknown error"}`);
+    }
+  }
+  stub(filename, bytes, reason) {
+    return {
+      type: "text",
+      text: `[image ${filename} (${Math.round(bytes / 1024)} KB) omitted: ${reason}]`
+    };
+  }
+  /** Map an absolute local path to its project-relative VFS path, when it
+   *  falls inside the dispatch's project root. */
+  projectRelative(p) {
+    if (!p || !this.cwd) return void 0;
+    const abs = path4.resolve(p);
+    const root = path4.resolve(this.cwd);
+    if (!abs.startsWith(root + path4.sep)) return void 0;
+    return abs.slice(root.length + 1).split(path4.sep).join("/");
+  }
+};
+
 // src/relay/redact.ts
 var REDACTION_MARKER = "[redacted]";
 var MIN_SECRET_LEN = 12;
@@ -42428,48 +43027,6 @@ var DeltaBatcher = class {
 // src/relay/daemon.ts
 import { randomUUID } from "crypto";
 
-// src/relay/device-http.ts
-init_config();
-function apiBase() {
-  return resolveApiBase();
-}
-function deviceToken() {
-  const d = getDevice();
-  if (!d) throw new Error("No device registered. Run: gipity login");
-  return d.token;
-}
-function bridgeAbort(outer, inner) {
-  if (outer.aborted) {
-    inner.abort(outer.reason);
-    return () => {
-    };
-  }
-  const onAbort = () => {
-    inner.abort(outer.reason);
-  };
-  outer.addEventListener("abort", onAbort, { once: true });
-  return () => outer.removeEventListener("abort", onAbort);
-}
-async function deviceFetch(method, path4, body, timeoutMs, signal) {
-  const controller = timeoutMs ? new AbortController() : null;
-  const timer = controller ? setTimeout(() => controller.abort("timeout"), timeoutMs) : null;
-  const detach = signal && controller ? bridgeAbort(signal, controller) : null;
-  try {
-    return await fetch(`${apiBase()}${path4}`, {
-      method,
-      headers: {
-        "Authorization": `Bearer ${deviceToken()}`,
-        "Content-Type": "application/json"
-      },
-      body: body !== void 0 ? JSON.stringify(body) : void 0,
-      signal: controller?.signal ?? signal
-    });
-  } finally {
-    if (timer) clearTimeout(timer);
-    if (detach) detach();
-  }
-}
-
 // src/relay/agent-token.ts
 init_api();
 init_config();
@@ -42518,21 +43075,21 @@ async function revokeRelayAgentToken() {
 init_platform();
 init_client_context();
 import { cpus, freemem, totalmem, loadavg, release, uptime, homedir as homedir14 } from "os";
-import { statfsSync, readdirSync as readdirSync7 } from "fs";
-import { join as join19 } from "path";
+import { statfsSync, readdirSync as readdirSync8 } from "fs";
+import { join as join20 } from "path";
 var PROBE_TIMEOUT_MS = 4e3;
 function parseVersion(out) {
   const m = out.match(/\d+\.\d+(?:\.\d+)?(?:[-.\w]*)?/);
   return m ? m[0] : void 0;
 }
 function runProbe(cmd, args) {
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     let out = "";
     let settled = false;
     const done = (s) => {
       if (!settled) {
         settled = true;
-        resolve18(s);
+        resolve19(s);
       }
     };
     let child;
@@ -42586,7 +43143,7 @@ async function detectGpu() {
 function diskUsage() {
   try {
     if (typeof statfsSync !== "function") return void 0;
-    const st2 = statfsSync(join19(homedir14(), "GipityProjects"), { bigint: false });
+    const st2 = statfsSync(join20(homedir14(), "GipityProjects"), { bigint: false });
     if (!st2 || !st2.bsize) return void 0;
     return { total: st2.bsize * st2.blocks, free: st2.bsize * st2.bavail };
   } catch {
@@ -42600,7 +43157,7 @@ function diskUsage() {
 }
 function localProjectCount() {
   try {
-    return readdirSync7(join19(homedir14(), "GipityProjects"), { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).length;
+    return readdirSync8(join20(homedir14(), "GipityProjects"), { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).length;
   } catch {
     return void 0;
   }
@@ -42729,8 +43286,8 @@ var SessionPool = class {
     const done = new Promise((r) => {
       markDone = r;
     });
-    return new Promise((resolve18, reject) => {
-      const turn = { onMessage: p.onMessage, resolve: resolve18, reject, interruptRequested: false, wasHot, done, markDone };
+    return new Promise((resolve19, reject) => {
+      const turn = { onMessage: p.onMessage, resolve: resolve19, reject, interruptRequested: false, wasHot, done, markDone };
       session.current = turn;
       session.state = "running";
       session.lastActivityAt = Date.now();
@@ -42907,7 +43464,7 @@ var SessionPool = class {
 // src/relay/daemon.ts
 init_config();
 init_api();
-var RELAY_LOG_PATH = join21(homedir15(), ".gipity", "relay.log");
+var RELAY_LOG_PATH = join22(homedir15(), ".gipity", "relay.log");
 var HEARTBEAT_INTERVAL_MS = parseInt(process.env.GIPITY_RELAY_HEARTBEAT_MS || "60000", 10);
 var DIAGNOSTICS_INTERVAL_MS = parseInt(process.env.GIPITY_RELAY_DIAGNOSTICS_MS || String(24 * 60 * 60 * 1e3), 10);
 var LONG_POLL_TIMEOUT_MS = parseInt(process.env.GIPITY_RELAY_POLL_TIMEOUT_MS || "35000", 10);
@@ -43007,7 +43564,7 @@ function lockLogPerms(dir, file) {
     chmodSync3(dir, 448);
   } catch {
   }
-  if (!existsSync19(file)) {
+  if (!existsSync20(file)) {
     try {
       closeSync4(openSync4(file, "a", 384));
     } catch {
@@ -43024,7 +43581,7 @@ function log2(level, msg, extra) {
   const pretty = `${C7.dim(hhmmss())} ${badge(level)} ${C7.bold(msg)}${formatExtra(extra)}`;
   process.stderr.write(pretty + "\n");
   try {
-    const dir = join21(homedir15(), ".gipity");
+    const dir = join22(homedir15(), ".gipity");
     mkdirSync14(dir, { recursive: true });
     lockLogPerms(dir, RELAY_LOG_PATH);
     const json = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level, msg, ...extra ?? {} });
@@ -43149,10 +43706,10 @@ async function heartbeatLoop(ctx) {
     }
     await Promise.race([
       sleep4(HEARTBEAT_INTERVAL_MS, ctx.abort.signal),
-      new Promise((resolve18) => {
+      new Promise((resolve19) => {
         heartbeatPoke = () => {
           heartbeatPoke = null;
-          resolve18();
+          resolve19();
         };
       })
     ]);
@@ -43196,9 +43753,9 @@ async function dispatchLoop(ctx, opts) {
     while (inflight.size >= MAX_CONCURRENT_DISPATCHES && !ctx.abort.signal.aborted) {
       await Promise.race([
         ...inflight,
-        new Promise((resolve18) => {
-          if (ctx.abort.signal.aborted) return resolve18();
-          ctx.abort.signal.addEventListener("abort", () => resolve18(), { once: true });
+        new Promise((resolve19) => {
+          if (ctx.abort.signal.aborted) return resolve19();
+          ctx.abort.signal.addEventListener("abort", () => resolve19(), { once: true });
         })
       ]);
     }
@@ -43319,8 +43876,8 @@ async function postStreamDelta(convGuid, dispatchGuid, flush) {
 function toolHint(name, input) {
   if (!input || typeof input !== "object") return void 0;
   if (name === "Bash" && typeof input.command === "string") return input.command;
-  const path4 = input.file_path ?? input.path ?? input.pattern ?? input.query ?? input.url ?? input.description;
-  return typeof path4 === "string" ? path4 : void 0;
+  const path5 = input.file_path ?? input.path ?? input.pattern ?? input.query ?? input.url ?? input.description;
+  return typeof path5 === "string" ? path5 : void 0;
 }
 var PhaseTracker = class {
   phase = "starting";
@@ -43425,7 +43982,7 @@ function isSafeSessionId(s) {
 function transcriptPathFor(cwd, sessionId) {
   if (!isSafeSessionId(sessionId)) return null;
   const slug = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-  return join21(homedir15(), ".claude", "projects", slug, `${sessionId}.jsonl`);
+  return join22(homedir15(), ".claude", "projects", slug, `${sessionId}.jsonl`);
 }
 function formatDuration(ms2) {
   const totalSec = ms2 / 1e3;
@@ -43485,8 +44042,12 @@ async function handleDispatch(claimed) {
       d = { ...d, kind: "resume", remote_session_id: sid };
     }
   }
+  const rewriter = new ImageBlockRewriter(
+    d.conversation_guid,
+    (msg, meta) => log2("warn", msg, { id: d.short_guid, ...meta })
+  );
   const queue = new IngestQueue(
-    (entries) => postIngest(d.conversation_guid, entries),
+    async (entries) => postIngest(d.conversation_guid, await rewriter.rewrite(entries)),
     { onWarn: (msg, meta) => log2("warn", msg, { id: d.short_guid, ...meta }) }
   );
   const pushSystem = (content) => {
@@ -43499,24 +44060,33 @@ async function handleDispatch(claimed) {
   let bootstrapped;
   try {
     ({ cwd, bootstrapped } = await resolveCwdForProject(d));
+    rewriter.setCwd(cwd);
     log2("debug", "resolved project cwd", { id: d.short_guid, project: d.project_slug, cwd, bootstrapped });
   } catch (err) {
     log2("error", "could not resolve project cwd", { id: d.short_guid, err: err?.message });
     await ack(d.short_guid, "error", `Could not materialize project locally: ${err?.message || err}`);
     return;
   }
-  if (bootstrapped) {
-    pushSystem("Syncing project files\u2026");
+  const hasAttachments = (d.attachments?.length ?? 0) > 0;
+  if (bootstrapped || hasAttachments) {
+    pushSystem(bootstrapped ? "Syncing project files\u2026" : "Syncing attached files\u2026");
     let syncKilled = false;
+    let syncFailed = false;
     try {
       syncKilled = (await runDispatchSync(d, cwd)).killed;
     } catch (err) {
       const msg = `project sync ${err?.message || "failed"}`;
-      log2("error", "project sync failed - aborting dispatch", { id: d.short_guid, err: err?.message });
-      pushSystem(`Claude Code not started - ${msg}`);
-      await flushQueue();
-      await ack(d.short_guid, "error", msg);
-      return;
+      if (!bootstrapped) {
+        syncFailed = true;
+        log2("error", "attachment pre-sync failed - continuing", { id: d.short_guid, err: err?.message });
+        pushSystem(`Attached-file sync failed (${err?.message || "failed"}) - Claude will sync on demand.`);
+      } else {
+        log2("error", "project sync failed - aborting dispatch", { id: d.short_guid, err: err?.message });
+        pushSystem(`Claude Code not started - ${msg}`);
+        await flushQueue();
+        await ack(d.short_guid, "error", msg);
+        return;
+      }
     }
     if (syncKilled) {
       log2("info", "dispatch cancelled during project sync", { id: d.short_guid });
@@ -43525,7 +44095,7 @@ async function handleDispatch(claimed) {
       await ack(d.short_guid, "cancelled");
       return;
     }
-    pushSystem("Project files synced.");
+    if (!syncFailed) pushSystem(bootstrapped ? "Project files synced." : "Attached files synced.");
   }
   if (SESSION_POOL_ENABLED) {
     const handled = await tryHandleViaPool(d, cwd, queue, pushSystem, flushQueue);
@@ -43807,23 +44377,23 @@ async function resolveCwdForProject(d) {
     throw new Error(`Invalid project slug: ${JSON.stringify(d.project_slug)}`);
   }
   const root = getProjectsRoot();
-  const path4 = join21(root, d.project_slug);
-  const configPath = join21(path4, ".gipity.json");
-  if (existsSync19(configPath)) {
+  const path5 = join22(root, d.project_slug);
+  const configPath = join22(path5, ".gipity.json");
+  if (existsSync20(configPath)) {
     try {
       const cfg = JSON.parse(readFileSync21(configPath, "utf-8"));
-      if (cfg.projectGuid === d.project_guid) return { cwd: path4, bootstrapped: false };
+      if (cfg.projectGuid === d.project_guid) return { cwd: path5, bootstrapped: false };
       log2("warn", "project dir exists but guid mismatch - using it anyway", {
-        path: path4,
+        path: path5,
         expected: d.project_guid,
         found: cfg.projectGuid
       });
-      return { cwd: path4, bootstrapped: false };
+      return { cwd: path5, bootstrapped: false };
     } catch {
     }
   }
-  log2("info", "bootstrapping new project dir", { slug: d.project_slug, path: path4 });
-  mkdirSync14(path4, { recursive: true });
+  log2("info", "bootstrapping new project dir", { slug: d.project_slug, path: path5 });
+  mkdirSync14(path5, { recursive: true });
   const apiBase2 = getApiBaseOverride() || DEFAULT_API_BASE;
   writeFileSync13(configPath, JSON.stringify({
     projectGuid: d.project_guid,
@@ -43836,7 +44406,7 @@ async function resolveCwdForProject(d) {
   }, null, 2) + "\n");
   const origCwd = process.cwd();
   try {
-    process.chdir(path4);
+    process.chdir(path5);
     setupClaudeHooks();
     setupClaudeMd();
     setupAgentsMd();
@@ -43844,7 +44414,7 @@ async function resolveCwdForProject(d) {
   } finally {
     process.chdir(origCwd);
   }
-  return { cwd: path4, bootstrapped: true };
+  return { cwd: path5, bootstrapped: true };
 }
 var running = /* @__PURE__ */ new Map();
 var LAST_SESSION_TTL_MS = 10 * 6e4;
@@ -43905,7 +44475,7 @@ async function killRunningForConv(convGuid) {
     }
   }
   const graceTimers = [];
-  const escalate = new Promise((resolve18) => {
+  const escalate = new Promise((resolve19) => {
     const t = setTimeout(() => {
       for (const e of matches) {
         log2("warn", "previous dispatch ignored SIGTERM - escalating to SIGKILL", { conv: convGuid });
@@ -43914,7 +44484,7 @@ async function killRunningForConv(convGuid) {
         } catch {
         }
       }
-      resolve18();
+      resolve19();
     }, KILL_GRACE_MS);
     graceTimers.push(t);
   });
@@ -43925,7 +44495,7 @@ async function killRunningForConv(convGuid) {
 }
 async function spawnSync2(cwd, timeoutMs, onSpawn) {
   const cmd = process.env.GIPITY_RELAY_CLAUDE_CMD || resolveCommand("gipity");
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve19, reject) => {
     const child = spawnCommand(cmd, ["sync", "--json"], {
       cwd,
       env: childEnv(),
@@ -43949,7 +44519,7 @@ async function spawnSync2(cwd, timeoutMs, onSpawn) {
         } catch {
         }
         try {
-          unlinkSync6(join21(cwd, ".gipity", "sync.lock"));
+          unlinkSync6(join22(cwd, ".gipity", "sync.lock"));
         } catch {
         }
         finish(() => reject(new Error(`timed out after ${Math.round(timeoutMs / 1e3)}s`)));
@@ -43965,7 +44535,7 @@ async function spawnSync2(cwd, timeoutMs, onSpawn) {
     child.on("exit", (code) => finish(() => {
       if (code === 0) {
         log2("info", "sync done", { cwd, stdoutLen });
-        resolve18();
+        resolve19();
       } else {
         reject(new Error(`gipity sync exited ${code}${stderrBuf ? `: ${stderrBuf.trim().slice(0, 300)}` : ""}`));
       }
@@ -43976,7 +44546,7 @@ async function spawnGipityClaude(args, cwd, d, queue, meta) {
   const cmd = process.env.GIPITY_RELAY_CLAUDE_CMD || resolveCommand("gipity");
   const fullArgs = [...args, "--output-format", "stream-json", "--verbose", "--include-partial-messages"];
   const env = childEnv({ GIPITY_CONVERSATION_GUID: d.conversation_guid, GIPITY_CAPTURE: "off" });
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve19, reject) => {
     const child = spawnCommand(cmd, fullArgs, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
     let resolveExited = () => {
     };
@@ -43984,10 +44554,17 @@ async function spawnGipityClaude(args, cwd, d, queue, meta) {
       resolveExited = r;
     });
     running.set(d.short_guid, { child, convGuid: d.conversation_guid, exited });
-    const q = queue ?? new IngestQueue(
-      (entries) => postIngest(d.conversation_guid, entries),
-      { onWarn: (msg, meta2) => log2("warn", msg, { id: d.short_guid, ...meta2 }) }
-    );
+    const q = queue ?? (() => {
+      const rw = new ImageBlockRewriter(
+        d.conversation_guid,
+        (msg, meta2) => log2("warn", msg, { id: d.short_guid, ...meta2 })
+      );
+      rw.setCwd(cwd);
+      return new IngestQueue(
+        async (entries) => postIngest(d.conversation_guid, await rw.rewrite(entries)),
+        { onWarn: (msg, meta2) => log2("warn", msg, { id: d.short_guid, ...meta2 }) }
+      );
+    })();
     const ownQueue = !queue;
     const dispatchStartedAt = Date.now();
     let stdoutBytesTotal = 0;
@@ -44147,7 +44724,7 @@ async function spawnGipityClaude(args, cwd, d, queue, meta) {
       void postProgress(d.conversation_guid, buildProgressPayload(false));
       if (ownQueue) await q.close();
       cleanup();
-      resolve18({
+      resolve19({
         exitCode: code ?? 1,
         killed,
         runtimeLimit,
@@ -44161,10 +44738,10 @@ async function runDispatchSync(d, cwd) {
   let killed = false;
   try {
     await spawnSync2(cwd, PROJECT_SYNC_TIMEOUT_MS, (child) => {
-      const exited = new Promise((resolve18) => {
+      const exited = new Promise((resolve19) => {
         child.once("exit", (_code, signal) => {
           if (signal === "SIGTERM") killed = true;
-          resolve18();
+          resolve19();
         });
       });
       running.set(d.short_guid, { child, convGuid: d.conversation_guid, exited });
@@ -44195,18 +44772,18 @@ function killDispatch(shortGuid) {
   return false;
 }
 function sleep4(ms2, signal) {
-  return new Promise((resolve18) => {
-    if (signal?.aborted) return resolve18();
+  return new Promise((resolve19) => {
+    if (signal?.aborted) return resolve19();
     let onAbort = null;
     const t = setTimeout(() => {
       if (onAbort && signal) signal.removeEventListener("abort", onAbort);
-      resolve18();
+      resolve19();
     }, ms2);
     if (signal) {
       onAbort = () => {
         clearTimeout(t);
         signal.removeEventListener("abort", onAbort);
-        resolve18();
+        resolve19();
       };
       signal.addEventListener("abort", onAbort, { once: true });
     }
@@ -44376,7 +44953,7 @@ relayCommand.command("run").description("Run the background service").option("-v
 });
 relayCommand.command("stop").description("Stop the background service").option("--force", "Force-stop if it doesn't exit cleanly within 5s").action(async (opts) => {
   const pidPath = getDaemonPidPath();
-  if (!existsSync20(pidPath)) {
+  if (!existsSync21(pidPath)) {
     console.log(muted("Background service isn't running."));
     return;
   }
@@ -44504,7 +45081,7 @@ relayCommand.command("revoke").description("Revoke and forget this device").acti
   } catch {
   }
   const pidPath = getDaemonPidPath();
-  if (existsSync20(pidPath)) {
+  if (existsSync21(pidPath)) {
     const pid = parseInt(readFileSync22(pidPath, "utf-8").trim(), 10);
     if (pid && !isNaN(pid)) {
       try {
@@ -44517,14 +45094,14 @@ relayCommand.command("revoke").description("Revoke and forget this device").acti
   console.log(muted(autostartRemoved ? "Auto-start removed and the background service was signalled to stop." : "The background service was signalled to stop."));
 });
 relayCommand.command("log").description("Tail the service log").option("-n, --lines <n>", "How many lines to print (default 100)", "100").option("-f, --follow", "Follow the log like `tail -f`").action((opts) => {
-  const path4 = RELAY_LOG_PATH;
-  if (!existsSync20(path4)) {
+  const path5 = RELAY_LOG_PATH;
+  if (!existsSync21(path5)) {
     console.log(muted("No log file yet. Start the service with `gipity relay run` (or install it)."));
     return;
   }
   const lines = parseInt(opts.lines, 10) || 100;
   try {
-    const all = readFileSync22(path4, "utf-8").split("\n");
+    const all = readFileSync22(path5, "utf-8").split("\n");
     const tail = all.slice(-lines - 1).join("\n");
     process.stdout.write(tail);
   } catch (err) {
@@ -44537,7 +45114,7 @@ relayCommand.command("log").description("Tail the service log").option("-n, --li
       console.error(error("--follow is not supported on this platform yet."));
       process.exit(1);
     }
-    const child = spawn2(tailCmd, ["-f", "-n", "0", path4], { stdio: "inherit" });
+    const child = spawn2(tailCmd, ["-f", "-n", "0", path5], { stdio: "inherit" });
     child.on("error", (err) => {
       console.error(error(err.code === "ENOENT" ? "`tail` not found - can't follow the log on this system." : `Failed to follow log: ${err.message}`));
       process.exit(1);
@@ -44597,12 +45174,12 @@ init_api();
 init_auth();
 init_utils();
 init_colors();
-import { existsSync as existsSync21, rmSync as rmSync2, unlinkSync as unlinkSync8, readFileSync as readFileSync23, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync22, rmSync as rmSync2, unlinkSync as unlinkSync8, readFileSync as readFileSync23, writeFileSync as writeFileSync14 } from "fs";
 import { homedir as homedir16, platform as osPlatform4 } from "os";
-import { join as join22, resolve as resolve16 } from "path";
+import { join as join23, resolve as resolve17 } from "path";
 function removeGipityPluginConfig() {
-  const settingsPath = join22(homedir16(), ".claude", "settings.json");
-  if (!existsSync21(settingsPath)) return false;
+  const settingsPath = join23(homedir16(), ".claude", "settings.json");
+  if (!existsSync22(settingsPath)) return false;
   let settings;
   try {
     settings = JSON.parse(readFileSync23(settingsPath, "utf-8"));
@@ -44628,8 +45205,8 @@ function removeInstallerPathLines() {
   const marker = "# Added by the Gipity installer";
   const touched = [];
   for (const name of [".bashrc", ".zshrc", ".profile"]) {
-    const rc2 = join22(homedir16(), name);
-    if (!existsSync21(rc2)) continue;
+    const rc2 = join23(homedir16(), name);
+    if (!existsSync22(rc2)) continue;
     let text;
     try {
       text = readFileSync23(rc2, "utf-8");
@@ -44654,7 +45231,7 @@ function tildify2(p) {
   return p === home || p.startsWith(home + "/") ? "~" + p.slice(home.length) : p;
 }
 function resolveCliPath2() {
-  return resolve16(process.argv[1] ?? "gipity");
+  return resolve17(process.argv[1] ?? "gipity");
 }
 async function stopDaemon() {
   if (!isDaemonRunning()) return;
@@ -44688,7 +45265,7 @@ function removeServiceUnit() {
       const r = spawnSyncCommand(argv2[0], argv2.slice(1), { stdio: "ignore" });
       if (r.status !== 0) allOk = false;
     }
-    if (existsSync21(plan2.path)) {
+    if (existsSync22(plan2.path)) {
       try {
         unlinkSync8(plan2.path);
       } catch {
@@ -44711,9 +45288,9 @@ async function revokeDeviceBestEffort() {
 }
 var uninstallCommand = new Command("uninstall").description("Uninstall Gipity").option("--yes", "Skip confirmation prompts").action(async (opts) => {
   const autoYes = opts.yes || getAutoConfirm();
-  const gipityDir = join22(homedir16(), ".gipity");
-  const launcherBin = join22(gipityDir, "launcher", "bin", "gipity");
-  const installedViaLauncher = existsSync21(launcherBin);
+  const gipityDir = join23(homedir16(), ".gipity");
+  const launcherBin = join23(gipityDir, "launcher", "bin", "gipity");
+  const installedViaLauncher = existsSync22(launcherBin);
   console.log(`${bold("Gipity uninstall")} - this will:`);
   console.log(`\u2022 Stop the running relay daemon (if any)`);
   console.log(`\u2022 Remove the OS autostart service (launchd / systemd / Task Scheduler)`);
@@ -44748,7 +45325,7 @@ var uninstallCommand = new Command("uninstall").description("Uninstall Gipity").
   } else {
     console.log(`${muted("No Gipity entries in Claude Code settings.")}`);
   }
-  if (existsSync21(gipityDir)) {
+  if (existsSync22(gipityDir)) {
     try {
       rmSync2(gipityDir, { recursive: true, force: true });
       console.log(`${success(`Removed ${gipityDir}/`)}`);
@@ -45275,7 +45852,7 @@ function collectRealFlags(argv2, program3) {
 
 // src/trace.ts
 import { openSync as openSync5, writeSync, mkdirSync as mkdirSync15 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 import { homedir as homedir17 } from "os";
 var TRACE_KEY = /* @__PURE__ */ Symbol.for("gipity.traceOutput");
 function installOutputTrace(label2) {
@@ -45287,10 +45864,10 @@ function installOutputTrace(label2) {
       existing.emit({ event: "reenter", label: label2 });
       return;
     }
-    const dir = join23(process.env.GIPITY_DIR || join23(homedir17(), ".gipity"), "trace");
+    const dir = join24(process.env.GIPITY_DIR || join24(homedir17(), ".gipity"), "trace");
     mkdirSync15(dir, { recursive: true });
     const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", "_").replace(/:/g, "-");
-    const fd2 = openSync5(join23(dir, `${stamp}-pid${process.pid}.jsonl`), "a");
+    const fd2 = openSync5(join24(dir, `${stamp}-pid${process.pid}.jsonl`), "a");
     const emit = (rec) => {
       try {
         writeSync(fd2, JSON.stringify({ t: (/* @__PURE__ */ new Date()).toISOString(), ...rec }) + "\n");
@@ -45326,11 +45903,11 @@ function installOutputTrace(label2) {
 // src/index.ts
 installOutputTrace("index");
 var __dirname = dirname13(fileURLToPath3(import.meta.url));
-var pkg = JSON.parse(readFileSync25(resolve17(__dirname, "../package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync25(resolve18(__dirname, "../package.json"), "utf-8"));
 function versionLabel() {
   const base = `v${pkg.version}`;
   try {
-    const info2 = JSON.parse(readFileSync25(resolve17(__dirname, "build-info.json"), "utf-8"));
+    const info2 = JSON.parse(readFileSync25(resolve18(__dirname, "build-info.json"), "utf-8"));
     if (info2?.sha) return `${base} (dev ${info2.sha}${info2.dirty ? ", modified" : ""})`;
   } catch {
   }