gipity 1.1.5 → 1.1.6

package/dist/index.js

@@ -6597,6 +6597,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 +6646,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 +6908,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 +6922,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 +32091,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.
@@ -32513,7 +32529,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 +32539,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 +32561,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 +32643,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 +32669,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 +32686,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 +32886,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 +32899,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 +32927,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 +32938,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 +33010,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 +33227,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 +33357,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 +33445,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 +33507,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 +33530,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 +33763,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 +34570,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 +34620,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 +34732,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 +34821,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 +34918,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 +35306,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 +35434,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 {
@@ -35490,13 +35772,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 +35793,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 +35812,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 +35937,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,7 +36003,7 @@ 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".`
@@ -35797,23 +36087,23 @@ 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);
   try {
     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 +36141,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 +36173,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;
@@ -35918,7 +36213,7 @@ ${bold("After reload")} ${muted("(page reloaded in place \u2014 storage preserve
   } finally {
     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}`));
       }
@@ -36217,14 +36512,14 @@ var pageScreenshotCommand = new Command("screenshot").description("Screenshot a
   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 +36550,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}`));
       }
@@ -36757,10 +37052,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}`);
@@ -39240,11 +39535,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 +39653,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 +40250,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(", ")})`)}` : "";
@@ -40490,6 +40827,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();
@@ -41262,10 +41680,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 +41736,16 @@ 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").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(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.filter) params.set("filter", opts.filter);
   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}`
+  const res = await api.get(
+    `/api/${api.guid}/records/${table}?${params}`
   );
   if (opts.json) {
     console.log(JSON.stringify(res));
@@ -41319,41 +41758,42 @@ 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 () => {
+recordsCommand.command("delete <table> <id>").description("Delete a record").option(ANON_FLAG, ANON_HELP).option("--json", "Output as JSON").action((table, id2, opts) => run("Delete", async () => {
   if (!await confirm(`Delete record ${id2} from "${table}"?`)) {
-    console.log("Cancelled.");
+    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}`);
+  printResult("Deleted.", opts, res?.data ?? { table, id: id2, deleted: true });
 }));
 
 // src/commands/fn.ts
@@ -41398,17 +41838,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 () => {
@@ -42845,7 +43279,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 +43301,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 +44822,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 +44834,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 +47055,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 +47684,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 +47702,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 +47715,7 @@ var SKILL_DOCS = {
   notify: "app-notify",
   payments: "app-payments",
   records: "app-records",
+  key: "app-auth",
   realtime: "app-realtime",
   job: "jobs",
   sandbox: "sandbox-tools",