gipity 1.1.5 → 1.1.7

package/dist/index.js

@@ -4002,9 +4002,10 @@ async function confirm(question, opts = {}) {
   const defaultYes = opts.default === "yes";
   if (opts.skip ?? _autoConfirm) return true;
   if (!process.stdin.isTTY) {
+    if (opts.headless === "no") return false;
     console.error(`Confirmation required (non-interactive). Re-run with --yes:
   ${rerunWithYes()}`);
-    return false;
+    process.exit(1);
   }
   const hint = defaultYes ? dim("[Y/n]") : dim("[y/N]");
   process.stdout.write(`${question} ${hint}: `);
@@ -6597,6 +6598,9 @@ function detectHarness() {
   }
   if (hasEnvPrefix("CODEX_")) return { harness: "codex" };
   if (hasEnvPrefix("GROK_")) return { harness: "grok", harnessSession: process.env.GROK_SESSION_ID };
+  if (process.env.ANTIGRAVITY_CONVERSATION_ID) {
+    return { harness: "agy", harnessSession: process.env.ANTIGRAVITY_CONVERSATION_ID };
+  }
   if (process.env.CURSOR_TRACE_ID || hasEnvPrefix("CURSOR_") || (process.env.TERM_PROGRAM ?? "").toLowerCase().includes("cursor")) {
     return { harness: "cursor" };
   }
@@ -6643,11 +6647,13 @@ __export(api_exports, {
   getAccountSlug: () => getAccountSlug,
   getAuthHeader: () => getAuthHeader,
   getBaseUrl: () => getBaseUrl,
+  mintAppToken: () => mintAppToken,
   patch: () => patch,
   post: () => post,
   postBinary: () => postBinary,
   postForTarEntries: () => postForTarEntries,
   publicPost: () => publicPost,
+  publicRequest: () => publicRequest,
   put: () => put,
   putTimeoutMs: () => putTimeoutMs,
   putToPresignedUrl: () => putToPresignedUrl,
@@ -6903,12 +6909,12 @@ async function getAccountSlug() {
   accountSlugCache = res.data.accountSlug;
   return accountSlugCache;
 }
-async function publicPost(path5, body, extraHeaders) {
+async function publicRequest(method, path5, body, extraHeaders) {
   const url = `${baseUrl()}${path5}`;
   const res = await fetch(url, {
-    method: "POST",
+    method,
     headers: { ...clientHeaders(), "Content-Type": "application/json", ...extraHeaders },
-    body: JSON.stringify(body)
+    body: body === void 0 ? void 0 : JSON.stringify(body)
   });
   if (!res.ok) {
     const json = await res.json().catch(() => ({ error: { code: "UNKNOWN", message: res.statusText } }));
@@ -6917,6 +6923,17 @@ async function publicPost(path5, body, extraHeaders) {
   }
   return res.json();
 }
+function publicPost(path5, body, extraHeaders) {
+  return publicRequest("POST", path5, body, extraHeaders);
+}
+async function mintAppToken(projectGuid2) {
+  try {
+    const minted = await publicPost("/api/token", { app: projectGuid2 });
+    return { "X-App-Token": minted.data.token };
+  } catch {
+    return void 0;
+  }
+}
 var tar, ApiError, REQUEST_TIMEOUT_MS, DOWNLOAD_HEADER_TIMEOUT_MS, PUT_TIMEOUT_FLOOR_MS, PUT_MIN_BYTES_PER_SEC, accountSlugCache;
 var init_api = __esm({
   "src/api.ts"() {
@@ -32075,7 +32092,7 @@ mkdir -p ~/GipityProjects/<slug> && cd ~/GipityProjects/<slug> && gipity init <s
 
 ## CLI quick reference
 
-Key commands: \`gipity add <template|kit>\`, \`gipity deploy dev\`, \`gipity sandbox run\`, \`gipity page inspect <url>\`, \`gipity page screenshot <url>\`, \`gipity db query "SQL"\`, \`gipity fn call <name>\`, \`gipity logs fn <name>\`, \`gipity secrets set <NAME> <value> [--account]\` (store an API key/token encrypted; read in functions via \`secrets.get('NAME')\` \u2014 never hardcode keys), \`gipity email send --to <addr> --subject <s> --body <b>\` (sends as \`gipity@gipity.ai\`; omit \`--to\` to self-send), \`gipity skill read <name>\`.
+Key commands: \`gipity add <template|kit>\`, \`gipity brand set --emoji <e>|--color <hex>\` (regenerate the app's icons + social share card), \`gipity deploy dev\`, \`gipity sandbox run\`, \`gipity page inspect <url>\`, \`gipity page screenshot <url>\`, \`gipity db query "SQL"\`, \`gipity fn call <name>\`, \`gipity logs fn <name>\`, \`gipity secrets set <NAME> <value> [--account]\` (store an API key/token encrypted; read in functions via \`secrets.get('NAME')\` \u2014 never hardcode keys), \`gipity email send --to <addr> --subject <s> --body <b>\` (sends as \`gipity@gipity.ai\`; omit \`--to\` to self-send), \`gipity skill read <name>\`.
 Rename for findability: \`gipity project rename <name>\` renames the current project's display name (the slug and deployed URLs never change); \`gipity chat rename <title>\` renames the current chat's tab title. Both are the display label users scan to switch between tabs \u2014 retitle a chat when the conversation clearly shifts to a new topic (sparingly, not every turn), and keep every project/chat title SHORT: 2-4 words, \u226440 characters, no trailing punctuation (e.g. "Stripe checkout", "Tetris game").
 Pull an existing remote project local (given its URL/slug): \`mkdir -p ~/GipityProjects/<slug> && cd ~/GipityProjects/<slug> && gipity init <slug>\` (adopts the matching project and syncs files down - this is the "clone").
 Move whole apps in/out: \`gipity save\` (export this project as a portable \`.gip\` bundle), \`gipity load <file.gip | github:owner/repo>\` (import as a NEW project; \`--inspect\` to preview), \`gipity github connect\` (1-2 click GitHub access for imports). Porting a Vercel/Replit/Lovable app? Load the \`app-import\` skill first.
@@ -32085,7 +32102,7 @@ Run \`gipity --help\` for the full list. Use \`--help\` on any command for detai
 
 Function return shape: \`gipity fn call\`, the in-test \`ctx.fn.call\`/\`callAs\`, and the client \`Gipity.fn\` all return your function's value **unwrapped** - read/assert \`result.field\`. Only raw HTTP/\`curl\` wraps it as \`{ data: ... }\`; never write \`result.data.field\` in a test.
 
-Tests are isolated, not run against your live DB: \`gipity test\` points \`ctx.fn.call\`/\`callAs\` at a throwaway copy of your database (your \`migrations/\` + \`seeds/\`), reset (truncate + reseed) before every run - so test rows never reach the deployed app and you don't write teardown. Functions see \`ctx.isTest === true\` during a run (use it to skip your own rate limiting); the platform also suppresses \`notify()\` push so a suite can't spam subscribers. Reference data tests need goes in seed files; a runtime-written settings table that isn't seeded goes under \`test.preserve\` in \`gipity.yaml\`. Build per-file fixtures in \`setup(fn)\` \u2192 \`ctx.fixtures\`, and namespace unique values with \`ctx.testId\`.
+Tests are isolated, not run against your live DB: \`gipity test\` points \`ctx.fn.call\`/\`callAs\` at a throwaway copy of your database (your \`migrations/\` + \`seeds/\`), one per test FILE, reset (truncate + reseed) before the file runs - so files can't interfere, test rows never reach the deployed app, and you don't write teardown. Functions see \`ctx.isTest === true\` during a run (use it to skip your own rate limiting); the platform also suppresses \`notify()\` push so a suite can't spam subscribers. Reference data tests need goes in seed files; a runtime-written settings table that isn't seeded goes under \`test.preserve\` in \`gipity.yaml\`. Build per-file fixtures in \`setup(fn)\` \u2192 \`ctx.fixtures\`.
 
 ## Hit friction on the platform? Report it in real time
 
@@ -32156,7 +32173,7 @@ App development skills:
 - \`app-development\` - functions, database, and API
 - \`app-import\` - import apps from GitHub/.gip bundles (incl. Vercel/Replit/Lovable porting) and export any project as a portable .gip - app_import tool, gipity save/load
 - \`app-records\` - Gipity Records: declared tables \u2192 validated CRUD, provenance, workflows, auto UI
-- \`app-testing\` - testing deployed app functions (ctx.fn.call/callAs, the isolated test DB)
+- \`app-testing\` - testing deployed app functions (ctx.fn.call/callAs, the per-file test DB)
 - \`deploy\` - the deploy pipeline & gipity.yaml manifest
 - \`jobs\` - long-running CPU + GPU compute jobs (Python / Node / bash)
 - \`realtime-scheduled-app\` - recipe: realtime presence/messages + DB function + scheduled poster, end-to-end
@@ -32513,7 +32530,7 @@ var UploadConflictError = class extends Error {
   currentServerVersion;
   path;
 };
-async function uploadOneFile(projectGuid, localPath, virtualPath, opts = {}) {
+async function uploadOneFile(projectGuid2, localPath, virtualPath, opts = {}) {
   const { sha256, size } = await hashFile(localPath);
   const mime = opts.mime ?? guessMime(virtualPath);
   const initBody = { path: virtualPath, size, sha256, mime };
@@ -32523,7 +32540,7 @@ async function uploadOneFile(projectGuid, localPath, virtualPath, opts = {}) {
   let init;
   try {
     init = await post(
-      `/projects/${projectGuid}/files/upload-init`,
+      `/projects/${projectGuid2}/files/upload-init`,
       initBody
     );
   } catch (err) {
@@ -32545,7 +32562,7 @@ async function uploadOneFile(projectGuid, localPath, virtualPath, opts = {}) {
   }
   let comp;
   try {
-    comp = await post(`/projects/${projectGuid}/files/upload-complete`, completeBody);
+    comp = await post(`/projects/${projectGuid2}/files/upload-complete`, completeBody);
   } catch (err) {
     if (err instanceof ApiError && err.statusCode === 409) {
       const current = typeof err.data?.current_server_version === "number" ? err.data.current_server_version : null;
@@ -32627,16 +32644,16 @@ async function transferToS3(localPath, size, mime, data, opts = {}) {
   completed.sort((a, b7) => a.part_number - b7.part_number);
   return { parts: completed };
 }
-async function uploadInitBatch(projectGuid, files) {
+async function uploadInitBatch(projectGuid2, files) {
   const res = await post(
-    `/projects/${projectGuid}/files/upload-init-batch`,
+    `/projects/${projectGuid2}/files/upload-init-batch`,
     { files }
   );
   return res.data.results;
 }
-async function uploadCompleteBatch(projectGuid, items) {
+async function uploadCompleteBatch(projectGuid2, items) {
   const res = await post(
-    `/projects/${projectGuid}/files/upload-complete-batch`,
+    `/projects/${projectGuid2}/files/upload-complete-batch`,
     { items }
   );
   return res.data.results;
@@ -32653,6 +32670,8 @@ var PRIMER_FILES = {
   codex: "AGENTS.md",
   grok: "AGENTS.md",
   // Grok Build reads the AGENTS.md family (and CLAUDE.md) natively
+  agy: "AGENTS.md",
+  // Antigravity reads the same AGENTS.md/GEMINI.md rules family natively
   aider: "AGENTS.md",
   // shares the Codex primer; aider is pointed at it via .aider.conf.yml
   gemini: "GEMINI.md",
@@ -32668,6 +32687,7 @@ var DEFAULT_SYNC_IGNORE = [
   ".gipity/",
   ".claude/",
   ".codex/",
+  ".agents/",
   ".gitignore",
   AIDER_CONF_FILE,
   // Home-directory junk: a project created inside a real home dir (or one that
@@ -32867,9 +32887,11 @@ function ensureGrokPluginInstalled() {
 var AGENTS_SKILLS_DIR = join4(homedir3(), ".agents", "skills");
 var AGENT_HOOKS_DIR = join4(homedir3(), ".gipity", "agent-hooks");
 var AGENT_SKILLS_MANIFEST = join4(homedir3(), ".gipity", "agent-skills.json");
-function agentSkillsState() {
+var AGY_SKILLS_DIR = join4(homedir3(), ".gemini", "config", "skills");
+var AGY_SKILLS_MANIFEST = join4(homedir3(), ".gipity", "agy-skills.json");
+function skillsManifestState(manifestPath) {
   try {
-    const m = JSON.parse(readFileSync6(AGENT_SKILLS_MANIFEST, "utf-8"));
+    const m = JSON.parse(readFileSync6(manifestPath, "utf-8"));
     return {
       current: typeof m?.version === "string" && versionGte(m.version, GIPITY_PLUGIN_VERSION),
       skills: Array.isArray(m?.skills) ? m.skills : []
@@ -32878,8 +32900,13 @@ function agentSkillsState() {
     return { current: false, skills: [] };
   }
 }
-function ensureAgentSkillsInstalled() {
-  if (agentSkillsState().current) return;
+function agentSkillsState() {
+  return skillsManifestState(AGENT_SKILLS_MANIFEST);
+}
+function agySkillsState() {
+  return skillsManifestState(AGY_SKILLS_MANIFEST);
+}
+function installSkillsAndHooks(skillsDir, manifestPath, harnessLabel) {
   if (!binaryOnPath("git")) return;
   const tmp = mkdtempSync(join4(tmpdir(), "gipity-skills-"));
   try {
@@ -32901,8 +32928,8 @@ function ensureAgentSkillsInstalled() {
     for (const entry of readdirSync3(skillsSrc, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       if (!existsSync4(join4(skillsSrc, entry.name, "SKILL.md"))) continue;
-      mkdirSync3(AGENTS_SKILLS_DIR, { recursive: true });
-      cpSync(join4(skillsSrc, entry.name), join4(AGENTS_SKILLS_DIR, entry.name), {
+      mkdirSync3(skillsDir, { recursive: true });
+      cpSync(join4(skillsSrc, entry.name), join4(skillsDir, entry.name), {
         recursive: true,
         force: true
       });
@@ -32912,13 +32939,21 @@ function ensureAgentSkillsInstalled() {
     for (const script of readdirSync3(join4(repo, "hooks", "scripts"))) {
       cpSync(join4(repo, "hooks", "scripts", script), join4(AGENT_HOOKS_DIR, script), { force: true });
     }
-    writeFileSync4(AGENT_SKILLS_MANIFEST, JSON.stringify({ version, skills: names }, null, 2) + "\n");
-    console.log(`Installed ${names.length} Gipity skills for Codex (~/.agents/skills).`);
+    writeFileSync4(manifestPath, JSON.stringify({ version, skills: names }, null, 2) + "\n");
+    console.log(`Installed ${names.length} Gipity skills for ${harnessLabel} (${skillsDir}).`);
   } catch {
   } finally {
     rmSync(tmp, { recursive: true, force: true });
   }
 }
+function ensureAgentSkillsInstalled() {
+  if (agentSkillsState().current) return;
+  installSkillsAndHooks(AGENTS_SKILLS_DIR, AGENT_SKILLS_MANIFEST, "Codex");
+}
+function ensureAgySkillsInstalled() {
+  if (agySkillsState().current) return;
+  installSkillsAndHooks(AGY_SKILLS_DIR, AGY_SKILLS_MANIFEST, "Antigravity");
+}
 function applyCodexHooks(existing) {
   const launcher = join4(AGENT_HOOKS_DIR, "launch.sh");
   const cmd = (script, ...args) => [`sh "${launcher}" "${join4(AGENT_HOOKS_DIR, script)}"`, ...args].join(" ");
@@ -32976,6 +33011,102 @@ function setupCodexIntegration() {
   ensureAgentSkillsInstalled();
   setupCodexHooks();
 }
+var AGY_HOOKS_SCRIPT = `#!/usr/bin/env node
+'use strict';
+const { spawnSync } = require('child_process');
+const { join } = require('path');
+
+const WRITE_TOOLS = new Set(['write_to_file', 'replace_file_content']);
+
+function readStdin() {
+  return new Promise((res) => {
+    let data = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (c) => { data += c; });
+    process.stdin.on('end', () => res(data));
+    process.stdin.on('error', () => res(data));
+  });
+}
+
+async function main() {
+  const event = process.argv[2];
+  const raw = await readStdin();
+  let payload = {};
+  try { payload = JSON.parse(raw); } catch { /* keep {} */ }
+
+  try {
+    if (event === 'post-tool-use') {
+      const toolCall = payload.toolCall;
+      const filePath = toolCall && toolCall.args && toolCall.args.TargetFile;
+      if (toolCall && WRITE_TOOLS.has(toolCall.name) && typeof filePath === 'string' && filePath) {
+        spawnSync(process.execPath, [join(__dirname, 'sync-push.cjs')], {
+          input: JSON.stringify({ tool_input: { file_path: filePath } }),
+          stdio: ['pipe', 'ignore', 'ignore'],
+          windowsHide: true,
+        });
+      }
+      spawnSync(process.execPath, [join(__dirname, 'capture.cjs'), 'agy', 'post-tool-use'], {
+        input: raw,
+        stdio: ['pipe', 'ignore', 'ignore'],
+        windowsHide: true,
+      });
+    } else if (event === 'stop') {
+      spawnSync(process.execPath, [join(__dirname, 'capture.cjs'), 'agy', 'stop'], {
+        input: raw,
+        stdio: ['pipe', 'ignore', 'ignore'],
+        windowsHide: true,
+      });
+    }
+  } catch { /* never let a side effect break the response below */ }
+
+  process.stdout.write('{}');
+}
+
+main();
+`;
+function applyAgyHooks(existing) {
+  const wrapper = join4(AGENT_HOOKS_DIR, "agy-hooks.cjs");
+  const launcher = join4(AGENT_HOOKS_DIR, "launch.sh");
+  const wrapCmd = (event) => `sh "${launcher}" "${wrapper}" ${event}`;
+  const block = {
+    PostToolUse: [
+      { matcher: ".*", hooks: [{ type: "command", command: wrapCmd("post-tool-use"), timeout: 30 }] }
+    ],
+    Stop: [
+      { hooks: [{ type: "command", command: wrapCmd("stop"), timeout: 60 }] }
+    ]
+  };
+  let settings = {};
+  if (existing !== null) {
+    try {
+      settings = JSON.parse(existing);
+    } catch {
+      return null;
+    }
+  }
+  if (JSON.stringify(settings.gipity ?? null) === JSON.stringify(block)) return null;
+  settings.gipity = block;
+  return JSON.stringify(settings, null, 2) + "\n";
+}
+function setupAgyHooks() {
+  if (process.platform === "win32") return;
+  const cwd = resolve3(process.cwd());
+  if (cwd === resolve3(homedir3())) return;
+  mkdirSync3(AGENT_HOOKS_DIR, { recursive: true });
+  writeFileSync4(join4(AGENT_HOOKS_DIR, "agy-hooks.cjs"), AGY_HOOKS_SCRIPT);
+  const path5 = join4(cwd, ".agents", "hooks.json");
+  const existing = existsSync4(path5) ? readFileSync6(path5, "utf-8") : null;
+  const next = applyAgyHooks(existing);
+  if (next === null) return;
+  mkdirSync3(dirname3(path5), { recursive: true });
+  writeFileSync4(path5, next);
+  console.log(existing === null ? "Wrote Antigravity sync + session-capture hooks (.agents/hooks.json)." : "Updated Antigravity hooks (.agents/hooks.json).");
+}
+function setupAgyIntegration() {
+  if (!binaryOnPath("agy")) return;
+  ensureAgySkillsInstalled();
+  setupAgyHooks();
+}
 function setupClaudeHooks() {
   ensureGipityPlugin();
   const cwd = resolve3(process.cwd());
@@ -33097,6 +33228,7 @@ var SUPPORTED_TOOLS = [
   { key: "claude", label: "Claude Code (CLAUDE.md + Gipity plugin)", setup: setupClaudeMd, integrate: setupClaudeHooks },
   { key: "codex", label: "OpenAI Codex (AGENTS.md + skills + sync hooks)", setup: setupAgentsMd, integrate: setupCodexIntegration },
   { key: "grok", label: "Grok Build (AGENTS.md + Gipity plugin)", setup: setupAgentsMd, integrate: ensureGrokPluginInstalled },
+  { key: "agy", label: "Antigravity (AGENTS.md + skills + sync hooks)", setup: setupAgentsMd, integrate: setupAgyIntegration },
   { key: "aider", label: "Aider (AGENTS.md + .aider.conf.yml)", setup: setupAiderMd, optIn: true },
   { key: "gemini", label: "Gemini CLI (GEMINI.md)", setup: setupGeminiMd },
   { key: "copilot", label: "GitHub Copilot (.github/copilot-instructions.md)", setup: setupCopilotMd },
@@ -33226,22 +33358,22 @@ async function acquireLock(progress) {
     }
   }
 }
-function readBaseline(projectGuid) {
+function readBaseline(projectGuid2) {
   const path5 = syncStatePath();
-  if (!existsSync5(path5)) return { projectGuid, files: {}, lastFullSync: null };
+  if (!existsSync5(path5)) return { projectGuid: projectGuid2, files: {}, lastFullSync: null };
   try {
     const parsed = JSON.parse(readFileSync7(path5, "utf-8"));
-    if (parsed.projectGuid !== projectGuid) {
-      return { projectGuid, files: {}, lastFullSync: null };
+    if (parsed.projectGuid !== projectGuid2) {
+      return { projectGuid: projectGuid2, files: {}, lastFullSync: null };
     }
     return {
-      projectGuid,
+      projectGuid: projectGuid2,
       files: parsed.files ?? {},
       lastFullSync: parsed.lastFullSync ?? null,
       ...parsed.deletesSkippedStreak ? { deletesSkippedStreak: parsed.deletesSkippedStreak } : {}
     };
   } catch {
-    return { projectGuid, files: {}, lastFullSync: null };
+    return { projectGuid: projectGuid2, files: {}, lastFullSync: null };
   }
 }
 function writeBaseline(b7) {
@@ -33314,8 +33446,8 @@ function resolveInRoot(root, relPath) {
   }
   return full;
 }
-async function fetchRemote(projectGuid) {
-  const res = await get(`/projects/${projectGuid}/files/tree`);
+async function fetchRemote(projectGuid2) {
+  const res = await get(`/projects/${projectGuid2}/files/tree`);
   const out = /* @__PURE__ */ new Map();
   for (const f of res.data) {
     if (f.type !== "file") continue;
@@ -33376,14 +33508,14 @@ function extractTarToMap(stream, idleMs, onBytes, keep) {
     stream.pipe(extract3);
   });
 }
-async function downloadAll(projectGuid, onBytes) {
-  const stream = await downloadStream(`/projects/${projectGuid}/files/tree?content=tar`);
+async function downloadAll(projectGuid2, onBytes) {
+  const stream = await downloadStream(`/projects/${projectGuid2}/files/tree?content=tar`);
   return extractTarToMap(stream, DOWNLOAD_IDLE_MS, onBytes);
 }
-async function fetchOneOutcome(projectGuid, path5, expectedSha) {
+async function fetchOneOutcome(projectGuid2, path5, expectedSha) {
   try {
     const stream = await downloadStream(
-      `/projects/${projectGuid}/files/tree?content=tar&path=${encodeURIComponent(path5)}`
+      `/projects/${projectGuid2}/files/tree?content=tar&path=${encodeURIComponent(path5)}`
     );
     const want = normalizeTreePath(path5);
     const files = await extractTarToMap(stream, DOWNLOAD_IDLE_MS, void 0, (p) => p === want);
@@ -33399,8 +33531,8 @@ async function fetchOneOutcome(projectGuid, path5, expectedSha) {
     return { kind: "transient" };
   }
 }
-async function fetchOne(projectGuid, path5, expectedSha) {
-  const out = await fetchOneOutcome(projectGuid, path5, expectedSha);
+async function fetchOne(projectGuid2, path5, expectedSha) {
+  const out = await fetchOneOutcome(projectGuid2, path5, expectedSha);
   return out.kind === "ok" ? out.buf : null;
 }
 function classifyLocal(info2, base) {
@@ -33632,14 +33764,14 @@ async function sync(opts = {}) {
     releaseLock();
   }
 }
-async function syncInner(projectGuid, root, ignore2, opts, interactive) {
-  const config = { projectGuid, ignore: ignore2 };
+async function syncInner(projectGuid2, root, ignore2, opts, interactive) {
+  const config = { projectGuid: projectGuid2, ignore: ignore2 };
   const p = opts.progress;
-  const baseline = readBaseline(projectGuid);
+  const baseline = readBaseline(projectGuid2);
   p?.phase("Scanning local files...");
   const local = walkLocal(root, ignore2, baseline.files);
   p?.phase("Checking Gipity for changes...");
-  const remote = await fetchRemote(projectGuid);
+  const remote = await fetchRemote(projectGuid2);
   for (const path5 of [...remote.keys()]) {
     if (shouldIgnore(path5, ignore2)) remote.delete(path5);
   }
@@ -34439,7 +34571,12 @@ function parseDuration(raw, unit) {
 }
 
 // src/commands/token.ts
-var tokenCommand = new Command("token").description("Manage API tokens").addHelpText("after", "\nLong-lived agent API tokens (gip_at_*) for headless agents and CI.");
+var tokenCommand = new Command("token").description("Manage API tokens").addHelpText("after", `
+Long-lived agent API tokens (gip_at_*) for headless agents and CI - they drive
+the gipity CLI as YOU.
+
+To let a script or cron write to one app instead, mint a project API key:
+gipity key create "my script" --role editor (sent as X-Api-Key).`);
 var fmtDate = (d) => d ? new Date(d).toLocaleDateString() : "never";
 tokenCommand.command("create").description("Mint a long-lived agent API token (shown once)").option("--name <name>", 'Label for the token, e.g. "Hermes on my VPS"').option("--expires <days>", "Days until the token expires (default: never)").option("--json", "Output as JSON").action((opts) => run("Create", async () => {
   const body = {};
@@ -34484,6 +34621,73 @@ tokenCommand.command("revoke <short_guid>").alias("rm").description("Revoke an a
   console.log(success(`Revoked token ${bold(shortGuid)}.`));
 }));
 
+// src/commands/key.ts
+init_api();
+init_config();
+init_colors();
+var keyCommand = new Command("key").description("Manage project API keys for scripts and agents (X-Api-Key)").addHelpText("after", `
+Give a script, cron, or agent write access to your app without a login:
+
+  gipity key create "laptop importer" --role editor
+  # the script sends:  X-Api-Key: <the key printed once above>
+
+Inside a function the caller shows up as ctx.auth.via === 'api_key' with
+ctx.auth.apiKeyName set to the key's name - stamp that on rows to tell
+script-written entries from hand-entered ones. Never build your own key table.
+
+Account-level tokens that run the CLI headlessly are a different thing: see
+gipity token --help.`);
+var fmtDate2 = (d) => d ? new Date(d).toLocaleDateString() : "never";
+var projectOpt = ["--project <guid-or-slug>", "Target a specific project instead of cwd / Home"];
+async function projectGuid(opts) {
+  const { config } = await resolveProjectContext({ projectOverride: opts.project });
+  return config.projectGuid;
+}
+keyCommand.command("create <name>").description("Mint a project API key (shown once). Give it a name you will recognize later").option("--role <role>", "viewer | editor | owner (default: viewer)", "viewer").option("--expires-days <n>", "Days until the key expires (default: never)").option(...projectOpt).option("--json", "Output as JSON").action((name, opts) => run("Create", async () => {
+  const body = { name, role: opts.role };
+  if (opts.expiresDays !== void 0) {
+    const days = parseInt(opts.expiresDays, 10);
+    if (!Number.isFinite(days) || days <= 0) throw new Error("--expires-days must be a positive number of days");
+    body.expires_in_days = days;
+  }
+  const res = await post(
+    `/projects/${await projectGuid(opts)}/api-keys`,
+    body
+  );
+  const k7 = res.data;
+  if (opts.json) {
+    console.log(JSON.stringify(k7));
+    return;
+  }
+  const expNote = k7.expires_at ? ` (expires ${fmtDate2(k7.expires_at)})` : " (never expires)";
+  console.log(success(`Created API key ${bold(k7.short_guid)} "${k7.name}" as ${k7.role}${muted(expNote)}.`));
+  console.log("");
+  console.log(k7.key);
+  console.log("");
+  console.log(muted("Send it from your script on every request:"));
+  console.log(muted(`  curl -H "X-Api-Key: ${k7.key}" ...`));
+  console.log(muted(`Revoke it any time: gipity key revoke ${k7.short_guid}`));
+  console.log("");
+  console.log(warning("Copy it now - it will not be shown again."));
+}));
+keyCommand.command("list").alias("ls").description("List this project's API keys (values are never shown again)").option(...projectOpt).option("--json", "Output as JSON").action((opts) => run("List", async () => {
+  const res = await get(`/projects/${await projectGuid(opts)}/api-keys`);
+  printList(
+    res.data,
+    opts,
+    'No API keys. Mint one with: gipity key create "my script" --role editor',
+    (k7) => `${bold(k7.short_guid)}  ${k7.name}  ${muted(`${k7.role}  ${k7.prefix}\u2026  last used ${fmtDate2(k7.last_used_at)}  expires ${fmtDate2(k7.expires_at)}`)}`
+  );
+}));
+keyCommand.command("revoke <short_guid>").alias("rm").description("Revoke a project API key (instant, irreversible)").option(...projectOpt).option("--json", "Output as JSON").action((shortGuid, opts) => run("Revoke", async () => {
+  await del(`/projects/${await projectGuid(opts)}/api-keys/${encodeURIComponent(shortGuid)}`);
+  if (opts.json) {
+    console.log(JSON.stringify({ short_guid: shortGuid, revoked: true }));
+    return;
+  }
+  console.log(success(`Revoked API key ${bold(shortGuid)}.`));
+}));
+
 // src/commands/init.ts
 init_api();
 init_config();
@@ -34529,6 +34733,80 @@ function escapeHtml(s) {
 function jsEscape(s) {
   return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
 }
+var ACCENT_PALETTE = [
+  "#f59e0b",
+  "#f97316",
+  "#ef4444",
+  "#ec4899",
+  "#a855f7",
+  "#6366f1",
+  "#3b82f6",
+  "#0ea5e9",
+  "#14b8a6",
+  "#22c55e",
+  "#84cc16",
+  "#eab308"
+];
+function hashString(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function darkTint(hex) {
+  const n = parseInt(hex.slice(1), 16);
+  const base = 1052692;
+  const ch = (shift) => {
+    const a = n >> shift & 255;
+    const b7 = base >> shift & 255;
+    return Math.round(b7 + (a - b7) * 0.14).toString(16).padStart(2, "0");
+  };
+  return `#${ch(16)}${ch(8)}${ch(0)}`;
+}
+function buildHeadBlock(v7) {
+  const t = escapeHtml(v7.projectName);
+  const d = v7.description ? escapeHtml(v7.description) : "";
+  const url = v7.accountSlug && v7.projectSlug ? `https://app.gipity.ai/${v7.accountSlug}/${v7.projectSlug}/` : void 0;
+  const themeColor = darkTint(ACCENT_PALETTE[hashString(v7.projectGuid || v7.projectName) % ACCENT_PALETTE.length]);
+  const jsonLd = JSON.stringify({
+    "@context": "https://schema.org",
+    "@type": "WebApplication",
+    name: v7.projectName,
+    ...v7.description ? { description: v7.description } : {},
+    ...url ? { url } : {}
+  }, null, 2).replace(/<\//g, "<\\/");
+  const lines = [
+    `<title>${t}</title>`,
+    ...d ? [`<meta name="description" content="${d}">`] : [],
+    ...url ? [`<link rel="canonical" href="${url}">`] : [],
+    `<meta property="og:title" content="${t}">`,
+    `<meta property="og:type" content="website">`,
+    ...d ? [`<meta property="og:description" content="${d}">`] : [],
+    ...url ? [
+      `<meta property="og:url" content="${url}">`,
+      `<meta property="og:image" content="${url}images/og-image.png">`,
+      `<meta property="og:image:width" content="1200">`,
+      `<meta property="og:image:height" content="630">`
+    ] : [],
+    `<meta name="twitter:card" content="summary_large_image">`,
+    `<meta name="twitter:title" content="${t}">`,
+    ...d ? [`<meta name="twitter:description" content="${d}">`] : [],
+    ...url ? [`<meta name="twitter:image" content="${url}images/og-image.png">`] : [],
+    `<meta name="theme-color" content="${themeColor}">`,
+    `<link rel="icon" type="image/png" sizes="192x192" href="./images/favicon-192.png">`,
+    `<link rel="icon" type="image/png" sizes="512x512" href="./images/favicon-512.png">`,
+    `<link rel="icon" type="image/x-icon" href="./images/favicon.ico">`,
+    `<link rel="apple-touch-icon" href="./images/apple-touch-icon.png">`,
+    `<link rel="manifest" href="./manifest.webmanifest">`,
+    `<script type="application/ld+json">
+${jsonLd}
+  </script>`
+  ];
+  return lines.map((l7) => `
+  ${l7}`).join("");
+}
 function buildTemplateVars(v7) {
   const safeTitle = escapeHtml(v7.projectName);
   const safeDesc = v7.description ? escapeHtml(v7.description) : "";
@@ -34544,6 +34822,9 @@ function buildTemplateVars(v7) {
     "{{JS_TITLE}}": jsEscape(v7.projectName),
     "{{PROJECT_GUID}}": v7.projectGuid,
     "{{DATABASE}}": slug,
+    "{{HEAD_BLOCK}}": buildHeadBlock(v7),
+    // Legacy per-tag placeholders — current templates carry only {{HEAD_BLOCK}},
+    // but older local template copies may still reference these.
     "{{DESCRIPTION_META}}": v7.description ? `
   <meta name="description" content="${safeDesc}">` : "",
     "{{OG_DESCRIPTION}}": v7.description ? `
@@ -34638,7 +34919,9 @@ async function finalizeLocalProject(opts) {
   try {
     const sub = await substituteDir(opts.dir, {
       projectGuid: opts.projectGuid,
-      projectName: opts.projectName
+      projectName: opts.projectName,
+      accountSlug: opts.accountSlug,
+      projectSlug: opts.projectSlug
     });
     if (sub.changed.length) {
       console.log(muted(`Resolved template vars in ${sub.changed.length} file${sub.changed.length > 1 ? "s" : ""}.`));
@@ -35024,7 +35307,7 @@ function resolveTools(forFlag) {
     (t) => requested.includes(t.key) || !t.optIn && requested.includes("all")
   );
 }
-var initCommand = new Command("init").description("Link this directory to a project").addHelpText("after", "\nWrites CLAUDE.md/AGENTS.md primer files so your AI coding tool understands Gipity, and installs the Gipity skills + file-sync hooks into the agent CLIs found on this machine (Claude Code, Codex, Grok).").argument("[name]", "Project name/slug (defaults to current directory name)").option("--agent <guid>", "Agent GUID to use").option("--no-capture", "Don't record Claude Code sessions in this directory to your Gipity project (sets captureHooks: false in .gipity.json)").option(
+var initCommand = new Command("init").description("Link this directory to a project").addHelpText("after", "\nWrites CLAUDE.md/AGENTS.md primer files so your AI coding tool understands Gipity, and installs the Gipity skills + file-sync hooks into the agent CLIs found on this machine (Claude Code, Codex, Grok, Antigravity).").argument("[name]", "Project name/slug (defaults to current directory name)").option("--agent <guid>", "Agent GUID to use").option("--no-capture", "Don't record Claude Code sessions in this directory to your Gipity project (sets captureHooks: false in .gipity.json)").option(
   "--for <tools>",
   `Which AI tool primer files to write (comma-separated). Default: all except aider (opt-in - it also writes .aider.conf.yml). Choices: ${TOOL_KEYS.join(", ")}, all`
 ).addHelpText("after", `
@@ -35152,7 +35435,7 @@ Working with an existing Gipity project:
     }
     console.log(success(`Wrote primer files: ${primerSummary}.`));
     if (wantsClaude) {
-      console.log(success("Ready! Run your coding agent here (claude, codex, grok), or `gipity build` to launch one with a picker."));
+      console.log(success("Ready! Run your coding agent here (claude, codex, grok, agy), or `gipity build` to launch one with a picker."));
       if (opts.capture === false) {
         console.log(muted("Session recording is off for this project (captureHooks: false in .gipity.json)."));
       } else {
@@ -35448,6 +35731,30 @@ init_colors();
 init_auth();
 init_config();
 
+// src/db-checkpoint.ts
+init_api();
+async function resolveDatabase(projectGuid2, explicit) {
+  if (explicit) return explicit;
+  const res = await get(`/projects/${projectGuid2}/databases`);
+  return res.data.length > 0 ? res.data[0].friendlyName : null;
+}
+async function checkpoint(projectGuid2, database, action, keep) {
+  const res = await post(
+    `/projects/${projectGuid2}/db/checkpoint`,
+    { database, action, ...keep ? { keep } : {} }
+  );
+  return res.data;
+}
+function createCheckpoint(projectGuid2, database) {
+  return checkpoint(projectGuid2, database, "create");
+}
+function restoreCheckpoint(projectGuid2, database, opts = {}) {
+  return checkpoint(projectGuid2, database, "restore", opts.keep);
+}
+function dropCheckpoint(projectGuid2, database) {
+  return checkpoint(projectGuid2, database, "drop");
+}
+
 // src/page-fixtures.ts
 init_api();
 init_config();
@@ -35490,13 +35797,13 @@ Nothing named "${basename4(localPath)}" under ${root} either. Generate a frame w
     `${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") {
+async function uploadPublicFixture(projectGuid2, localPath, flag = "--fixture") {
   assertLocalAsset(flag, localPath);
   const name = basename4(localPath);
   const size = statSync6(localPath).size;
   const contentType = guessMime(localPath);
   const init = await post(
-    `/api/${projectGuid}/uploads/init`,
+    `/api/${projectGuid2}/uploads/init`,
     { filename: name, content_type: contentType, size, public: true }
   );
   if (init.data.method !== "PUT" || !init.data.url) {
@@ -35511,13 +35818,13 @@ async function uploadPublicFixture(projectGuid, localPath, flag = "--fixture") {
     throw new Error(`upload of fixture "${name}" failed: ${res.status} ${res.statusText}`);
   }
   const done = await post(
-    `/api/${projectGuid}/uploads/complete`,
+    `/api/${projectGuid2}/uploads/complete`,
     { upload_guid: init.data.upload_guid }
   );
   return { guid: done.data.guid, url: done.data.url, name, localPath };
 }
-async function deleteFixture(projectGuid, guid) {
-  await del(`/api/${projectGuid}/uploads/${guid}`);
+async function deleteFixture(projectGuid2, guid) {
+  await del(`/api/${projectGuid2}/uploads/${guid}`);
 }
 var CAMERA_EXTS = [".png", ".jpg", ".jpeg", ".webp", ".mp4", ".webm", ".y4m", ".mjpeg"];
 function assertCameraFile(localPath) {
@@ -35530,9 +35837,9 @@ A still image is played as a looping single-frame feed, which is what a gesture/
 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) {
+async function uploadCameraFeed(projectGuid2, localPath) {
   assertCameraFile(localPath);
-  return uploadPublicFixture(projectGuid, localPath, "--camera");
+  return uploadPublicFixture(projectGuid2, localPath, "--camera");
 }
 
 // src/commands/page-eval.ts
@@ -35655,7 +35962,15 @@ function budgetOverrunHint(reason, usedBudgetMs) {
   }
   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 navigationAbortHint(reason) {
+  if (!/navigated or reloaded/i.test(reason)) return null;
+  return `If you were verifying that state SURVIVES a reload, that is what --reload is for (one command, one page): gipity page eval "<url>" '<seed/assert expr>' --reload '<assert-restored expr>'. It reloads the page in place (localStorage/sessionStorage/cookies preserved) and reports the second result separately. Splitting into two 'page eval' calls does NOT do this: each call is its own browser session, so the second one starts from empty storage and never exercises the restore path.`;
+}
+function stepsDeterministically(script) {
+  return /\badvance\s*\(/.test(script);
+}
 function slowRenderMessage(fps, o) {
+  if (!o.camera && stepsDeterministically(o.script ?? "")) return null;
   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}`;
@@ -35713,14 +36028,14 @@ 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."
+  '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 ("remember it when I come back"): seed/assert state with <expr>, then assert the restored UI here. This is the ONLY way to check that - reloading inside the body aborts the eval (the result is lost with the old page), and two separate `page eval` calls are two fresh browser profiles, so the second starts from empty storage.'
 ).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. Bare number = MILLISECONDS (so 90s = 90000, NOT 90); or pass an explicit unit that means the same on both this and \`sandbox run --timeout\` \u2014 --timeout 90s. Its own await/setTimeout pauses count (default ${EVAL_SCRIPT_BUDGET_MS}, ${EVAL_SCRIPT_BUDGET_CAMERA_MS} with --camera/--fake-media; floor 1000, 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. Without this flag the page loads as a genuinely anonymous, signed-out visitor \u2014 nothing carries over from earlier --auth runs.").option("--json", "Output as JSON").action((url, exprArg, opts) => run("Page eval", async () => {
+).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. Without this flag the page loads as a genuinely anonymous, signed-out visitor \u2014 nothing carries over from earlier --auth runs.").option("--restore-db", "Snapshot the app database before the script runs and roll it back after, so a write-path check (click Approve, submit the form, edit a row) leaves the real data untouched. Use this whenever the eval WRITES - it is the undo for driving the deployed app against real project data. Same snapshot/undo standalone: gipity db checkpoint / gipity db restore.").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(
@@ -35797,23 +36112,36 @@ var pageEvalCommand = new Command("eval").description("Evaluate JS in a real bro
   const fixturePaths = opts.fixture ?? [];
   const hosted = [];
   let camera;
-  let projectGuid;
+  let projectGuid2;
   let sentExpr = expr;
   let sentSteps = steps;
   if (opts.camera) assertCameraFile(opts.camera);
+  let restoreDb;
   try {
+    if (opts.restoreDb) {
+      const { config } = await resolveProjectContext({});
+      projectGuid2 = config.projectGuid;
+      const database = await resolveDatabase(config.projectGuid);
+      if (!database) {
+        console.error(muted("--restore-db: this project has no database - nothing to roll back."));
+      } else {
+        const cp2 = await createCheckpoint(config.projectGuid, database);
+        console.error(muted(`Checkpointed ${cp2.tables.length} table(s), ${cp2.rows} row(s) in '${database}' - rolled back when this eval finishes.`));
+        restoreDb = { projectGuid: config.projectGuid, database };
+      }
+    }
     if (fixturePaths.length || opts.camera) {
       const { config } = await resolveProjectContext({});
-      projectGuid = config.projectGuid;
+      projectGuid2 = config.projectGuid;
     }
     if (opts.camera) {
       console.log(muted(`Hosting camera feed ${opts.camera}...`));
-      camera = await uploadCameraFeed(projectGuid, opts.camera);
+      camera = await uploadCameraFeed(projectGuid2, opts.camera);
     }
     if (fixturePaths.length) {
       for (const p of fixturePaths) {
         console.log(muted(`Hosting fixture ${p}...`));
-        hosted.push(await uploadPublicFixture(projectGuid, p));
+        hosted.push(await uploadPublicFixture(projectGuid2, p));
       }
       const map = {};
       for (const h of hosted) map[h.name] = h.url;
@@ -35851,7 +36179,7 @@ var pageEvalCommand = new Command("eval").description("Evaluate JS in a real bro
       }));
     } catch (err) {
       const msg = err?.message ?? "";
-      const hint = budgetOverrunHint(msg, scriptBudgetMs);
+      const hint = budgetOverrunHint(msg, scriptBudgetMs) ?? (reloadExpr === void 0 ? navigationAbortHint(msg) : null);
       if (!hint) throw err;
       throw new Error(`${msg}
 ${hint}`);
@@ -35883,7 +36211,12 @@ ${hint}`);
       console.log(`${warning("\u26A0 Navigation incomplete:")} ${d.note || "page did not reach full load"}`);
     }
     if (d.slowRender) {
-      console.log(slowRenderMessage(d.slowRender.fps, { camera: !!camera, waitMs }));
+      const slow = slowRenderMessage(d.slowRender.fps, {
+        camera: !!camera,
+        waitMs,
+        script: [expr, ...steps, reloadExpr ?? ""].join("\n")
+      });
+      if (slow) console.log(slow);
     }
     if (d.auth?.requested) {
       const who = getAuth()?.email;
@@ -35916,9 +36249,17 @@ ${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 {
+    if (restoreDb) {
+      try {
+        const r = await restoreCheckpoint(restoreDb.projectGuid, restoreDb.database);
+        console.error(muted(`Rolled ${r.tables.length} table(s) back to the checkpoint (${r.rows} row(s)) - nothing this eval wrote survives.`));
+      } catch (err) {
+        console.error(warning(`\u26A0 Could not roll back the database - the checkpoint is still there, retry with: gipity db restore (${err.message})`));
+      }
+    }
     for (const h of [...hosted, ...camera ? [camera] : []]) {
       try {
-        await deleteFixture(projectGuid, h.guid);
+        await deleteFixture(projectGuid2, h.guid);
       } catch (err) {
         console.error(warning(`\u26A0 Could not auto-delete fixture "${h.name}" (${h.guid}) \u2014 still hosted at ${h.url}: ${err.message}`));
       }
@@ -36012,7 +36353,7 @@ init_auth();
 init_colors();
 init_utils();
 import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname7, join as join12, resolve as resolvePath } from "path";
+import { dirname as dirname7, extname as extname4, join as join12, resolve as resolvePath } from "path";
 var DEVICE_PRESETS = {
   default: { width: 1280, height: 720 },
   desktop: { width: 1920, height: 1080 },
@@ -36123,6 +36464,14 @@ function resolveDevice(name) {
   const available = [...Object.keys(DEVICE_PRESETS), ...TOUCH_DEVICES].join(", ");
   throw new Error(`Unknown --device preset: "${name}" (known: ${available})`);
 }
+function viewportSlug(name) {
+  return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "shot";
+}
+function stemPath(output, suffix) {
+  const ext = extname4(output) || ".png";
+  const base = ext && output.endsWith(ext) ? output.slice(0, -ext.length) : output;
+  return `${base}-${suffix}${ext}`;
+}
 function splitCsv(values) {
   if (!values || values.length === 0) return [];
   return values.flatMap((v7) => v7.split(",").map((s) => s.trim()).filter(Boolean));
@@ -36139,7 +36488,7 @@ 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("--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), e.g. --viewport 390x844 for a phone-sized window", appendOption, []).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 - 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('./...') 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("--file <path>", "Read the pre-capture script from a file instead of inline --action (mutually exclusive), or --file - to read it from stdin (pipe a heredoc: --file - <<'EOF' ... EOF) with no tmp file. For a multi-step driver - click through a flow, wait for it to render - then capture. Same async-function-body semantics as --action; same --file flag as page eval.").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("--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. Without this flag the page loads as a genuinely anonymous, signed-out visitor \u2014 nothing carries over from earlier --auth runs.").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()).addOption(new Option("--width <px>", "Alias: --viewport WxH").hideHelp()).addOption(new Option("--height <px>", "Alias: --viewport WxH").hideHelp()).action((url, opts) => run("Page screenshot", async () => {
+var pageScreenshotCommand = new Command("screenshot").description("Screenshot a web page").argument("<url>", "URL to screenshot").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), e.g. --viewport 390x844 for a phone-sized window", appendOption, []).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 - 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('./...') 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("--file <path>", "Read the pre-capture script from a file instead of inline --action (mutually exclusive), or --file - to read it from stdin (pipe a heredoc: --file - <<'EOF' ... EOF) with no tmp file. For a multi-step driver - click through a flow, wait for it to render - then capture. Same async-function-body semantics as --action; same --file flag as page eval.").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 (default .gipity/screenshots/ss-<host>-<timestamp>.png). With several viewports it is a stem: -o tmp/shot.png --device desktop,mobile writes tmp/shot-desktop.png and tmp/shot-mobile.png.").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. Without this flag the page loads as a genuinely anonymous, signed-out visitor \u2014 nothing carries over from earlier --auth runs.").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()).addOption(new Option("--width <px>", "Alias: --viewport WxH").hideHelp()).addOption(new Option("--height <px>", "Alias: --viewport WxH").hideHelp()).action((url, opts) => run("Page screenshot", async () => {
   const aliasFlag = ACTION_ALIAS_FLAGS.find((f) => opts[f.slice(2)] !== void 0);
   if (aliasFlag) {
     console.error(muted(
@@ -36209,22 +36558,23 @@ var pageScreenshotCommand = new Command("screenshot").description("Screenshot a
     ...deviceNames.map(resolveDevice),
     ...viewportStrs.map(parseViewportString)
   ];
-  if (opts.output && customViewports.length > 1) {
-    throw new Error("--output can only be used with a single viewport");
-  }
+  const viewportLabels = [
+    ...deviceNames.map(viewportSlug),
+    ...viewportStrs.map(viewportSlug)
+  ];
   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;
+  const projectGuid2 = getConfig()?.projectGuid;
+  const save = !opts.ephemeral && projectGuid2 ? { project_guid: projectGuid2, 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.");
+    if (!projectGuid2) 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}...`));
-    camera = await uploadCameraFeed(projectGuid, opts.camera);
+    camera = await uploadCameraFeed(projectGuid2, opts.camera);
   }
   const preCapture = [
     opts.waitFor ? buildWaitForGate(opts.waitFor, waitForTimeoutMs) : "",
@@ -36255,7 +36605,7 @@ var pageScreenshotCommand = new Command("screenshot").description("Screenshot a
   } finally {
     if (camera) {
       try {
-        await deleteFixture(projectGuid, camera.guid);
+        await deleteFixture(projectGuid2, 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}`));
       }
@@ -36270,8 +36620,16 @@ var pageScreenshotCommand = new Command("screenshot").description("Screenshot a
   }
   const dir = defaultScreenshotDir();
   const savedFiles = [];
+  const usedStems = /* @__PURE__ */ new Set();
+  const outputPath = (i) => {
+    if (pngs.length === 1) return opts.output;
+    let suffix = viewportLabels[i] ?? dimSuffix(meta.screenshots[i].viewport);
+    while (usedStems.has(suffix)) suffix += `-${i + 1}`;
+    usedStems.add(suffix);
+    return stemPath(opts.output, suffix);
+  };
   for (let i = 0; i < pngs.length; i++) {
-    const target = opts.output ? opts.output : join12(dir, names[i] ?? shotName(meta.screenshots[i].viewport));
+    const target = opts.output ? outputPath(i) : join12(dir, names[i] ?? shotName(meta.screenshots[i].viewport));
     mkdirSync7(dirname7(target), { recursive: true });
     writeFileSync8(target, pngs[i].buffer);
     savedFiles.push(resolvePath(target));
@@ -36757,10 +37115,10 @@ dbCommand.command("list").description("List databases").option("--all", "List da
       grouped.get(key).push(db2);
     }
     let first = true;
-    for (const [projectGuid, dbs] of grouped) {
+    for (const [projectGuid2, dbs] of grouped) {
       if (!first) console.log("");
       first = false;
-      const label2 = dbs[0].projectSlug || dbs[0].projectName || projectGuid;
+      const label2 = dbs[0].projectSlug || dbs[0].projectName || projectGuid2;
       console.log(label2);
       for (const db2 of dbs) {
         console.log(`${db2.friendlyName}`);
@@ -36816,6 +37174,47 @@ dbCommand.command("drop <name>").description("Drop a database").option("--projec
     console.log(success(`Dropped database '${name}'.`));
   }
 }));
+dbCommand.command("checkpoint").description("Snapshot every table so a write test can be undone. Take one before exercising a real write path (page eval on the deployed app, fn call, workflow run), then `gipity db restore` to put the data back exactly as it was - no hand-written SQL to scrub test strings out of real content.").option("--database <name>", "Database name").option("--drop", "Discard the existing checkpoint without restoring (keep whatever the run wrote)").option("--json", "Output as JSON").action((opts) => run("Checkpoint", async () => {
+  const config = requireConfig();
+  const dbName = await resolveDatabase(config.projectGuid, opts.database);
+  if (!dbName) {
+    console.error(error("No databases in this project - nothing to checkpoint."));
+    process.exit(1);
+  }
+  if (opts.drop) {
+    const dropped = await dropCheckpoint(config.projectGuid, dbName);
+    if (opts.json) {
+      console.log(JSON.stringify(dropped));
+    } else {
+      console.log(dropped.tables.length === 0 ? `No checkpoint in '${dbName}'.` : success(`Discarded the checkpoint of ${dropped.tables.length} table(s) in '${dbName}'. Current data kept.`));
+    }
+    return;
+  }
+  const res = await createCheckpoint(config.projectGuid, dbName);
+  if (opts.json) {
+    console.log(JSON.stringify(res));
+  } else if (res.tables.length === 0) {
+    console.log(`Database '${dbName}' has no tables - nothing to checkpoint.`);
+  } else {
+    console.log(success(`Checkpointed ${res.tables.length} table(s), ${res.rows} row(s) in '${dbName}'.`));
+    console.log("Undo everything written since: gipity db restore");
+  }
+}));
+dbCommand.command("restore").description("Roll every table back to the last `gipity db checkpoint` and drop the checkpoint. The undo for a live write test.").option("--database <name>", "Database name").option("--keep", "Keep the checkpoint after restoring, so you can run the same write test again").option("--json", "Output as JSON").action((opts) => run("Restore", async () => {
+  const config = requireConfig();
+  const dbName = await resolveDatabase(config.projectGuid, opts.database);
+  if (!dbName) {
+    console.error(error("No databases in this project - nothing to restore."));
+    process.exit(1);
+  }
+  const res = await restoreCheckpoint(config.projectGuid, dbName, { keep: opts.keep });
+  if (opts.json) {
+    console.log(JSON.stringify(res));
+  } else {
+    console.log(success(`Restored ${res.tables.length} table(s) to the checkpoint (${res.rows} row(s)) in '${dbName}'.`));
+    if (opts.keep) console.log("Checkpoint kept - restore again any time.");
+  }
+}));
 
 // src/commands/memory.ts
 init_api();
@@ -36870,7 +37269,7 @@ memoryCommand.command("delete <topic>").description("Delete a topic").option("--
 init_api();
 init_config();
 import { readFileSync as readFileSync15, existsSync as existsSync11, statSync as statSync7, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname8, extname as extname4, relative as relative4, resolve as resolve11, sep as sep3 } from "path";
+import { dirname as dirname8, extname as extname5, relative as relative4, resolve as resolve11, sep as sep3 } from "path";
 init_colors();
 var LANG_MAP = {
   js: "javascript",
@@ -36934,7 +37333,7 @@ function resolveLanguage(opts) {
     process.exit(1);
   }
   if (explicit) return explicit;
-  const fromExt = opts.filePath ? LANG_MAP[extname4(opts.filePath).slice(1).toLowerCase()] : void 0;
+  const fromExt = opts.filePath ? LANG_MAP[extname5(opts.filePath).slice(1).toLowerCase()] : void 0;
   if (fromExt) return fromExt;
   if (opts.filePath) {
     console.error(error(`Cannot infer the language of ${opts.filePath} from its extension (expected .js, .py, or .sh).`));
@@ -37645,6 +38044,33 @@ function formatRunLine(r) {
   const statusColor = r.status === "completed" ? success : r.status === "failed" ? error : muted;
   return `${muted(r.short_guid)}  ${statusColor(r.status)}  ${dur}  ${runTokens(r)} tokens  ${muted(fmtTime(r.started_at))}`;
 }
+function jsonStringInfo(v7) {
+  if (typeof v7 !== "string") return null;
+  const t = v7.trim();
+  if (!t.startsWith("{") && !t.startsWith("[")) return null;
+  try {
+    const parsed = JSON.parse(t);
+    return typeof parsed === "object" && parsed !== null ? { ok: true, value: parsed } : null;
+  } catch {
+    return { ok: false };
+  }
+}
+function labelFor(info2) {
+  return info2.ok ? "(JSON string)" : error("(truncated/invalid JSON string)");
+}
+function renderStepOutput(output) {
+  if (output && typeof output === "object" && !Array.isArray(output)) {
+    return Object.entries(output).map(([k7, v7]) => {
+      const info3 = jsonStringInfo(v7);
+      if (!info3) return `${JSON.stringify(k7)}: ${JSON.stringify(v7, null, 2)}`;
+      const body = info3.ok ? JSON.stringify(info3.value, null, 2) : JSON.stringify(v7);
+      return `${JSON.stringify(k7)} ${labelFor(info3)}: ${body}`;
+    }).join("\n");
+  }
+  const info2 = jsonStringInfo(output);
+  if (info2?.ok) return JSON.stringify(info2.value, null, 2);
+  return JSON.stringify(output, null, 2);
+}
 function printStepRuns(steps, emptyNote) {
   if (steps.length === 0) {
     console.log(`  ${muted(emptyNote)}`);
@@ -37657,7 +38083,7 @@ function printStepRuns(steps, emptyNote) {
     console.log(`  ${s.step_order}. ${name}${statusColor(s.status)}  ${s.tokens_used ?? 0} tokens${model}`);
     if (s.error_message) console.log(`     ${error(s.error_message)}`);
     if (s.output_json !== null && s.output_json !== void 0) {
-      console.log(JSON.stringify(s.output_json, null, 2).split("\n").map((l7) => `     ${l7}`).join("\n"));
+      console.log(renderStepOutput(s.output_json).split("\n").map((l7) => `     ${l7}`).join("\n"));
     }
   }
 }
@@ -37728,7 +38154,7 @@ workflowCommand.command("info <name>").description("Show workflow details").opti
     }
   }
 }));
-workflowCommand.command("run <name>").description("Trigger a workflow (add --wait to block until it finishes)").option("--json", "Output as JSON").option("--wait", "Block until the triggered run reaches a terminal state, then print it").option("--timeout <s>", "Max seconds to wait with --wait", "120").action((name, _opts, cmd) => run("Run", async () => {
+workflowCommand.command("run <name>").description("Run a workflow: waits for it to finish and prints each step's status and output (--no-wait to fire and forget)").option("--json", "Output as JSON").option("--no-wait", "Trigger and return immediately instead of waiting for the run").addOption(new Option("--wait", "Wait for the run (already the default)").hideHelp()).option("--timeout <s>", "Max seconds to wait for the run to finish", "300").action((name, _opts, cmd) => run("Run", async () => {
   const opts = mergedOpts(cmd);
   const wf2 = await resolveWorkflow(name);
   if (!opts.wait) {
@@ -37739,7 +38165,7 @@ workflowCommand.command("run <name>").description("Trigger a workflow (add --wai
   const before = await get(`/workflows/${wf2.short_guid}/runs?limit=1`);
   const prevGuid = before.data[0]?.short_guid;
   await post(`/workflows/${wf2.short_guid}/run`, {});
-  const r = await waitForRun(wf2.short_guid, prevGuid, Number(opts.timeout) || 120);
+  const r = await waitForRun(wf2.short_guid, prevGuid, Number(opts.timeout) || 300);
   if (opts.json) {
     console.log(JSON.stringify(r));
   } else {
@@ -38751,7 +39177,7 @@ async function runRelaySetup(opts) {
   }
   console.log("");
   const promptText = opts.mode === "run-now" ? "  Set up remote control on this computer" : "  Enable remote control";
-  const enable = await confirm(promptText, { default: "yes" });
+  const enable = await confirm(promptText, { default: "yes", headless: "no" });
   if (!enable) {
     setRelayEnabled(false);
     console.log(`  ${muted("Skipped. Turn on later with")} ${brand("gipity connect")}${muted(".")}`);
@@ -38778,7 +39204,7 @@ async function runRelaySetup(opts) {
   }
   startDaemon();
   console.log("");
-  const autostartOs = await confirm("  Also start at OS login", { default: "yes" });
+  const autostartOs = await confirm("  Also start at OS login", { default: "yes", headless: "no" });
   if (autostartOs) {
     try {
       const res = installAutostart();
@@ -38801,7 +39227,7 @@ async function runRelaySetup(opts) {
   }
   if (getDiagnosticsConsent() === void 0) {
     console.log("");
-    const diag = await confirm("  Share anonymous diagnostics info", { default: "yes" });
+    const diag = await confirm("  Share anonymous diagnostics info", { default: "yes", headless: "no" });
     setDiagnosticsConsent(diag);
   }
   console.log("");
@@ -39240,11 +39666,53 @@ var grokAdapter = {
   installHint: "curl -fsSL https://grok.x.ai/install.sh | sh   (or see docs.x.ai/grok-build)"
 };
 
+// src/agents/agy.ts
+var MODEL_ID_TO_AGY_DISPLAY = {
+  "gemini-3.5-flash": "Gemini 3.5 Flash (Medium)",
+  "gemini-3.1-pro-preview": "Gemini 3.1 Pro (High)"
+};
+function translateModel(model) {
+  return MODEL_ID_TO_AGY_DISPLAY[model] ?? model;
+}
+function projectArgs(resume) {
+  return resume ? ["--conversation", resume] : ["--new-project"];
+}
+var agyAdapter = {
+  key: "agy",
+  source: "agy",
+  displayName: "Antigravity",
+  providerName: "Google",
+  binary: "agy",
+  buildInteractiveArgs({ resume, model }) {
+    const args = [...projectArgs(resume)];
+    if (model) args.push("--model", translateModel(model));
+    return args;
+  },
+  buildHeadlessArgs({ message, resume, model, bypassApprovals }) {
+    const args = ["-p", message, ...projectArgs(resume)];
+    if (model) args.push("--model", translateModel(model));
+    if (bypassApprovals) args.push("--dangerously-skip-permissions");
+    return args;
+  },
+  sessionIdFromStreamEvent() {
+    return null;
+  },
+  hooksSupportedOnPlatform(platform2) {
+    return platform2 !== "win32";
+  },
+  // No stream-json ingest mapper for agy: hook capture carries the full
+  // conversationId on every event (confirmed live, including headless -p),
+  // so the daemon doesn't need to parse agy's stdout at all.
+  daemonStreamCapture: false,
+  installHint: "see https://antigravity.google (Google account sign-in required)"
+};
+
 // src/agents/index.ts
 var AGENT_ADAPTERS = [
   claudeCodeAdapter,
   codexAdapter,
-  grokAdapter
+  grokAdapter,
+  agyAdapter
 ];
 var AGENT_KEYS = AGENT_ADAPTERS.map((a) => a.key);
 function getAdapter(key) {
@@ -39316,10 +39784,10 @@ function reportSyncResult(result) {
     console.log(`  ${muted("Nothing was deleted. Re-run `gipity sync` to finish the pull.")}`);
   }
 }
-async function fetchProjectStats(projectGuid, cwd) {
-  if (projectGuid) {
+async function fetchProjectStats(projectGuid2, cwd) {
+  if (projectGuid2) {
     try {
-      const res = await get(`/projects/${encodeURIComponent(projectGuid)}/files/stats`);
+      const res = await get(`/projects/${encodeURIComponent(projectGuid2)}/files/stats`);
       const d = res.data;
       const topLevelNames = d.top_level.map((e) => e.type === "directory" ? `${e.name}/` : e.name);
       return {
@@ -39913,7 +40381,7 @@ async function pickAgent(lastUsed) {
   AGENT_ADAPTERS.forEach((a, i) => {
     const notes = [];
     if (a.key === lastUsed) notes.push("last used");
-    if (a.key === "codex" && !a.hooksSupportedOnPlatform(process.platform)) {
+    if ((a.key === "codex" || a.key === "agy") && !a.hooksSupportedOnPlatform(process.platform)) {
       notes.push("session recording unavailable on Windows");
     }
     const note = notes.length ? `  ${muted(`(${notes.join(", ")})`)}` : "";
@@ -40286,9 +40754,9 @@ var STARTERS = [
 ];
 var BLANK = [
   { key: "web-simple", hint: "static frontend-only site - pages, dashboards, simple games" },
-  { key: "web-fullstack", hint: "backend API + database wiring - frontend, functions, migrations; deploys green" },
+  { key: "web-fullstack", hint: "backend API + database wiring - frontend, functions, migrations; deploys green empty" },
   { key: "3d-engine", hint: "3D multiplayer wiring - Three.js + Rapier + Gipity Realtime" },
-  { key: "api", hint: "pure API backend, no frontend - one example function + test" }
+  { key: "api", hint: "pure API backend, no frontend - functions + tests, deploys green" }
 ];
 var KITS = [
   { key: "realtime", hint: "multiplayer / presence / shared state" },
@@ -40490,6 +40958,87 @@ Pulled ${syncResult.applied} files to local.`);
   }
 }));
 
+// src/commands/brand.ts
+init_api();
+init_config();
+init_colors();
+function printBrand(d) {
+  console.log(`${bold("Glyph:")}  ${d.resolved.glyph}${d.resolved.isEmoji ? muted(" (emoji)") : ""}`);
+  console.log(`${bold("Accent:")} ${d.resolved.accent}${d.branding.primary_color ? "" : muted(" (derived from project)")}`);
+  if (d.branding.app_name) console.log(`${bold("Name:")}   ${d.branding.app_name}`);
+  if (d.branding.tagline) console.log(`${bold("Tagline:")} ${d.branding.tagline}`);
+}
+var DEPLOY_HINT = "Deploy to publish the new assets: gipity deploy dev";
+var brandCommand = new Command("brand").description("The app's generated icons + share card (favicons, iOS icon, og-image)").addHelpText("after", `
+Examples:
+  gipity brand                                Show the current brand
+  gipity brand set --emoji \u{1F98D}                 Emoji icon + share card, regenerate all assets
+  gipity brand set --glyph R --color "#3b82f6"  Letter glyph on a blue accent
+  gipity brand set --tagline "Bananas at 60fps"  Subtitle on the share card
+  gipity brand apply                          Re-render assets from the stored brand
+  gipity brand apply --fix-head               Migrate an older app: assets + splice the
+                                              share/SEO tags into src/index.html
+
+Assets are generated server-side into src/images/ (+ src/manifest.webmanifest)
+and are versioned like any other file - rollback restores previous ones.`);
+brandCommand.command("show", { isDefault: true }).description("Show the stored brand and the resolved render spec").option("--project <guid-or-slug>", "Target a specific project instead of cwd / Home").option("--json", "Output raw JSON").action((opts) => run("Brand", async () => {
+  const { config } = await resolveProjectContext({ projectOverride: opts.project });
+  const res = await get(`/projects/${config.projectGuid}/brand`);
+  if (opts.json) {
+    console.log(JSON.stringify(res.data));
+    return;
+  }
+  printBrand(res.data);
+  console.log(muted(`
+Assets: ${(res.data.assets ?? []).join(", ")}`));
+  console.log(muted(`Change it: gipity brand set --emoji \u{1F3A8} | --glyph A | --color "#RRGGBB" | --tagline "..."`));
+}));
+brandCommand.command("set").description("Change brand fields and regenerate all assets").option("--emoji <emoji>", "Emoji glyph for the icon + share card (e.g. \u{1F98D})").option("--glyph <char>", "Letter/digit glyph (alias of --emoji, any single character)").option("--color <hex>", "Accent color, #RRGGBB").option("--name <name>", "Display name override (og/share title stays the page title)").option("--tagline <text>", "One-line subtitle on the share card (max 120 chars)").option("--fix-head", "Also splice the share/SEO head block into src/index.html (for apps installed before templates shipped it)").option("--no-regenerate", "Store the fields without re-rendering assets").option("--project <guid-or-slug>", "Target a specific project instead of cwd / Home").option("--json", "Output raw JSON").action((opts) => run("Brand", async () => {
+  const { config } = await resolveProjectContext({ projectOverride: opts.project });
+  const body = {};
+  const glyph = opts.emoji ?? opts.glyph;
+  if (glyph) body.icon_glyph = glyph;
+  if (opts.color) body.primary_color = opts.color;
+  if (opts.name) body.app_name = opts.name;
+  if (opts.tagline) body.tagline = opts.tagline;
+  if (opts.regenerate === false) body.regenerate = false;
+  if (opts.fixHead) body.fix_head = true;
+  if (!glyph && !opts.color && !opts.name && !opts.tagline) {
+    console.error("Nothing to set - pass --emoji, --glyph, --color, --name, or --tagline. (gipity brand set --help; use gipity brand apply to just re-render)");
+    process.exitCode = 1;
+    return;
+  }
+  const res = await post(`/projects/${config.projectGuid}/brand`, body);
+  if (opts.json) {
+    console.log(JSON.stringify(res.data));
+    return;
+  }
+  printBrand(res.data);
+  reportFiles(res.data.files ?? []);
+}));
+brandCommand.command("apply").description("Re-render all brand assets from the stored brand (no field changes)").option("--fix-head", "Also splice the share/SEO head block into src/index.html (for apps installed before templates shipped it)").option("--project <guid-or-slug>", "Target a specific project instead of cwd / Home").option("--json", "Output raw JSON").action((opts) => run("Brand", async () => {
+  const { config } = await resolveProjectContext({ projectOverride: opts.project });
+  const body = opts.fixHead ? { fix_head: true } : {};
+  const res = await post(`/projects/${config.projectGuid}/brand`, body);
+  if (opts.json) {
+    console.log(JSON.stringify(res.data));
+    return;
+  }
+  reportFiles(res.data.files ?? []);
+}));
+function reportFiles(files) {
+  if (!files.length) {
+    console.log(muted("\nStored (assets not regenerated - run gipity brand apply)."));
+    return;
+  }
+  console.log(success(`
+\u2713 Regenerated ${files.length} asset${files.length === 1 ? "" : "s"}.`));
+  if (files.includes("src/index.html")) {
+    console.log(success("\u2713 src/index.html head updated (page title/description preserved)."));
+  }
+  console.log(muted(`  ${DEPLOY_HINT}`));
+}
+
 // src/commands/remove.ts
 init_api();
 init_config();
@@ -40984,7 +41533,7 @@ async function runInteractive(url, observe, opts) {
   const samples = Math.min(30, Math.max(2, parseInt(opts.samples, 10) || 6));
   const settle = opts.waitFor ? 200 : 1e3;
   const labels = (opts.labels ? String(opts.labels).split(",").map((s) => s.trim()) : []).filter(Boolean);
-  const labelFor = (i) => labels[i] ?? `client-${i}`;
+  const labelFor2 = (i) => labels[i] ?? `client-${i}`;
   warnUnknownTokens(unknownTokens(url, opts.action, observe));
   if (!opts.json) {
     console.log(`${brand("Page test")} ${muted("(interactive)")} ${bold(url)}`);
@@ -40994,16 +41543,16 @@ async function runInteractive(url, observe, opts) {
   for (let i = 0; i < clients; i++) {
     runs.push((async () => {
       await sleep3(i * stagger * 1e3);
-      if (!opts.json) console.log(muted(`client ${i} (${labelFor(i)}) joining`));
-      const clientUrl = subst(url, labelFor(i), i);
+      if (!opts.json) console.log(muted(`client ${i} (${labelFor2(i)}) joining`));
+      const clientUrl = subst(url, labelFor2(i), i);
       const expr = buildHarness(
-        opts.action ? subst(opts.action, labelFor(i), i) : void 0,
-        subst(observe, labelFor(i), i),
-        labelFor(i),
+        opts.action ? subst(opts.action, labelFor2(i), i) : void 0,
+        subst(observe, labelFor2(i), i),
+        labelFor2(i),
         hold,
         samples
       );
-      return observeClient(clientUrl, expr, i, labelFor(i), settle, hold, opts.waitFor);
+      return observeClient(clientUrl, expr, i, labelFor2(i), settle, hold, opts.waitFor);
     })());
   }
   const results = (await Promise.all(runs)).sort((a, b7) => a.i - b7.i);
@@ -41057,7 +41606,7 @@ async function runPassive(url, opts) {
   const stagger = opts.stagger != null ? Math.max(0, parseInt(opts.stagger, 10) || 0) : 12;
   const wait = Math.min(3e4, Math.max(2e3, parseInt(opts.wait, 10) || 24e3));
   const labels = (opts.labels ? String(opts.labels).split(",").map((s) => s.trim()) : []).filter(Boolean);
-  const labelFor = (i) => labels[i] ?? `client-${i}`;
+  const labelFor2 = (i) => labels[i] ?? `client-${i}`;
   warnUnknownTokens(unknownTokens(url));
   if (!opts.json) {
     console.log(`${brand("Page test")} ${bold(url)}`);
@@ -41068,7 +41617,7 @@ async function runPassive(url, opts) {
     runs.push((async () => {
       await sleep3(i * stagger * 1e3);
       if (!opts.json) console.log(`${muted(`client ${i}${i === 0 ? " (first)" : ""} starting`)}`);
-      return inspectClient(subst(url, labelFor(i), i), wait, i);
+      return inspectClient(subst(url, labelFor2(i), i), wait, i);
     })());
   }
   const results = (await Promise.all(runs)).sort((a, b7) => a.i - b7.i);
@@ -41262,10 +41811,31 @@ pageCommand.action(() => {
 
 // src/commands/records.ts
 init_api();
+init_auth();
 init_config();
 init_colors();
 init_utils();
 var recordsCommand = new Command("records").description("Manage app records (Gipity Records - validated CRUD with audit history)");
+var ANON_FLAG = "--anon";
+var ANON_HELP = "Call as an anonymous visitor (the public path a signed-out user hits) instead of as your signed-in account";
+async function recordsHttp(opts) {
+  const config = requireConfig();
+  if (!opts.anon) {
+    const who = getAuth()?.email;
+    console.error(muted(`Auth: calling as ${who ?? "your signed-in account"} (the owner persona; use ${ANON_FLAG} for the public visitor path)`));
+    return { guid: config.projectGuid, get, post, put, patch, del };
+  }
+  console.error(muted("Auth: anonymous visitor (the public path a signed-out user hits)"));
+  const headers = await mintAppToken(config.projectGuid);
+  return {
+    guid: config.projectGuid,
+    get: (path5) => publicRequest("GET", path5, void 0, headers),
+    post: (path5, body) => publicRequest("POST", path5, body, headers),
+    put: (path5, body) => publicRequest("PUT", path5, body, headers),
+    patch: (path5, body) => publicRequest("PATCH", path5, body, headers),
+    del: (path5, body) => publicRequest("DELETE", path5, body, headers)
+  };
+}
 recordsCommand.command("list").description("List record tables").option("--json", "Output as JSON").action((opts) => run("List", async () => {
   const config = requireConfig();
   const res = await get(`/api/${config.projectGuid}/records-config`);
@@ -41297,16 +41867,20 @@ recordsCommand.command("config <table>").description("Show or set a table's Reco
     res.data
   );
 }));
-recordsCommand.command("query <table>").description("List records").option("--filter <filter>", 'Filter string (e.g., "status:eq:active")').option("--sort <sort>", 'Sort string (e.g., "created_at:desc")').option("--limit <n>", "Max rows", "20").option("--offset <n>", "Offset", "0").option("--fields <fields>", "Comma-separated column names").option("--json", "Output as JSON").action((table, opts) => run("Query", async () => {
-  const config = requireConfig();
+recordsCommand.command("query <table>").description("List records (full-text search, filter, sort, recycle bin)").option("-q, --q <text>", "Full-text search across the table's text columns (needs `--searchable true` on the table)").option("--filter <filter>", 'AND filter string (e.g., "status:eq:active")').option("--any <filter>", 'OR filter group, same grammar as --filter (e.g., "owner:eq:me,shared:eq:true")').option("--sort <sort>", 'Sort string (e.g., "created_at:desc")').option("--limit <n>", "Max rows", "20").option("--offset <n>", "Offset", "0").option("--fields <fields>", "Comma-separated column names").option("--include-deleted", "Include soft-deleted rows (owner/editor)").option("--only-deleted", "Only soft-deleted rows - the recycle bin (owner/editor)").option(ANON_FLAG, ANON_HELP).option("--json", "Output as JSON").action((table, opts) => run("Query", async () => {
+  const api = await recordsHttp(opts);
   const params = new URLSearchParams();
+  if (opts.q) params.set("q", opts.q);
   if (opts.filter) params.set("filter", opts.filter);
+  if (opts.any) params.set("any", opts.any);
   if (opts.sort) params.set("sort", opts.sort);
   params.set("limit", opts.limit);
   params.set("offset", opts.offset);
   if (opts.fields) params.set("fields", opts.fields);
-  const res = await get(
-    `/api/${config.projectGuid}/records/${table}?${params}`
+  if (opts.includeDeleted) params.set("include_deleted", "1");
+  if (opts.onlyDeleted) params.set("only_deleted", "1");
+  const res = await api.get(
+    `/api/${api.guid}/records/${table}?${params}`
   );
   if (opts.json) {
     console.log(JSON.stringify(res));
@@ -41319,41 +41893,55 @@ recordsCommand.command("query <table>").description("List records").option("--fi
     console.log("");
   }
 }));
-recordsCommand.command("get <table> <id>").description("Get a record").option("--json", "Output as JSON").action((table, id2, opts) => run("Get", async () => {
-  const config = requireConfig();
-  const res = await get(`/api/${config.projectGuid}/records/${table}/${id2}`);
+recordsCommand.command("get <table> <id>").description("Get a record").option(ANON_FLAG, ANON_HELP).option("--json", "Output as JSON").action((table, id2, opts) => run("Get", async () => {
+  const api = await recordsHttp(opts);
+  const res = await api.get(`/api/${api.guid}/records/${table}/${id2}`);
   console.log(opts.json ? JSON.stringify(res.data) : JSON.stringify(res.data, null, 2));
 }));
-recordsCommand.command("history <table> <id>").description("Audit history for a record (who/what changed it, with English summaries)").option("--limit <n>", "Max events", "20").option("--json", "Output as JSON").action((table, id2, opts) => run("History", async () => {
-  const config = requireConfig();
-  const res = await get(
-    `/api/${config.projectGuid}/records/${table}/${id2}/history?limit=${encodeURIComponent(opts.limit)}`
+recordsCommand.command("history <table> [id]").description("Audit history (who/what changed it, with English summaries). Omit <id> for the whole table's feed.").option("--limit <n>", "Max events", "20").option(ANON_FLAG, ANON_HELP).option("--json", "Output as JSON").action((table, id2, opts) => run("History", async () => {
+  const api = await recordsHttp(opts);
+  const scope = id2 ? `${table}/${encodeURIComponent(id2)}` : table;
+  const res = await api.get(
+    `/api/${api.guid}/records/${scope}/history?limit=${encodeURIComponent(opts.limit)}`
   );
-  printList(res.data, opts, "No history for this record.", (e) => {
+  printList(res.data, opts, id2 ? "No history for this record." : `No history for "${table}".`, (e) => {
     const summary = e.detail?.summary || `${e.action} ${e.entity_type} ${e.entity_id}`;
     return `${muted(e.created_at)}  ${bold(e.source || "-")}  ${summary}`;
   });
 }));
-recordsCommand.command("create <table>").description("Create a record").requiredOption("--data <json>", "JSON object with field values").option("--json", "Output as JSON").action((table, opts) => run("Create", async () => {
-  const config = requireConfig();
+recordsCommand.command("create <table>").description("Create a record").requiredOption("--data <json>", "JSON object with field values").option(ANON_FLAG, ANON_HELP).option("--json", "Output as JSON").action((table, opts) => run("Create", async () => {
+  const api = await recordsHttp(opts);
   const data = JSON.parse(opts.data);
-  const res = await post(`/api/${config.projectGuid}/records/${table}`, data);
+  const res = await api.post(`/api/${api.guid}/records/${table}`, data);
   printResult(`Created: ${JSON.stringify(res.data)}`, opts, res.data);
 }));
-recordsCommand.command("update <table> <id>").description("Update a record").requiredOption("--data <json>", "JSON object with fields to update").option("--json", "Output as JSON").action((table, id2, opts) => run("Update", async () => {
-  const config = requireConfig();
+recordsCommand.command("update <table> <id>").description("Update a record").requiredOption("--data <json>", "JSON object with fields to update").option(ANON_FLAG, ANON_HELP).option("--json", "Output as JSON").action((table, id2, opts) => run("Update", async () => {
+  const api = await recordsHttp(opts);
   const data = JSON.parse(opts.data);
-  const res = await put(`/api/${config.projectGuid}/records/${table}/${id2}`, data);
+  const res = await api.put(`/api/${api.guid}/records/${table}/${id2}`, data);
   printResult(`Updated: ${JSON.stringify(res.data)}`, opts, res.data);
 }));
-recordsCommand.command("delete <table> <id>").description("Delete a record").action((table, id2) => run("Delete", async () => {
-  if (!await confirm(`Delete record ${id2} from "${table}"?`)) {
-    console.log("Cancelled.");
+recordsCommand.command("delete <table> <id>").description("Delete a record (soft-delete when the table declares one; --purge removes it for good)").option("--purge", "Hard-delete: remove the row AND erase its audit history (owner/editor). Use it to scrub probe rows.").option(ANON_FLAG, ANON_HELP).option("--json", "Output as JSON").action((table, id2, opts) => run("Delete", async () => {
+  const what = opts.purge ? `Purge record ${id2} from "${table}" (also erases its history)?` : `Delete record ${id2} from "${table}"?`;
+  if (!await confirm(what)) {
+    printResult("Cancelled.", opts, { table, id: id2, deleted: false, cancelled: true });
     return;
   }
-  const config = requireConfig();
-  await del(`/api/${config.projectGuid}/records/${table}/${id2}`);
-  printResult("Deleted.", { json: false });
+  const api = await recordsHttp(opts);
+  const res = await api.del(
+    `/api/${api.guid}/records/${table}/${id2}${opts.purge ? "?purge=1" : ""}`
+  );
+  const data = res?.data ?? { table, id: id2, deleted: true, purged: !!opts.purge };
+  printResult(
+    data.purged ? "Purged - the row and its audit history are gone." : `Deleted. If "${table}" declares a soft-delete column the row is only stamped deleted (see it with \`gipity records query ${table} --only-deleted\`, bring it back with \`gipity records restore ${table} ${id2}\`, remove it for good with \`--purge\`).`,
+    opts,
+    data
+  );
+}));
+recordsCommand.command("restore <table> <id>").description("Un-delete a soft-deleted record (owner/editor)").option("--json", "Output as JSON").action((table, id2, opts) => run("Restore", async () => {
+  const api = await recordsHttp(opts);
+  const res = await api.post(`/api/${api.guid}/records/${table}/${id2}/restore`);
+  printResult("Restored.", opts, res?.data ?? { table, id: id2, restored: true });
 }));
 
 // src/commands/fn.ts
@@ -41398,17 +41986,11 @@ ${error(`error: ${log3.error_message}`)}`;
     return line;
   });
 }));
-async function callAnon(projectGuid, name, body) {
-  let appToken;
-  try {
-    const minted = await publicPost("/api/token", { app: projectGuid });
-    appToken = minted.data.token;
-  } catch {
-  }
+async function callAnon(projectGuid2, name, body) {
   return publicPost(
-    `/api/${projectGuid}/fn/${encodeURIComponent(name)}`,
+    `/api/${projectGuid2}/fn/${encodeURIComponent(name)}`,
     body,
-    appToken ? { "X-App-Token": appToken } : void 0
+    await mintAppToken(projectGuid2)
   );
 }
 fnCommand.command("call <name> [body]").description("Call a function").option("-d, --data <json>", "JSON request body: inline JSON, @file to read a file, or @- / - for stdin").option("--file <field=@path>", "Attach a file as { data, media_type } under <field> (the vision/media service shape), repeatable, e.g. --file image=@receipt.png", (v7, acc) => (acc || []).concat(v7)).option("--anon", "Call as an anonymous visitor (the public path a signed-out user hits) instead of as your signed-in account").option("--field <path>", "Print only this field of the result (dot path, e.g. items.0.short_guid)").option("--json", "Output as JSON").action((name, bodyArg, opts) => run("Call", async () => {
@@ -41446,6 +42028,7 @@ fnCommand.command("delete <name>").alias("rm").description("Delete a function").
 
 // src/commands/service.ts
 init_api();
+init_auth();
 init_config();
 init_colors();
 var SERVICES = [
@@ -41471,16 +42054,59 @@ serviceCommand.command("list").description("List callable app services").option(
   const width = SERVICES.reduce((m, s) => Math.max(m, s.name.length), 0);
   console.log('Call one with `gipity service call <name> \'{"json":"body"}\'`');
   console.log(muted("(GET endpoints like llm/models, tts/voices take --get and no body)"));
+  console.log(muted("Verifying what a signed-out visitor of your deployed app gets? Add --anon."));
   console.log("");
   for (const s of SERVICES) {
     console.log(`${bold(s.name.padEnd(width))}  ${muted(`[${s.method}] ${s.desc}`)}`);
   }
 }));
-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 () => {
+function anonBillingHint(name, err) {
+  if (!(err instanceof ApiError) || err.statusCode !== 401) return null;
+  if (err.code !== "LOGIN_REQUIRED") return null;
+  const service = name.split("/")[0];
+  return `An anonymous visitor cannot call '${service}': it is on the user_pays default, so every signed-out visitor to a public page is asked to sign in and pay from their own credits. If this app serves the public (a help bubble, a landing page), switch it to owner-pays in gipity.yaml and redeploy:
+  deploy:
+    phases:
+      - services
+  service_definitions:
+    - service: ${service}
+      billing_mode: owner_pays
+  gipity deploy dev --only services`;
+}
+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; --anon calls it as a signed-out visitor instead.").option("-d, --data <json>", "JSON request body: inline JSON, @file to read a file, or @- / - for stdin (alternative to the positional [body])").option("--file <field=@path>", "Attach a file as { data, media_type } under <field> (the vision/media shape these services expect), repeatable, e.g. --file image=@receipt.png", (v7, acc) => (acc || []).concat(v7)).option("--anon", "Call as an anonymous visitor (the public path a signed-out user of your deployed app hits) instead of as your signed-in account").option("--get", "Issue a GET (for listing endpoints like llm/models, tts/voices)").option("--field <path>", "Print only this field of the result (dot path, e.g. choices.0.message.content)").option("--json", "Output compact JSON").action((name, bodyArg, opts) => run("Call", async () => {
   const config = requireConfig();
   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 || "{}"));
+  const body = resolveBody(bodyArg || opts.data, opts.file);
+  if (opts.anon) {
+    console.error(muted("Auth: anonymous visitor (the public path a signed-out user of your deployed app hits)"));
+  } else {
+    const who = getAuth()?.email;
+    console.error(muted(`Auth: calling as ${who ?? "your signed-in account"} (the owner persona - always billed to you and never blocked by billing_mode; use --anon for the public visitor path)`));
+  }
+  let res;
+  try {
+    if (opts.anon) {
+      const headers = await mintAppToken(config.projectGuid);
+      if (!headers) {
+        throw new Error(
+          `Could not mint a visitor token for this project, so there is no anonymous path to call. That means the app is not deployed on this API base yet: run \`gipity deploy dev\` first, then re-run this command.`
+        );
+      }
+      res = await publicRequest(opts.get ? "GET" : "POST", url, opts.get ? void 0 : body, headers);
+    } else {
+      res = opts.get ? await get(url) : await post(url, body);
+    }
+  } catch (err) {
+    const hint = opts.anon ? anonBillingHint(name, err) : null;
+    if (!hint) throw err;
+    throw new Error(`${err.message}
+${hint}`);
+  }
+  if (opts.field) {
+    emitField(res, opts.field);
+    return;
+  }
   console.log(opts.json ? JSON.stringify(res) : JSON.stringify(res, null, 2));
 }));
 
@@ -42845,7 +43471,7 @@ function undeployedFunctionsFromFailures(results) {
   return [...names];
 }
 var LONG_RUN_MS = 6e4;
-async function pollTestStatus(projectGuid, runGuid, opts) {
+async function pollTestStatus(projectGuid2, runGuid, opts) {
   const startTime = Date.now();
   const getPollInterval = () => {
     const elapsed = Date.now() - startTime;
@@ -42867,7 +43493,7 @@ async function pollTestStatus(projectGuid, runGuid, opts) {
     if (Date.now() - startTime > POLL_HARD_CAP_MS) {
       throw new Error(`Test run ${runGuid} still not finished after ${Math.round(POLL_HARD_CAP_MS / 6e4)} minutes - giving up on the poll. Check it later with \`gipity test status ${runGuid}\` or re-run.`);
     }
-    const res = await get(`/projects/${projectGuid}/test/status/${runGuid}`);
+    const res = await get(`/projects/${projectGuid2}/test/status/${runGuid}`);
     const data = res.data;
     if (!opts.json && data.results.length > lastResultCount) {
       const newResults = data.results.slice(lastResultCount);
@@ -44388,10 +45014,11 @@ async function collectDiagnostics() {
       return [];
     }
   })();
-  const [claude, codex, grok, cursor, gpu] = await Promise.all([
+  const [claude, codex, grok, agy, cursor, gpu] = await Promise.all([
     probeVersion("claude"),
     probeVersion("codex"),
     probeVersion("grok"),
+    probeVersion("agy"),
     probeVersion("cursor"),
     detectGpu()
   ]);
@@ -44399,6 +45026,7 @@ async function collectDiagnostics() {
   if (claude) agents.claude_code = claude;
   if (codex) agents.codex = codex;
   if (grok) agents.grok = grok;
+  if (agy) agents.agy = agy;
   if (cursor) agents.cursor = cursor;
   return {
     collected_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -46619,6 +47247,16 @@ var uninstallCommand = new Command("uninstall").description("Uninstall Gipity").
     }
     console.log(`${success(`Removed ${agentSkills.skills.length} Gipity skills from ~/.agents/skills.`)}`);
   }
+  const agySkills = agySkillsState();
+  if (agySkills.skills.length) {
+    for (const name of agySkills.skills) {
+      try {
+        rmSync4(join25(AGY_SKILLS_DIR, name), { recursive: true, force: true });
+      } catch {
+      }
+    }
+    console.log(`${success(`Removed ${agySkills.skills.length} Gipity skills from ~/.gemini/config/skills.`)}`);
+  }
   if (existsSync23(gipityDir)) {
     try {
       rmSync4(gipityDir, { recursive: true, force: true });
@@ -47238,8 +47876,8 @@ function configureHelp(cmd) {
 var program2 = new Command();
 program2.enablePositionalOptions();
 var startGroup = [statusCommand, initCommand, skillCommand, projectCommand];
-var buildGroup = [addCommand, removeCommand, saveCommand, loadCommand, deployCommand, pageCommand, testCommand];
-var backendGroup = [dbCommand, fnCommand, secretsCommand, logsCommand, jobCommand, workflowCommand];
+var buildGroup = [addCommand, removeCommand, brandCommand, saveCommand, loadCommand, deployCommand, pageCommand, testCommand];
+var backendGroup = [dbCommand, fnCommand, secretsCommand, keyCommand, logsCommand, jobCommand, workflowCommand];
 var servicesGroup = [serviceCommand, generateCommand, notifyCommand, paymentsCommand, realtimeCommand, recordsCommand, rbacCommand, auditCommand, domainCommand, tokenCommand];
 var filesGroup = [syncCommand, fileCommand, pushCommand, uploadCommand, storageCommand];
 var gipGroup = [chatCommand, memoryCommand, agentCommand, approvalCommand, gmailCommand];
@@ -47256,6 +47894,7 @@ var HELP_SECTIONS = [
   { title: "Connect & setup", cmds: connectGroup }
 ];
 var SKILL_DOCS = {
+  brand: "web-app-basics",
   save: "app-import",
   load: "app-import",
   github: "app-import",
@@ -47268,6 +47907,7 @@ var SKILL_DOCS = {
   notify: "app-notify",
   payments: "app-payments",
   records: "app-records",
+  key: "app-auth",
   realtime: "app-realtime",
   job: "jobs",
   sandbox: "sandbox-tools",