gipity 1.0.429 → 1.1.1

package/dist/index.js

@@ -3944,10 +3944,10 @@ function prompt(question) {
     return Promise.reject(new Error(`prompt() called without a TTY: ${question.trim()}`));
   }
   const rl2 = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     rl2.question(question, (answer) => {
       rl2.close();
-      resolve19(answer.trim());
+      resolve20(answer.trim());
     });
   });
 }
@@ -3977,7 +3977,7 @@ async function confirm(question, opts = {}) {
   const wasRaw = stdin.isRaw ?? false;
   stdin.setRawMode(true);
   stdin.resume();
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     stdin.once("data", (key) => {
       stdin.setRawMode(wasRaw);
       stdin.pause();
@@ -3992,12 +3992,12 @@ async function confirm(question, opts = {}) {
       else if (k7 === "n") answer = false;
       else answer = defaultYes;
       console.log(answer ? "y" : "n");
-      resolve19(answer);
+      resolve20(answer);
     });
   });
 }
 function pickOne(label2, max, defaultIdx = 1) {
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     process.stdout.write(`  ${bold(label2)} (1-${max}) [${bold(String(defaultIdx))}]: `);
     const { stdin } = process;
     const wasRaw = stdin.isRaw ?? false;
@@ -4013,15 +4013,15 @@ function pickOne(label2, max, defaultIdx = 1) {
       }
       if (ch === "\r" || ch === "\n") {
         console.log(String(defaultIdx));
-        return resolve19(defaultIdx);
+        return resolve20(defaultIdx);
       }
       const n = parseInt(ch, 10);
       if (n >= 1 && n <= max) {
         console.log(String(n));
-        return resolve19(n);
+        return resolve20(n);
       }
       console.log(String(defaultIdx));
-      resolve19(defaultIdx);
+      resolve20(defaultIdx);
     });
   });
 }
@@ -5370,8 +5370,8 @@ var require_streamx = __commonJS({
             return this;
           },
           next() {
-            return new Promise(function(resolve19, reject) {
-              promiseResolve = resolve19;
+            return new Promise(function(resolve20, reject) {
+              promiseResolve = resolve20;
               promiseReject = reject;
               const data = stream.read();
               if (data !== null) ondata(data);
@@ -5401,11 +5401,11 @@ var require_streamx = __commonJS({
         }
         function destroy(err) {
           stream.destroy(err);
-          return new Promise((resolve19, reject) => {
-            if (stream._duplexState & DESTROYED) return resolve19({ value: void 0, done: true });
+          return new Promise((resolve20, reject) => {
+            if (stream._duplexState & DESTROYED) return resolve20({ value: void 0, done: true });
             stream.once("close", function() {
               if (err) reject(err);
-              else resolve19({ value: void 0, done: true });
+              else resolve20({ value: void 0, done: true });
             });
           });
         }
@@ -5449,8 +5449,8 @@ var require_streamx = __commonJS({
         const writes = pending + (ws2._duplexState & WRITE_WRITING ? 1 : 0);
         if (writes === 0) return Promise.resolve(true);
         if (state.drains === null) state.drains = [];
-        return new Promise((resolve19) => {
-          state.drains.push({ writes, resolve: resolve19 });
+        return new Promise((resolve20) => {
+          state.drains.push({ writes, resolve: resolve20 });
         });
       }
       write(data) {
@@ -5555,10 +5555,10 @@ var require_streamx = __commonJS({
       cb2(null);
     }
     function pipelinePromise(...streams) {
-      return new Promise((resolve19, reject) => {
+      return new Promise((resolve20, reject) => {
         return pipeline(...streams, (err) => {
           if (err) return reject(err);
-          resolve19();
+          resolve20();
         });
       });
     }
@@ -6213,16 +6213,16 @@ var require_extract = __commonJS({
           entryCallback = null;
           cb2(err);
         }
-        function onnext(resolve19, reject) {
+        function onnext(resolve20, reject) {
           if (error2) {
             return reject(error2);
           }
           if (entryStream) {
-            resolve19({ value: entryStream, done: false });
+            resolve20({ value: entryStream, done: false });
             entryStream = null;
             return;
           }
-          promiseResolve = resolve19;
+          promiseResolve = resolve20;
           promiseReject = reject;
           consumeCallback(null);
           if (extract3._finished && promiseResolve) {
@@ -6250,11 +6250,11 @@ var require_extract = __commonJS({
         function destroy(err) {
           extract3.destroy(err);
           consumeCallback(err);
-          return new Promise((resolve19, reject) => {
-            if (extract3.destroyed) return resolve19({ value: void 0, done: true });
+          return new Promise((resolve20, reject) => {
+            if (extract3.destroyed) return resolve20({ value: void 0, done: true });
             extract3.once("close", function() {
               if (err) reject(err);
-              else resolve19({ value: void 0, done: true });
+              else resolve20({ value: void 0, done: true });
             });
           });
         }
@@ -6560,6 +6560,7 @@ function detectHarness() {
     return { harness: "claude-code", harnessVersion: version, harnessSession: process.env.CLAUDE_CODE_SESSION_ID };
   }
   if (hasEnvPrefix("CODEX_")) return { harness: "codex" };
+  if (hasEnvPrefix("GROK_")) return { harness: "grok", harnessSession: process.env.GROK_SESSION_ID };
   if (process.env.CURSOR_TRACE_ID || hasEnvPrefix("CURSOR_") || (process.env.TERM_PROGRAM ?? "").toLowerCase().includes("cursor")) {
     return { harness: "cursor" };
   }
@@ -6705,7 +6706,7 @@ async function postForTarEntries(path5, body, retried = false) {
   if (!res.body) throw new ApiError(500, "EMPTY_RESPONSE", "Server returned no body");
   const extract3 = tar.extract();
   const entries = [];
-  const done = new Promise((resolve19, reject) => {
+  const done = new Promise((resolve20, reject) => {
     extract3.on("entry", (header, stream, next) => {
       const chunks = [];
       stream.on("data", (c) => chunks.push(c));
@@ -6716,7 +6717,7 @@ async function postForTarEntries(path5, body, retried = false) {
       stream.on("error", reject);
       stream.resume();
     });
-    extract3.on("finish", () => resolve19());
+    extract3.on("finish", () => resolve20());
     extract3.on("error", reject);
   });
   Readable.fromWeb(res.body).pipe(extract3);
@@ -6741,6 +6742,9 @@ async function sendMessage(message) {
   if (res.data.conversationGuid !== config.conversationGuid) {
     saveConfig({ ...config, conversationGuid: res.data.conversationGuid });
   }
+  if (res.data.costWarning && !res.data.content) {
+    return res.data.costWarning.message;
+  }
   return res.data.content;
 }
 async function download(path5, retried = false) {
@@ -31858,9 +31862,9 @@ var {
 // src/index.ts
 init_config();
 init_utils();
-import { readFileSync as readFileSync25 } from "fs";
+import { readFileSync as readFileSync26 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname13, resolve as resolve18 } from "path";
+import { dirname as dirname13, resolve as resolve19 } from "path";
 
 // src/helpers/output.ts
 var frameOpen = false;
@@ -31982,7 +31986,7 @@ Prefer the cheapest option that works - CLI and sandbox are instant and free, ap
 3. App services - runtime HTTP endpoints your deployed app calls directly at \`https://a.gipity.ai/api/<PROJECT_GUID>/services/*\`. Available: LLM, TTS, image, sound, music, transcribe, video, file upload, realtime, location, push notifications (Gipity Notify - \`gipity add notify\`, send from a function with the injected \`notify()\`; see \`app-notify\`). Load the matching skill (\`app-llm\`, \`app-tts\`, etc.) before writing service code - they have the schemas, auth pattern, and common-mistake guards. For one-off generation during development, prefer \`gipity generate <image|video|speech|sound|music>\` or \`gipity chat\` - direct generation always bills you (the owner), regardless of any service \`billing_mode\` (that setting only governs the deployed app's runtime calls; never flip it just to create assets). \`gipity generate\` saves to a generic file in the current directory by default (e.g. \`./generated.png\`) - pass \`-o <path>\` to write it straight into your source tree so it deploys (e.g. \`gipity generate image "hero banner" -o src/assets/images/hero.png\`) instead of generating at cwd and moving it.
 4. Delegate to Gip (\`gipity chat "<task>"\`) - only when the work genuinely needs agent reasoning or a tool not in the CLI, sandbox, or app services. Required for: Twitter/X search, Gmail, calendar, push notifications, video understanding, audio source isolation, cross-model second opinions, multi-step orchestration. Don't use \`gipity chat\` for anything the sandbox can do - it's slower and burns tokens.
 
-You are the developer. Write files in this directory - the Gipity Claude Code plugin's hooks auto-sync them to Gipity. Don't run \`npm install\`, \`npm start\`, \`node\`, or \`python\` locally; there is no local runtime. Code runs in the Gipity sandbox.
+You are the developer. Write files in this directory - Gipity's editor hooks (installed by \`gipity init\` into Claude Code, Grok, and Codex) auto-sync them to Gipity. Don't run \`npm install\`, \`npm start\`, \`node\`, or \`python\` locally; there is no local runtime. Code runs in the Gipity sandbox.
 
 ## Use first-party services before reaching outside
 
@@ -32018,7 +32022,7 @@ The full "when to add a template" rule and the definition of done are spelled ou
 
 Build loop: \`gipity add\` \u2192 edit files \u2192 \`gipity deploy dev --inspect\` \u2192 fix any errors \u2192 repeat until the definition of done is met. \`deploy --inspect\` deploys and then runs the page-inspect report on the live URL in one command; use a standalone \`gipity page inspect <url>\` only when re-checking without deploying.
 
-\`add\` writes real files to disk - Read a scaffolded file before your first Write/Edit to it, or the call fails \`"File has not been read yet"\`. Don't rewrite from memory of the template.
+\`add\` writes real files to disk - Read a scaffolded file with the Read tool before your first Write/Edit to it, or the call fails \`"File has not been read yet"\` (viewing it with \`cat\`/\`head\` in Bash does not count - the harness only tracks the Read tool). Don't rewrite from memory of the template.
 
 Make your file changes and verify they landed, then run \`gipity deploy dev\` once. \`0 uploaded, N unchanged\` means nothing changed on disk - fix the files, don't re-run deploy or probe the environment.
 
@@ -32074,7 +32078,7 @@ Every tool call returns its full output with that call. There is no output buffe
 
 This directory is the app root - it holds \`.gipity.json\` (and \`gipity.yaml\` for backends) and is already your cwd, so run app commands here. Don't \`cd\` to a git root (\`git rev-parse --show-toplevel\`): when the app is nested in a larger repo that resolves outside the app.
 
-Write files locally - the Gipity Claude Code plugin's hooks auto-push every save to Gipity and auto-pull remote changes (images, audio from \`gipity chat\`) before each turn. Use \`gipity sync\` if things get out of sync (or if the plugin isn't installed - \`gipity status --repair-hooks\` re-enables it). Deletes are safe - use \`rollback\` with a datetime to undo, or \`file_version_restore\` for individual files.
+Write files locally - Gipity's editor hooks (installed into Claude Code, Grok, and Codex by \`gipity init\`) auto-push every save to Gipity and auto-pull remote changes (images, audio from \`gipity chat\`) before each turn. Use \`gipity sync\` if things get out of sync (or if the hooks aren't installed - \`gipity status --repair-hooks\` re-enables them). Deletes are safe - use \`rollback\` with a datetime to undo, or \`file_version_restore\` for individual files.
 
 To keep local-only material (research clones, scratch data, vendored references) in the project directory without syncing or deploying it, list it in a \`.gipityignore\` at the project root - gitignore-style, one pattern per line, \`#\` comments. Ignored paths are invisible to sync in both directions; anything that already synced before being ignored stays on the server until you delete it.
 
@@ -32290,7 +32294,7 @@ function run(label2, action) {
 init_api();
 init_config();
 init_utils();
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, existsSync as existsSync5, statSync, lstatSync, unlinkSync as unlinkSync3, readdirSync as readdirSync2, rmdirSync, readFileSync as readFileSync6, renameSync, openSync as openSync2, closeSync as closeSync2, utimesSync, realpathSync } from "fs";
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, existsSync as existsSync5, statSync, lstatSync, unlinkSync as unlinkSync3, readdirSync as readdirSync3, rmdirSync, readFileSync as readFileSync6, renameSync, openSync as openSync2, closeSync as closeSync2, utimesSync, realpathSync } from "fs";
 import { join as join4, relative, dirname as dirname4, extname as extname2, resolve as resolve4, sep } from "path";
 import { hostname } from "os";
 import { createHash as createHash2 } from "crypto";
@@ -32354,25 +32358,25 @@ async function hashFile(path5) {
   const hash = createHash("sha256");
   let size = 0;
   const stream = createReadStream(path5);
-  await new Promise((resolve19, reject) => {
+  await new Promise((resolve20, reject) => {
     stream.on("data", (chunk) => {
       const buf = chunk;
       hash.update(buf);
       size += buf.length;
     });
-    stream.on("end", () => resolve19());
+    stream.on("end", () => resolve20());
     stream.on("error", reject);
   });
   return { sha256: hash.digest("hex"), size };
 }
 function readRange(path5, start, end) {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     const chunks = [];
     const stream = createReadStream(path5, { start, end });
     stream.on("data", (c) => {
       chunks.push(c);
     });
-    stream.on("end", () => resolve19(Buffer.concat(chunks)));
+    stream.on("end", () => resolve20(Buffer.concat(chunks)));
     stream.on("error", reject);
   });
 }
@@ -32536,11 +32540,14 @@ async function uploadCompleteBatch(projectGuid, items) {
 // src/setup.ts
 init_platform();
 import { resolve as resolve3, join as join3, dirname as dirname3 } from "path";
-import { homedir as homedir3 } from "os";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir3, tmpdir } from "os";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, readFileSync as readFileSync5, mkdtempSync, rmSync, cpSync, readdirSync as readdirSync2 } from "fs";
+init_config();
 var PRIMER_FILES = {
   claude: "CLAUDE.md",
   codex: "AGENTS.md",
+  grok: "AGENTS.md",
+  // Grok Build reads the AGENTS.md family (and CLAUDE.md) natively
   aider: "AGENTS.md",
   // shares the Codex primer; aider is pointed at it via .aider.conf.yml
   gemini: "GEMINI.md",
@@ -32555,6 +32562,7 @@ var DEFAULT_SYNC_IGNORE = [
   ".gipity.json",
   ".gipity/",
   ".claude/",
+  ".codex/",
   ".gitignore",
   AIDER_CONF_FILE,
   // Home-directory junk: a project created inside a real home dir (or one that
@@ -32615,7 +32623,7 @@ var GIPITY_PLUGIN_ID = "gipity@gipity";
 var GIPITY_MARKETPLACE_NAME = "gipity";
 var GIPITY_MARKETPLACE_REPO = "GipityAI/skills";
 var LEGACY_MARKETPLACE_REPO = "GipityAI/claude-plugin";
-var GIPITY_PLUGIN_VERSION = "0.5.0";
+var GIPITY_PLUGIN_VERSION = "0.7.0";
 function isGipityManagedHookCommand(command) {
   return (
     // Capture hooks: bare absolute runner path or the fire-time launcher.
@@ -32702,8 +32710,8 @@ function userScopeInstallState() {
     return { exists: false, current: false };
   }
 }
-function claudeOnPath() {
-  const probe = spawnSyncCommand(process.platform === "win32" ? "where" : "which", ["claude"], {
+function binaryOnPath(bin) {
+  const probe = spawnSyncCommand(process.platform === "win32" ? "where" : "which", [bin], {
     encoding: "utf-8"
   });
   return probe.status === 0 && !!probe.stdout?.toString().trim();
@@ -32711,7 +32719,7 @@ function claudeOnPath() {
 function ensureGipityPluginInstalled() {
   const state = userScopeInstallState();
   if (state.current) return;
-  if (!claudeOnPath()) return;
+  if (!binaryOnPath("claude")) return;
   const claudeCmd = resolveCommand("claude");
   spawnSyncCommand(claudeCmd, ["plugin", "marketplace", "update", GIPITY_MARKETPLACE_NAME], {
     stdio: "ignore",
@@ -32723,6 +32731,146 @@ function ensureGipityPluginInstalled() {
     timeout: 12e4
   });
 }
+function grokInstallState() {
+  try {
+    const p = join3(homedir3(), ".grok", "installed-plugins", "registry.json");
+    const data = JSON.parse(readFileSync5(p, "utf-8"));
+    const versions = [];
+    for (const repo of Object.values(data?.repos ?? {})) {
+      const v7 = repo?.plugins?.gipity?.version;
+      if (typeof v7 === "string") versions.push(v7);
+    }
+    return {
+      exists: versions.length > 0,
+      current: versions.some((v7) => versionGte(v7, GIPITY_PLUGIN_VERSION))
+    };
+  } catch {
+    return { exists: false, current: false };
+  }
+}
+function ensureGrokPluginInstalled() {
+  const state = grokInstallState();
+  if (state.current) return;
+  if (!binaryOnPath("grok")) return;
+  const grokCmd = resolveCommand("grok");
+  const verb = state.exists ? ["plugin", "update", "gipity"] : ["plugin", "install", GIPITY_MARKETPLACE_REPO, "--trust"];
+  const res = spawnSyncCommand(grokCmd, verb, { stdio: "ignore", timeout: 12e4 });
+  if (!state.exists && res.status === 0) {
+    console.log("Installed the Gipity plugin for Grok (skills + file-sync hooks).");
+  }
+}
+var AGENTS_SKILLS_DIR = join3(homedir3(), ".agents", "skills");
+var AGENT_HOOKS_DIR = join3(homedir3(), ".gipity", "agent-hooks");
+var AGENT_SKILLS_MANIFEST = join3(homedir3(), ".gipity", "agent-skills.json");
+function agentSkillsState() {
+  try {
+    const m = JSON.parse(readFileSync5(AGENT_SKILLS_MANIFEST, "utf-8"));
+    return {
+      current: typeof m?.version === "string" && versionGte(m.version, GIPITY_PLUGIN_VERSION),
+      skills: Array.isArray(m?.skills) ? m.skills : []
+    };
+  } catch {
+    return { current: false, skills: [] };
+  }
+}
+function ensureAgentSkillsInstalled() {
+  if (agentSkillsState().current) return;
+  if (!binaryOnPath("git")) return;
+  const tmp = mkdtempSync(join3(tmpdir(), "gipity-skills-"));
+  try {
+    const clone = spawnSyncCommand(
+      resolveCommand("git"),
+      ["clone", "--depth", "1", `https://github.com/${GIPITY_MARKETPLACE_REPO}.git`, join3(tmp, "repo")],
+      { stdio: "ignore", timeout: 12e4 }
+    );
+    if (clone.status !== 0) return;
+    const repo = join3(tmp, "repo");
+    let version = GIPITY_PLUGIN_VERSION;
+    try {
+      const manifest = JSON.parse(readFileSync5(join3(repo, ".claude-plugin", "plugin.json"), "utf-8"));
+      if (typeof manifest?.version === "string") version = manifest.version;
+    } catch {
+    }
+    const skillsSrc = join3(repo, "skills");
+    const names = [];
+    for (const entry of readdirSync2(skillsSrc, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (!existsSync4(join3(skillsSrc, entry.name, "SKILL.md"))) continue;
+      mkdirSync3(AGENTS_SKILLS_DIR, { recursive: true });
+      cpSync(join3(skillsSrc, entry.name), join3(AGENTS_SKILLS_DIR, entry.name), {
+        recursive: true,
+        force: true
+      });
+      names.push(entry.name);
+    }
+    mkdirSync3(AGENT_HOOKS_DIR, { recursive: true });
+    for (const script of readdirSync2(join3(repo, "hooks", "scripts"))) {
+      cpSync(join3(repo, "hooks", "scripts", script), join3(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).`);
+  } catch {
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+function applyCodexHooks(existing) {
+  const launcher = join3(AGENT_HOOKS_DIR, "launch.sh");
+  const cmd = (script, ...args) => [`sh "${launcher}" "${join3(AGENT_HOOKS_DIR, script)}"`, ...args].join(" ");
+  const wanted = [
+    { event: "PostToolUse", matcher: "Edit|Write", command: cmd("sync-push.cjs"), timeout: 30 },
+    { event: "UserPromptSubmit", command: cmd("sync-pull.cjs"), timeout: 300 },
+    // Session capture: mirror the Codex session into the Gipity web CLI.
+    { event: "SessionStart", command: cmd("capture.cjs", "codex", "session-start"), timeout: 30 },
+    { event: "PostToolUse", command: cmd("capture.cjs", "codex", "post-tool-use"), timeout: 30 },
+    { event: "Stop", command: cmd("capture.cjs", "codex", "stop"), timeout: 60 }
+  ];
+  let settings = {};
+  if (existing !== null) {
+    try {
+      settings = JSON.parse(existing);
+    } catch {
+      return null;
+    }
+  }
+  const hooks = settings.hooks ?? (settings.hooks = {});
+  let changed = false;
+  for (const w of wanted) {
+    const groups = Array.isArray(hooks[w.event]) ? hooks[w.event] : hooks[w.event] = [];
+    const present = groups.some(
+      (g) => Array.isArray(g?.hooks) && g.hooks.some(
+        (h) => typeof h?.command === "string" && h.command === w.command
+      )
+    );
+    if (present) continue;
+    const group = { hooks: [{ type: "command", command: w.command, timeout: w.timeout }] };
+    if (w.matcher) group.matcher = w.matcher;
+    groups.push(group);
+    changed = true;
+  }
+  return changed ? JSON.stringify(settings, null, 2) + "\n" : null;
+}
+function setupCodexHooks() {
+  if (process.platform === "win32") return;
+  const cwd = resolve3(process.cwd());
+  if (cwd === resolve3(homedir3())) return;
+  const path5 = join3(cwd, ".codex", "hooks.json");
+  const existing = existsSync4(path5) ? readFileSync5(path5, "utf-8") : null;
+  const next = applyCodexHooks(existing);
+  if (next === null) return;
+  mkdirSync3(dirname3(path5), { recursive: true });
+  writeFileSync4(path5, next);
+  if (existing === null) {
+    console.log("Wrote Codex sync + session-capture hooks (.codex/hooks.json) - approve them once with /hooks inside Codex.");
+  } else {
+    console.log("Updated Codex hooks (.codex/hooks.json) - if Codex asks, re-approve them via /hooks.");
+  }
+}
+function setupCodexIntegration() {
+  if (!binaryOnPath("codex")) return;
+  ensureAgentSkillsInstalled();
+  setupCodexHooks();
+}
 function setupClaudeHooks() {
   ensureGipityPlugin();
   const cwd = resolve3(process.cwd());
@@ -32744,14 +32892,21 @@ function setupClaudeHooks() {
 }
 var GIPITY_BLOCK_BEGIN = "<!-- BEGIN GIPITY INTEGRATION - auto-generated by gipity, do not edit this block -->";
 var GIPITY_BLOCK_END = "<!-- END GIPITY INTEGRATION -->";
-function renderManagedBlock() {
-  const body = [SKILLS_CONTENT, BUILD_VS_NON_BUILD_RULE, DEFINITION_OF_DONE].join("\n\n");
+function renderManagedBlock(apiBase2) {
+  let body = [SKILLS_CONTENT, BUILD_VS_NON_BUILD_RULE, DEFINITION_OF_DONE].join("\n\n");
+  const base = apiBase2.replace(/\/+$/, "");
+  if (base !== DEFAULT_API_BASE) {
+    body = body.replaceAll(DEFAULT_API_BASE, base);
+    const note = `> **Platform instance:** this project runs against the Gipity platform at \`${base}\`, not the public \`${DEFAULT_API_BASE}\`. The project and its data exist only on that instance; every API/service URL in this document already points there - never substitute \`a.gipity.ai\`.`;
+    const headingEnd = body.indexOf("\n");
+    body = body.slice(0, headingEnd + 1) + "\n" + note + "\n" + body.slice(headingEnd + 1);
+  }
   return `${GIPITY_BLOCK_BEGIN}
 ${body}
 ${GIPITY_BLOCK_END}`;
 }
-function applySkillsBlock(existing) {
-  const block = renderManagedBlock();
+function applySkillsBlock(existing, apiBase2 = DEFAULT_API_BASE) {
+  const block = renderManagedBlock(apiBase2);
   if (existing === null) return block + "\n";
   let next;
   const beginIdx = existing.indexOf(GIPITY_BLOCK_BEGIN);
@@ -32770,7 +32925,7 @@ function writeSkillsFile(relPath, wrap) {
   const path5 = resolve3(process.cwd(), relPath);
   mkdirSync3(dirname3(path5), { recursive: true });
   const existing = existsSync4(path5) ? readFileSync5(path5, "utf-8") : null;
-  const baseNext = applySkillsBlock(existing);
+  const baseNext = applySkillsBlock(existing, resolveApiBase());
   const next = wrap && existing === null ? wrap(baseNext) : baseNext;
   if (next !== existing) writeFileSync4(path5, next);
 }
@@ -32834,14 +32989,22 @@ ${block}`
   );
 }
 var SUPPORTED_TOOLS = [
-  { key: "claude", label: "Claude Code (CLAUDE.md)", setup: setupClaudeMd },
-  { key: "codex", label: "OpenAI Codex (AGENTS.md)", setup: setupAgentsMd },
+  { 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: "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 },
   { key: "cursor", label: "Cursor (.cursor/rules/gipity.mdc)", setup: setupCursorMd }
 ];
 var DEFAULT_TOOLS = SUPPORTED_TOOLS.filter((t) => !t.optIn);
+function setupProjectTools(tools = DEFAULT_TOOLS) {
+  for (const t of tools) {
+    t.setup();
+    t.integrate?.();
+  }
+  setupGitignore();
+}
 function setupGitignore() {
   const gitignorePath = resolve3(process.cwd(), ".gitignore");
   const entries = [".gipity/", ".gipity.json", ...SCRATCH_IGNORE];
@@ -32986,7 +33149,7 @@ function walkLocal(root, ignorePatterns, baseline) {
   function walk(dir) {
     let entries;
     try {
-      entries = readdirSync2(dir, { withFileTypes: true });
+      entries = readdirSync3(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -33065,7 +33228,7 @@ async function fetchRemote(projectGuid) {
 function extractTarToMap(stream, idleMs, onBytes, keep) {
   const extract3 = tar2.extract();
   const files = /* @__PURE__ */ new Map();
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     let settled = false;
     let idle;
     const arm = () => {
@@ -33101,7 +33264,7 @@ function extractTarToMap(stream, idleMs, onBytes, keep) {
       });
       entryStream.resume();
     });
-    extract3.on("finish", () => done(resolve19, files));
+    extract3.on("finish", () => done(resolve20, files));
     extract3.on("error", (e) => done(reject, e));
     stream.on("error", (e) => done(reject, e));
     arm();
@@ -33860,7 +34023,7 @@ async function syncInner(projectGuid, root, ignore2, opts, interactive) {
 function cleanupEmptyDirs(root, emptiedDirs) {
   const isEmpty = (dir) => {
     try {
-      return readdirSync2(dir).length === 0;
+      return readdirSync3(dir).length === 0;
     } catch {
       return false;
     }
@@ -34144,7 +34307,7 @@ init_utils();
 
 // src/adopt-cwd.ts
 init_api();
-import { readdirSync as readdirSync4, statSync as statSync3 } from "fs";
+import { readdirSync as readdirSync5, statSync as statSync3 } from "fs";
 import { join as join8, resolve as resolve6, sep as sep2, parse as parsePath } from "path";
 import { homedir as homedir6 } from "os";
 
@@ -34152,7 +34315,7 @@ import { homedir as homedir6 } from "os";
 init_config();
 
 // src/template-vars.ts
-import { promises as fs, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { promises as fs, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
 import { join as join5, relative as relative2, extname as extname3 } from "path";
 var SUBSTITUTABLE_EXTS = /* @__PURE__ */ new Set([
   ".html",
@@ -34219,7 +34382,7 @@ function* walkTextFiles(root) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = readdirSync3(dir, { withFileTypes: true });
+      entries = readdirSync4(dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -34308,10 +34471,7 @@ async function finalizeLocalProject(opts) {
   } catch (err) {
     if (opts.sync === "strict") throw err;
   }
-  const tools = opts.tools ?? DEFAULT_TOOLS;
-  if (tools.some((t) => t.key === "claude")) setupClaudeHooks();
-  for (const t of tools) t.setup();
-  setupGitignore();
+  setupProjectTools(opts.tools ?? DEFAULT_TOOLS);
   return { applied };
 }
 
@@ -34490,7 +34650,7 @@ function scanForAdoption(cwd) {
     if (truncated) return;
     let entries;
     try {
-      entries = readdirSync4(dir);
+      entries = readdirSync5(dir);
     } catch {
       return;
     }
@@ -34526,7 +34686,7 @@ function scanForAdoption(cwd) {
 function isLikelyEmpty(cwd) {
   let entries;
   try {
-    entries = readdirSync4(cwd);
+    entries = readdirSync5(cwd);
   } catch {
     return true;
   }
@@ -34564,7 +34724,7 @@ function canAdoptCwd(cwd) {
 function countGitRepoChildren(dir) {
   let entries;
   try {
-    entries = readdirSync4(dir);
+    entries = readdirSync5(dir);
   } catch {
     return 0;
   }
@@ -34676,14 +34836,15 @@ 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.").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).").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", `
 Examples:
   $ gipity init                          Link cwd as a new project (slug = dir name).
   $ gipity init my-app                   Link cwd with an explicit slug.
-  $ gipity init --for codex              Write only AGENTS.md (skip Claude/Cursor/etc).
+  $ gipity init --for codex              AGENTS.md + Codex skills/sync hooks only.
+  $ gipity init --for grok               AGENTS.md + the Gipity plugin in Grok only.
   $ gipity init --for cursor,gemini      Write only the Cursor + Gemini primers.
   $ gipity init --for aider              AGENTS.md + a read: entry in .aider.conf.yml
                                          (aider auto-reads nothing, so it's opt-in).
@@ -34704,9 +34865,6 @@ Working with an existing Gipity project:
     process.exit(1);
   }
   const wantsClaude = tools.some((t) => t.key === "claude");
-  const writeAllPrimers = () => {
-    for (const t of tools) t.setup();
-  };
   const primerSummary = tools.map((t) => t.label).join(", ");
   try {
     const auth = getAuth();
@@ -34718,9 +34876,7 @@ Working with an existing Gipity project:
     if (existsSync8(resolve7(cwd, ".gipity.json"))) {
       const existing = getConfig();
       console.log(`Already linked to ${info(`"${existing?.projectSlug ?? ""}"`)} ${muted(`(${existing?.projectGuid ?? ""})`)}`);
-      if (wantsClaude) setupClaudeHooks();
-      writeAllPrimers();
-      setupGitignore();
+      setupProjectTools(tools);
       if (existing) {
         let changed = false;
         const cur = existing.ignore ?? (existing.ignore = []);
@@ -34769,7 +34925,7 @@ Working with an existing Gipity project:
       const sizeStr = scan.truncated ? `>${formatBytes(ADOPT_THRESHOLDS.REFUSE_BYTES)}` : formatBytes(scan.bytes);
       const fileStr = scan.truncated ? `>${ADOPT_THRESHOLDS.REFUSE_FILES}` : `${scan.files}`;
       console.error(error(`Directory has ${fileStr} files (${sizeStr}) - too large to adopt as a Gipity project.`));
-      console.error(muted('Move into a subdirectory, or use `gipity claude` and pick "Create new project".'));
+      console.error(muted('Move into a subdirectory, or use `gipity build` and pick "Create new project".'));
       process.exit(1);
     }
     if (scan.tier === "moderate") {
@@ -34808,7 +34964,7 @@ Working with an existing Gipity project:
     }
     console.log(success(`Wrote primer files: ${primerSummary}.`));
     if (wantsClaude) {
-      console.log(success("Ready! Run `gipity claude` for Claude Code, or open this directory in your other AI coding tool."));
+      console.log(success("Ready! Run your coding agent here (claude, codex, grok), 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 {
@@ -34983,7 +35139,7 @@ var pushCommand = new Command("push").description("Push one or more files").argu
 
 // src/commands/upload.ts
 init_config();
-import { statSync as statSync4, readdirSync as readdirSync5 } from "fs";
+import { statSync as statSync4, readdirSync as readdirSync6 } from "fs";
 import { join as join10, basename as basename2, posix, resolve as resolve10, dirname as dirname6 } from "path";
 init_utils();
 init_colors();
@@ -34992,7 +35148,7 @@ function walkFiles(root) {
   const stack = [root];
   while (stack.length) {
     const dir = stack.pop();
-    for (const entry of readdirSync5(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync6(dir, { withFileTypes: true })) {
       const full = join10(dir, entry.name);
       if (entry.isDirectory()) stack.push(full);
       else if (entry.isFile()) out.push(full);
@@ -35105,7 +35261,7 @@ init_config();
 // src/page-fixtures.ts
 init_api();
 init_config();
-import { readFileSync as readFileSync11, statSync as statSync5, existsSync as existsSync10, readdirSync as readdirSync6 } from "node:fs";
+import { readFileSync as readFileSync11, statSync as statSync5, existsSync as existsSync10, readdirSync as readdirSync7 } from "node:fs";
 import { basename as basename3, resolve as resolve11, relative as relative3, join as join11 } from "node:path";
 var FIND_SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", ".gipity", "dist", "build", ".next", "coverage"]);
 function findByBasename(root, name, limit = 3) {
@@ -35117,7 +35273,7 @@ function findByBasename(root, name, limit = 3) {
     visited++;
     let entries;
     try {
-      entries = readdirSync6(dir, { withFileTypes: true });
+      entries = readdirSync7(dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -35190,7 +35346,7 @@ async function uploadCameraFeed(projectGuid, localPath) {
 }
 
 // src/commands/page-eval.ts
-var EVAL_NO_VALUE_HINT = "The eval ran but returned no JSON-serializable value. A statement body with no `return`, an assignment, a void call, or a DOM node/function all serialize to null. End the script with an expression \u2014 or an explicit `return` \u2014 that yields plain data, e.g. `return { label: input.value, count: items.length }` or `return JSON.stringify(payload)`.";
+var EVAL_NO_VALUE_HINT = "The eval ran but returned no JSON-serializable value. A body ending in a loop/if-block, a `return` of undefined, or a DOM node/function all serialize to null. End the script with an expression \u2014 or an explicit `return` \u2014 that yields plain data, e.g. `return { label: input.value, count: items.length }` or `return JSON.stringify(payload)`.";
 function normalizeEvalResult(raw) {
   const trimmed = (raw ?? "").trim();
   if (trimmed === "" || trimmed === "null" || trimmed === "undefined") {
@@ -35350,8 +35506,8 @@ function evalExecTimeoutMessage(result, budgetMs) {
 ` + (budgetOverrunHint("in-page budget", budgetMs) ?? "") + `
 If the slow part is a ONE-TIME page init (a WASM/model download, a big asset, a first-frame pipeline warm-up), do NOT split the body across several 'page eval' calls \u2014 every call is a fresh page load that re-pays that init, so each one hits this same wall. Have the page kick it off on load (not behind a click) and absorb it in the pre-eval window instead.`;
 }
-var JS_DECOY_FLAGS = ["--js", "--javascript", "--script", "--code", "--expr", "--eval", "--exec"];
-var pageEvalCommand = new Command("eval").description("Evaluate JS in a real browser on a page (DOM, computed styles, element rects; inline expr or --file script). ONE client per call - to verify realtime/presence across concurrent clients use `page test --observe` instead").argument("<url>", "URL to load").argument("[expr]", `JavaScript to evaluate in page context (inline expression or statement body with return/await; result is JSON-serialized). Omit when using --file. Time budget: the body has ${EVAL_SCRIPT_BUDGET_MS / 1e3}s to finish after page load (${EVAL_SCRIPT_BUDGET_CAMERA_MS / 1e3}s with --camera) - raise it with --timeout, max ${EVAL_SCRIPT_BUDGET_MAX_MS / 1e3}s.`).option("--file <path>", `Read the script body from a file instead of the inline <expr> arg (mutually exclusive). Runs as an async function body, so top-level return/await work. Same post-load budget as <expr> (--timeout).`).option(
+var JS_DECOY_FLAGS = ["--js", "--javascript", "--script", "--code", "--expr", "--eval", "--exec", "--action"];
+var pageEvalCommand = new Command("eval").description("Evaluate JS in a real browser on a page (DOM, computed styles, element rects; inline expr or --file script). ONE client per call - to verify realtime/presence across concurrent clients use `page test --observe` instead").argument("<url>", "URL to load").argument("[expr]", `JavaScript to evaluate in page context (inline expression or statement body; await works, and the trailing expression is returned automatically \u2014 REPL-style \u2014 so no explicit return is needed; result is JSON-serialized). Omit when using --file. Time budget: the body has ${EVAL_SCRIPT_BUDGET_MS / 1e3}s to finish after page load (${EVAL_SCRIPT_BUDGET_CAMERA_MS / 1e3}s with --camera) - raise it with --timeout, max ${EVAL_SCRIPT_BUDGET_MAX_MS / 1e3}s.`).option("--file <path>", `Read the script body from a file instead of the inline <expr> arg (mutually exclusive). Runs as an async function body, so top-level return/await work. Same post-load budget as <expr> (--timeout).`).option(
   "--step <expr>",
   `Run another expression against the SAME loaded page, after <expr> (repeat, max ${MAX_EVAL_STEPS}). Whatever that page load paid for \u2014 a vision model coming up, a game booting, a socket connecting \u2014 stays up for every step, so an N-part check costs ONE page load instead of N. Each step gets its own in-page budget and its own reported result.`,
   (val, prev) => [...prev, val],
@@ -35370,7 +35526,7 @@ var pageEvalCommand = new Command("eval").description("Evaluate JS in a real bro
 ).option("--fake-media", "Grant a synthetic microphone + camera and auto-accept the getUserMedia prompt, so a voice/camera app runs headlessly instead of hitting its no-camera path. The feed is a built-in test pattern (and a tone) \u2014 nothing a vision model can recognize; to drive a vision app use --camera <path> instead.").option("--wait <ms>", "Sleep this many ms after DOMContentLoaded before evaluating (lets late async work settle; max 30000). With --wait-for, it elapses AFTER the selector appears - gate, then settle.", "500").option("--wait-for <selector>", `Wait until this CSS selector appears before evaluating, then evaluate (deterministic - beats guessing a --wait). Gate on the state you are ASSERTING, not just a ready flag: '#verdict:not(:empty)' returns the instant the round lands, where a fixed wait snapshots mid-sequence. Same flag on page inspect/screenshot. Max ${WAIT_FOR_MAX_MS}ms (--wait-timeout).`).option("--wait-timeout <ms>", `Max ms to wait for --wait-for before giving up (max ${WAIT_FOR_MAX_MS})`, "5000").option(
   "--timeout <ms>",
   `How long the script itself may run IN the page - its own await/setTimeout pauses count (default ${EVAL_SCRIPT_BUDGET_MS}, ${EVAL_SCRIPT_BUDGET_CAMERA_MS} with --camera/--fake-media; max ${EVAL_SCRIPT_BUDGET_MAX_MS}). Raise it to trace a sequence that unfolds over time (a game round, an animation). Distinct from --wait, which only sleeps BEFORE the script.`
-).option("--auth", "Evaluate signed in as you (your Gipity account), so a page behind a Sign-in-with-Gipity login is reachable. Only works for apps using Sign in with Gipity, hosted on *.gipity.ai.").option("--json", "Output as JSON").action((url, exprArg, opts) => run("Page eval", async () => {
+).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 () => {
   const decoy = JS_DECOY_FLAGS.find((f) => opts[f.slice(2)] !== void 0);
   if (decoy) {
     pageEvalCommand.error(
@@ -35524,6 +35680,8 @@ ${hint}`);
     if (d.auth?.requested) {
       const who = getAuth()?.email;
       console.log(d.auth.established ? `${muted("Auth:")} ${success("session established")}${who ? muted(` as ${who}`) : ""} ${muted("(what the page renders with it is app-defined)")}` : `${warning("Auth: session NOT established")}${d.auth.detail ? ` \u2014 ${d.auth.detail}` : ""} ${muted("(this is the anonymous view)")}`);
+    } else {
+      console.log(muted("Auth: anonymous visitor (signed out; pass --auth to run as your Gipity account)"));
     }
     if (camera) console.log(`${muted("Camera:")} ${camera.name} ${muted("(played as the webcam feed; getUserMedia resolves)")}`);
     if (hosted.length) console.log(`${muted("Fixtures:")} ${hosted.map((h) => h.name).join(", ")}`);
@@ -35653,7 +35811,10 @@ function fmtMs(ms2) {
   return ms2 >= 1e3 ? `${(ms2 / 1e3).toFixed(1)}s` : `${ms2}ms`;
 }
 function printAuthLine(auth) {
-  if (!auth?.requested) return;
+  if (!auth?.requested) {
+    console.log(`${label("Auth")} ${muted("anonymous visitor (signed out; pass --auth to capture as your Gipity account)")}`);
+    return;
+  }
   const who = getAuth()?.email;
   console.log(auth.established ? `${label("Auth")} ${success("session established")}${who ? muted(` as ${who}`) : ""} ${muted("(what the page renders with it is app-defined)")}` : `${warning("Auth: session NOT established")}${auth.detail ? ` \u2014 ${auth.detail}` : ""} ${muted("(this is the anonymous view)")}`);
 }
@@ -35751,7 +35912,7 @@ function splitCsv(values) {
 function appendOption(value, previous = []) {
   return [...previous, value];
 }
-var ACTION_DECOY_FLAGS = ["--eval", "--js", "--javascript", "--script", "--code", "--exec"];
+var ACTION_ALIAS_FLAGS = ["--eval", "--js", "--javascript", "--script", "--code", "--exec"];
 function buildWaitForGate(selector, timeoutMs) {
   const sel = JSON.stringify(selector);
   return `await (async () => { const __t0 = Date.now(); while (Date.now() - __t0 < ${timeoutMs}) { try { if (document.querySelector(${sel})) return; } catch (e) { throw new Error('wait-for: invalid selector ' + ${sel}); } await new Promise((r) => setTimeout(r, 100)); } throw new Error('wait-for: nothing matched ' + ${sel} + ' within ${timeoutMs}ms \u2014 the page never reached that state (raise --wait-timeout, fix the selector, or check the app actually gets there headlessly)'); })();`;
@@ -35760,13 +35921,14 @@ var WAIT_FOR_MAX_MS2 = 15e3;
 var WAIT_FOR_DEFAULT_MS = 15e3;
 var MAX_POST_LOAD_DELAY_MS = 3e4;
 var CAMERA_DEFAULT_DELAY_MS = 15e3;
-var pageScreenshotCommand = new Command("screenshot").description("Screenshot a web page").argument("<url>", "URL to screenshot").option("--wait <ms>", `Sleep this many ms after DOMContentLoaded before capturing (default 1000, max ${MAX_POST_LOAD_DELAY_MS}). With --camera it defaults to ${CAMERA_DEFAULT_DELAY_MS} so the vision model is up. Same flag as page eval/inspect.`).option("--wait-for <selector>", `Wait until this CSS selector appears before capturing, then capture (deterministic - beats guessing a --wait). Same flag as page eval/inspect. Gate on what you are photographing ('[data-vision="ready"]', '#verdict:not(:empty)'). Max ${WAIT_FOR_MAX_MS2}ms (--wait-timeout).`).option("--wait-timeout <ms>", `Max ms to wait for --wait-for before giving up (default ${WAIT_FOR_DEFAULT_MS}, max ${WAIT_FOR_MAX_MS2}). Timing out is reported - the capture still happens, so you see the state it got stuck in.`).option("--action <js>", `Run JS in the page before capturing \u2014 e.g. click a button to enter a state ("document.getElementById('play').click()"). Runs as an async function body, so const/await and app-relative import('./\u2026') work. Runs after the post-load delay, then settles again before the shot. If it throws, the capture still happens and the failure is reported.`).option("--full", "Capture the full scrollable page (default: viewport only). Scrolls the page through first so scroll-reveal/fade-in-on-scroll (IntersectionObserver) sections render into the shot instead of capturing blank.").option("-o, --output <file>", "Output path (single viewport only; default .gipity/screenshots/ss-<host>-<timestamp>.png)").option("--device <names>", `Device preset(s): ${Object.keys(DEVICE_PRESETS).join(", ")} (comma-separated or repeat flag). mobile/tablet emulate a real touch device \u2014 touch events, mobile user-agent, DPR \u2014 so touch-gated mobile UI actually renders.`, appendOption, []).option("--viewport <dims>", "Raw viewport(s): WxH or WxH@dpr (comma-separated or repeat flag)", appendOption, []).option("--no-reload-between", "Skip reload between viewports (faster, lower fidelity - only safe for static pages)").option("--fake-media", "Grant a synthetic microphone + camera and auto-accept the getUserMedia prompt, so voice/camera apps render headlessly. The video feed is a built-in test pattern \u2014 to capture what the app does with a REAL frame (a hand, a face, an object), use --camera <path> instead.").option("--camera <path>", "Play a local image or video (.png/.jpg/.webp/.mp4/.webm/.y4m/.mjpeg) as the browser's WEBCAM feed, then capture \u2014 so the shot shows the app reacting to a frame you chose (detected gesture, boxes, labels). Implies --fake-media.").option("--auth", "Capture the page signed in as you (your Gipity account), so UI behind a Sign-in-with-Gipity login is shown. Only works for apps using Sign in with Gipity, hosted on *.gipity.ai.").option("--ephemeral", "Skip the project screenshot history: do not persist this capture to Gipity (screenshots/ in the project). Local file is still written.").option("--json", "Output JSON metadata instead of a friendly summary").addOption(new Option("--post-load-delay <ms>", "Alias for --wait").hideHelp()).addOption(new Option("--full-page", "Alias for --full").hideHelp()).action((url, opts) => run("Page screenshot", async () => {
-  const decoy = ACTION_DECOY_FLAGS.find((f) => opts[f.slice(2)] !== void 0);
-  if (decoy) {
-    pageScreenshotCommand.error(
-      `error: ${decoy} is not a flag on screenshot \u2014 use --action "<js>" to run JavaScript in the page before the capture, e.g. gipity page screenshot "<url>" --action "document.getElementById('play').click()"`
-    );
+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 \u2014 e.g. click a button to enter a state ("document.getElementById('play').click()"). Runs as an async function body, so const/await and app-relative import('./\u2026') work. Runs after the post-load delay, then settles again before the shot. If it throws, the capture still happens and the failure is reported.`).option("--full", "Capture the full scrollable page (default: viewport only). Scrolls the page through first so scroll-reveal/fade-in-on-scroll (IntersectionObserver) sections render into the shot instead of capturing blank.").option("-o, --output <file>", "Output path (single viewport only; default .gipity/screenshots/ss-<host>-<timestamp>.png)").option("--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(
+      `Note: treating ${aliasFlag} as --action \u2014 it runs your JS in the page before the capture. --action is the canonical flag.`
+    ));
   }
+  const actionScript = [opts.action, ...ACTION_ALIAS_FLAGS.map((f) => opts[f.slice(2)])].filter(Boolean).join("\n");
   const delayRaw = opts.wait ?? opts.postLoadDelay;
   const chosenDelay = delayRaw !== void 0;
   let postLoadDelayMs = chosenDelay ? parseInt(String(delayRaw), 10) : 1e3;
@@ -35800,6 +35962,20 @@ var pageScreenshotCommand = new Command("screenshot").description("Screenshot a
   }
   const deviceNames = splitCsv(opts.device);
   const viewportStrs = splitCsv(opts.viewport);
+  if (opts.width !== void 0 || opts.height !== void 0) {
+    if (opts.width === void 0 || opts.height === void 0) {
+      pageScreenshotCommand.error(
+        "error: --width and --height go together (both in px, equivalent to --viewport WxH) \u2014 or use a preset like --device mobile for a real handset (touch events, mobile user-agent, DPR)"
+      );
+    }
+    if (!/^\d+$/.test(String(opts.width)) || !/^\d+$/.test(String(opts.height))) {
+      pageScreenshotCommand.error("error: --width and --height must be integers (px)");
+    }
+    viewportStrs.push(`${opts.width}x${opts.height}`);
+    if (parseInt(String(opts.width), 10) <= 500) {
+      console.error(muted("Tip: --device mobile emulates a real handset (touch events, mobile user-agent, DPR) \u2014 a raw viewport only resizes the window."));
+    }
+  }
   const customViewports = [
     ...deviceNames.map(resolveDevice),
     ...viewportStrs.map(parseViewportString)
@@ -35823,7 +35999,7 @@ var pageScreenshotCommand = new Command("screenshot").description("Screenshot a
   }
   const preCapture = [
     opts.waitFor ? buildWaitForGate(opts.waitFor, waitForTimeoutMs) : "",
-    opts.action ?? ""
+    actionScript
   ].filter(Boolean).join("\n");
   const body = {
     url,
@@ -35945,7 +36121,7 @@ ${brand("@ " + dims)}${deviceTag}`);
     printVfsLine(s);
   }
 }));
-for (const f of ACTION_DECOY_FLAGS) pageScreenshotCommand.addOption(new Option(`${f} <value>`).hideHelp());
+for (const f of ACTION_ALIAS_FLAGS) pageScreenshotCommand.addOption(new Option(`${f} <js>`, "Alias for --action").hideHelp());
 pageScreenshotCommand.addHelpText("after", `
 Examples:
   gipity page screenshot "https://dev.gipity.ai/me/app/"
@@ -35992,7 +36168,7 @@ function shortUrl(url, truncate = true, maxLen = 100) {
   const tailLen = Math.floor(keep / 2);
   return result.slice(0, headLen) + "\u2026" + result.slice(-tailLen);
 }
-var pageInspectCommand = new Command("inspect").description("Inspect a web page (console, failed resources, timing, layout overflow). ONE passive load - to verify realtime/presence across concurrent clients use `page test --observe`").argument("<url>", "URL to inspect").option("--wait <ms>", "Sleep this many ms after DOMContentLoaded before capturing (lets late async/LCP work settle; max 30000)", "500").option("--wait-for <selector>", "Wait until this CSS selector appears before capturing (deterministic; replaces --wait)").option("--wait-timeout <ms>", "Max ms to wait for --wait-for before giving up", "5000").option("--json", "Output as JSON").option("--no-reprobe", "Skip the automatic second probe that filters one-time transient console errors - roughly halves inspect time on a page with any console error, at the cost of possibly reporting a cold-load transient as real").option("--no-truncate", "Show full URLs instead of truncating long ones with middle-ellipsis").option("--all", "Include render-blocking, large resources, oversized images, overflow culprits, and LCP detail").option("--no-fake-media", "Inspect with NO camera or microphone present, so a getUserMedia app takes its no-device error path (use this only when that fallback IS what you're inspecting)").option("--device <name>", `Inspect as a real touch device: ${TOUCH_DEVICES.join(", ")}. Emulates touch events, mobile user-agent and DPR, so a touch-gated mobile layout is what gets inspected.`).option("--auth", "Load the page signed in as you (your Gipity account), so pages behind a Sign-in-with-Gipity login are reachable. Only works for apps using Sign in with Gipity, hosted on *.gipity.ai.").addOption(new Option("--screenshot [path]", "Capture a screenshot").hideHelp()).action((url, opts) => {
+var pageInspectCommand = new Command("inspect").description("Inspect a web page (console, failed resources, timing, layout overflow). ONE passive load - to verify realtime/presence across concurrent clients use `page test --observe`").argument("<url>", "URL to inspect").option("--wait <ms>", "Sleep this many ms after DOMContentLoaded before capturing (lets late async/LCP work settle; max 30000)", "500").option("--wait-for <selector>", "Wait until this CSS selector appears before capturing (deterministic; replaces --wait)").option("--wait-timeout <ms>", "Max ms to wait for --wait-for before giving up", "5000").option("--json", "Output as JSON").option("--no-reprobe", "Skip the automatic second probe that filters one-time transient console errors - roughly halves inspect time on a page with any console error, at the cost of possibly reporting a cold-load transient as real").option("--no-truncate", "Show full URLs instead of truncating long ones with middle-ellipsis").option("--all", "Include render-blocking, large resources, oversized images, overflow culprits, and LCP detail").option("--no-fake-media", "Inspect with NO camera or microphone present, so a getUserMedia app takes its no-device error path (use this only when that fallback IS what you're inspecting)").option("--device <name>", `Inspect as a real touch device: ${TOUCH_DEVICES.join(", ")}. Emulates touch events, mobile user-agent and DPR, so a touch-gated mobile layout is what gets inspected.`).option("--auth", "Load the page signed in as you (your Gipity account), so pages behind a Sign-in-with-Gipity login are reachable. Only works for apps using Sign in with Gipity, hosted on *.gipity.ai. Without this flag the page loads as a genuinely anonymous, signed-out visitor \u2014 nothing carries over from earlier --auth runs.").addOption(new Option("--screenshot [path]", "Capture a screenshot").hideHelp()).action((url, opts) => {
   if (opts.screenshot !== void 0) {
     console.error(error("page inspect does not capture screenshots. Use page screenshot:"));
     console.error(`  gipity page screenshot ${url}${typeof opts.screenshot === "string" ? ` -o ${opts.screenshot}` : ""}`);
@@ -36066,6 +36242,8 @@ async function inspectPage(url, opts = {}) {
   if (b7.auth?.requested) {
     const who = getAuth()?.email;
     console.log(b7.auth.established ? `${muted("Auth:")} ${success("session established")}${who ? muted(` as ${who}`) : ""} ${muted("(what the page renders with it is app-defined)")}` : `${warning("Auth: session NOT established")}${b7.auth.detail ? ` \u2014 ${b7.auth.detail}` : ""} ${muted("(this is the anonymous view)")}`);
+  } else {
+    console.log(muted("Auth: anonymous visitor (signed out; pass --auth to load as your Gipity account)"));
   }
   console.log(`${muted("Title:")} ${b7.title || "(none)"}`);
   console.log(`${muted("Elements:")} ${b7.elementCount || 0}`);
@@ -36336,11 +36514,15 @@ dbCommand.command("list").description("List databases").option("--all", "List da
   }
 }));
 dbCommand.command("create <name>").description("Create a database").option("--json", "Output as JSON").action((name, opts) => run("Create", async () => {
-  const response = await sendMessage(`Create a new database called "${name}" for this project. Confirm when done, no explanation.`);
+  const config = requireConfig();
+  await post(`/projects/${config.projectGuid}/db/manage`, {
+    action: "create",
+    name
+  });
   if (opts.json) {
-    console.log(JSON.stringify({ response }));
+    console.log(JSON.stringify({ success: true, name }));
   } else {
-    console.log(response);
+    console.log(success(`Created database '${name}'.`));
   }
 }));
 dbCommand.command("drop <name>").description("Drop a database").option("--project <slug>", "Project slug (required if not in a project directory)").option("--yes", "Skip confirmation").option("--json", "Output as JSON").action((name, opts) => run("Drop", async () => {
@@ -36428,8 +36610,8 @@ memoryCommand.command("delete <topic>").description("Delete a topic").option("--
 // src/commands/sandbox.ts
 init_api();
 init_config();
-import { readFileSync as readFileSync13, existsSync as existsSync11, statSync as statSync6 } from "fs";
-import { dirname as dirname8, extname as extname4, relative as relative4, resolve as resolve12 } from "path";
+import { readFileSync as readFileSync13, existsSync as existsSync11, statSync as statSync6, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname8, extname as extname4, relative as relative4, resolve as resolve12, sep as sep3 } from "path";
 init_colors();
 var LANG_MAP = {
   js: "javascript",
@@ -36547,13 +36729,13 @@ function resolveRelativeCwd() {
   return rel2.split(/[\\/]/).filter(Boolean).join("/");
 }
 var sandboxCommand = new Command("sandbox").description("Run code in a sandbox");
-sandboxCommand.command("run [args...]").description("Run code").option("--language <language>", "Language: js, py, or bash (required unless pinned by an interpreter token or --file extension)").option("--file <path>", "Read the code body from a file instead of the inline <code> arg; --language is inferred from the extension when not given").option("--timeout <seconds>", "Execution timeout in seconds", "30").option(
+sandboxCommand.command("run [args...]").description("Run code").option("--language <language>", "Language: js, py, or bash (required unless pinned by an interpreter token or --file extension)").option("--file <path>", "Read the code body from a file instead of the inline <code> arg; --language is inferred from the extension when not given").addOption(new Option("--code <code>", "Alias for the positional inline <code> arg").hideHelp()).option("--timeout <seconds>", "Execution timeout in seconds", "30").option(
   "--input <path>",
   "Narrow to specific project files instead of auto-mirroring the whole tree (repeatable). Use this only for >1 GB projects or when you want surgical control.",
   (v7, prev) => [...prev ?? [], v7]
 ).option(
-  "--no-sync-output <glob>",
-  'Do not persist run outputs matching this glob back to the project (repeatable). For byproducts you want to inspect once but never keep, e.g. --no-sync-output "docs/preview*". Supports *, **, and dir/ prefixes.',
+  "--discard-output <glob>",
+  "Discard run outputs matching this glob entirely - not saved, not returned (repeatable). To LOOK at an output without keeping it, write it under tmp/ instead: scratch outputs land on local disk only and never enter the project. Supports *, **, and dir/ prefixes.",
   (v7, prev) => [...prev, v7],
   []
 ).option("--json", "Output as JSON").addHelpText("after", `
@@ -36561,6 +36743,11 @@ By default the whole project is auto-mirrored into /work/ (up to 1 GB) -
 so your code can reference project files by their relative path, and any
 file you write lands back in the project. No manual copy needed.
 
+Exception: tmp/ is scratch. An output written under tmp/ comes back to
+your local tmp/ for inspection but is never saved to the project - use it
+for previews and other look-once artifacts (no cleanup needed). To drop
+an output entirely, --discard-output <glob>.
+
 Use --input only for projects over the auto-mirror cap, or when you want
 to restrict what the sandbox sees.
 
@@ -36577,6 +36764,11 @@ Examples:
   $ gipity sandbox run --language python \\
       "import pandas as pd; print(pd.read_csv('data/sales.csv').describe())"
 
+  # Preview a generated PDF without saving the preview: write it to tmp/
+  $ gipity sandbox run bash \\
+      "pdftoppm -png -r 90 docs/report.pdf tmp/preview"
+  # -> tmp/preview-1.png lands on local disk only; Read it, done.
+
   # Run a script file directly (language inferred from .py)
   $ gipity sandbox run --file build_report.py
   $ gipity sandbox run python build_report.py   # same thing, interpreter shorthand
@@ -36598,6 +36790,13 @@ GCC/Rust).
   let inlineCode;
   let filePath = opts.file;
   let langFromInterp;
+  if (opts.code !== void 0) {
+    if (args.length) {
+      console.error(error("Pass the code once: either positionally or via --code, not both"));
+      process.exit(1);
+    }
+    args = [opts.code];
+  }
   if (args.length >= 2 && INTERPRETERS[args[0].toLowerCase()] !== void 0) {
     langFromInterp = INTERPRETERS[args[0].toLowerCase()];
     const rest = args.slice(1).join(" ");
@@ -36627,9 +36826,9 @@ GCC/Rust).
     }
   }
   const language = resolveLanguage({ langFromInterp, langOpt: opts.language, filePath, inlineCode });
-  const noSyncOutput = opts.syncOutput ?? [];
-  if (noSyncOutput.some((g) => !g.trim())) {
-    console.error(error('--no-sync-output requires a non-empty glob (e.g. --no-sync-output "docs/preview*")'));
+  const discardOutput = opts.discardOutput ?? [];
+  if (discardOutput.some((g) => !g.trim())) {
+    console.error(error('--discard-output requires a non-empty glob (e.g. --discard-output "*.ppm")'));
     process.exit(1);
   }
   const { config } = await resolveProjectContext();
@@ -36655,16 +36854,30 @@ GCC/Rust).
     cwd,
     // The filter must run SERVER-side (in the output extractor): skipping
     // only in the CLI would still write the files into project storage and
-    // make every later sync propose deleting them.
-    noSyncOutput: noSyncOutput.length ? noSyncOutput : void 0
+    // make every later sync propose deleting them. (`noSyncOutput` is the
+    // wire name for --discard-output.)
+    noSyncOutput: discardOutput.length ? discardOutput : void 0
   });
   const res = opts.json ? await doRun() : await withSpinner("Running in sandbox\u2026", doRun, { done: null });
   const pulledLocal = !!(res.data.outputFiles?.length && getConfigPath());
   if (pulledLocal) {
     await sync({ interactive: false, progress: opts.json ? void 0 : createProgressReporter() });
   }
+  const scratchWritten = [];
+  if (res.data.scratchFiles?.length) {
+    const base = resolve12(getProjectRoot() ?? process.cwd());
+    for (const f of res.data.scratchFiles) {
+      const rel2 = f.path.replace(/\\/g, "/");
+      const abs = resolve12(base, rel2);
+      if (abs !== base && !abs.startsWith(base + sep3)) continue;
+      mkdirSync8(dirname8(abs), { recursive: true });
+      writeFileSync9(abs, Buffer.from(f.contentBase64, "base64"));
+      scratchWritten.push(rel2);
+    }
+  }
   if (opts.json) {
-    console.log(JSON.stringify({ ...res.data, filesSynced: pulledLocal }));
+    const { scratchFiles: _omit, ...rest } = res.data;
+    console.log(JSON.stringify({ ...rest, scratchFiles: scratchWritten, filesSynced: pulledLocal }));
   } else {
     if (res.data.autoMirrorSkipped) {
       console.error(dim(`Note: ${res.data.autoMirrorSkipped.reason}`));
@@ -36694,8 +36907,12 @@ GCC/Rust).
         if (pulledLocal) console.log(dim("Not pulled locally - run 'gipity sync' to fetch them."));
       }
     }
+    if (scratchWritten.length > 0) {
+      console.log("\nScratch outputs (local only - never synced or deployed):");
+      for (const f of scratchWritten) console.log(`${f}`);
+    }
     if (res.data.skippedOutputFiles && res.data.skippedOutputFiles.length > 0) {
-      console.log(dim("\nNot persisted (--no-sync-output):"));
+      console.log(dim("\nDiscarded (--discard-output):"));
       for (const f of res.data.skippedOutputFiles) console.log(dim(`${f}`));
     }
     if (res.data.exitCode !== 0) {
@@ -36737,9 +36954,11 @@ ${syncResult.summary}`;
         ...a.remoteSize != null ? { size: a.remoteSize } : {}
       }));
     }
+    const displayContent = res.data.content || res.data.costWarning?.message || "";
     if (opts.json) {
       console.log(JSON.stringify({
-        content: res.data.content,
+        content: displayContent,
+        costWarning: res.data.costWarning ?? null,
         toolsUsed: res.data.toolsUsed?.map((t) => ({
           tool: t.toolName,
           success: t.success,
@@ -36753,7 +36972,7 @@ ${syncResult.summary}`;
         syncedFiles: syncChanges
       }));
     } else {
-      console.log(res.data.content);
+      console.log(displayContent);
       if (res.data.toolsUsed && res.data.toolsUsed.length > 0) {
         const toolNames = [...new Set(res.data.toolsUsed.map((t) => t.toolName))];
         console.log(`
@@ -36799,7 +37018,7 @@ chatCommand.command("delete <guid>").description("Delete a chat").option("--json
 init_api();
 init_config();
 import { join as join13 } from "path";
-import { mkdirSync as mkdirSync8 } from "fs";
+import { mkdirSync as mkdirSync9 } from "fs";
 init_colors();
 init_utils();
 var projectCommand = new Command("project").description("Manage projects").argument("[name]", "Switch to project by name/slug").option("--json", "Output as JSON").action((name, opts) => run("Project", async () => {
@@ -36857,7 +37076,7 @@ projectCommand.command("create <name>").description("Create a project").option("
   const res = await post("/projects", body);
   const project = res.data;
   const dir = join13(getProjectsRoot(), project.slug);
-  mkdirSync8(dir, { recursive: true });
+  mkdirSync9(dir, { recursive: true });
   const accountSlug = await getAccountSlug();
   let agentGuid = "";
   try {
@@ -36891,7 +37110,7 @@ projectCommand.command("create <name>").description("Create a project").option("
   if (process.env.GIPITY_NON_INTERACTIVE === "1") {
     console.log(`${muted("Next:")} switch to "${project.name}" in the sidebar.`);
   } else {
-    console.log(`${muted("Next:")} exit Claude (Ctrl+D), then run:  ${brand("gipity claude")}`);
+    console.log(`${muted("Next:")} exit Claude (Ctrl+D), then run:  ${brand("gipity build")}`);
     console.log(`${muted("Pick")} "${project.name}" ${muted(`- it'll be at the top of the list.`)}`);
   }
 }));
@@ -37112,7 +37331,7 @@ function printStepRuns(steps, emptyNote) {
   }
 }
 var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
-var sleep2 = (ms2) => new Promise((resolve19) => setTimeout(resolve19, ms2));
+var sleep2 = (ms2) => new Promise((resolve20) => setTimeout(resolve20, ms2));
 async function waitForRun(wfGuid, prevGuid, timeoutSec) {
   const deadline = Date.now() + timeoutSec * 1e3;
   let runGuid;
@@ -37729,14 +37948,15 @@ storageCommand.command("retention").description("View or adjust your file versio
   printRetention(data, opts.reset === true || hasSet);
 }));
 
-// src/commands/claude.ts
+// src/commands/build.ts
 init_platform();
 init_auth();
 init_api();
-import { join as join16, dirname as dirname10, resolve as resolve14, basename as basename4, sep as sep4 } from "path";
-import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync16, writeFileSync as writeFileSync10, renameSync as renameSync2, readdirSync as readdirSync7, statSync as statSync7 } from "fs";
-import { homedir as homedir11 } from "os";
+import { join as join17, dirname as dirname10, resolve as resolve14, basename as basename4, sep as sep5 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync12, readFileSync as readFileSync17, writeFileSync as writeFileSync12, renameSync as renameSync2, readdirSync as readdirSync8, statSync as statSync7 } from "fs";
+import { homedir as homedir12 } from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
+import { randomUUID } from "crypto";
 
 // src/login-flow.ts
 init_api();
@@ -37775,7 +37995,7 @@ async function interactiveLogin() {
   return getAuth();
 }
 
-// src/commands/claude.ts
+// src/commands/build.ts
 init_config();
 
 // src/prompts.ts
@@ -38053,7 +38273,7 @@ init_platform();
 init_api();
 import { hostname as hostname3, userInfo, platform as osPlatform2 } from "os";
 import { resolve as resolve13, dirname as dirname9 } from "path";
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
 
 // src/relay/machine-id.ts
 import { createHash as createHash3 } from "crypto";
@@ -38166,8 +38386,8 @@ function startDaemon() {
 function installAutostart(opts = {}) {
   const stdio = opts.stdio ?? "ignore";
   const plan2 = planFor({ cliPath: resolveCliPath() });
-  mkdirSync9(dirname9(plan2.path), { recursive: true });
-  writeFileSync9(plan2.path, plan2.content);
+  mkdirSync10(dirname9(plan2.path), { recursive: true });
+  writeFileSync10(plan2.path, plan2.content);
   let ok = true;
   for (const argv2 of plan2.enableCmds) {
     const r = spawnSyncCommand(argv2[0], argv2.slice(1), { stdio });
@@ -38264,7 +38484,7 @@ async function runRelaySetup(opts) {
     console.error(`  ${dim("Skipping for now - we'll offer again next time. Or turn it on with `gipity setup`.")}`);
     return false;
   }
-  const startNow = await confirm("  Start the relay now (and on future `gipity claude` runs)?", { default: "yes" });
+  const startNow = await confirm("  Start the relay now (and on future `gipity build` runs)?", { default: "yes" });
   if (startNow) {
     startDaemon();
   }
@@ -38275,7 +38495,7 @@ async function runRelaySetup(opts) {
       if (!res.ok) {
         if (isWsl()) {
           console.log(`  ${muted("Auto-start needs systemd, which this WSL distro has off. The relay still runs -")}`);
-          console.log(`  ${muted("it started just now and `gipity claude` restarts it. For boot-time auto-start:")}`);
+          console.log(`  ${muted("it started just now and `gipity build` restarts it. For boot-time auto-start:")}`);
           console.log(`  ${muted("add [boot] systemd=true to /etc/wsl.conf, restart WSL, then run")} ${brand("gipity relay install")}${muted(".")}`);
         } else {
           console.log(`  ${muted("Autostart install returned non-zero - you can run")} ${brand("gipity relay install")} ${muted("later.")}`);
@@ -38309,19 +38529,19 @@ async function maybeOfferRelayOn() {
   await runRelaySetup({ mode: "offer-once" });
 }
 
-// src/commands/claude.ts
+// src/commands/build.ts
 init_utils();
 init_colors();
 
 // src/banner.ts
 init_colors();
 import { homedir as homedir9 } from "os";
-import { sep as sep3 } from "path";
+import { sep as sep4 } from "path";
 function tildify(p) {
   const home = homedir9();
   if (!home) return p;
   if (p === home) return "~";
-  if (p.startsWith(home + sep3)) return "~" + p.slice(home.length);
+  if (p.startsWith(home + sep4)) return "~" + p.slice(home.length);
   return p;
 }
 var AI_MODELS = [
@@ -38613,14 +38833,200 @@ function ensureClaudeInstalled(opts = {}) {
   return { installed: isClaudeInstalled(), alreadyPresent: false };
 }
 
-// src/commands/claude.ts
+// src/agents/claude-code.ts
+var claudeCodeAdapter = {
+  key: "claude",
+  source: "claude_code",
+  displayName: "Claude Code",
+  providerName: "Anthropic",
+  binary: "claude",
+  models: [
+    { id: "opus", label: "Opus" },
+    { id: "sonnet", label: "Sonnet" },
+    { id: "haiku", label: "Haiku" }
+  ],
+  buildInteractiveArgs({ resume, model }) {
+    const args = [];
+    if (model) args.push("--model", model);
+    if (resume) args.push("--resume", resume);
+    return args;
+  },
+  buildHeadlessArgs({ message, resume, model, bypassApprovals, jsonStream }) {
+    const args = ["-p", message];
+    if (bypassApprovals) args.push("--permission-mode", "bypassPermissions");
+    if (model) args.push("--model", model);
+    if (resume) args.push("--resume", resume);
+    if (jsonStream) args.push("--output-format", "stream-json", "--verbose", "--include-partial-messages");
+    return args;
+  },
+  sessionIdFromStreamEvent(event) {
+    if (event && typeof event.session_id === "string" && event.session_id) return event.session_id;
+    return null;
+  },
+  hooksSupportedOnPlatform() {
+    return true;
+  },
+  // The daemon parses Claude's stream-json into ingest entries itself
+  // (hook capture stands down via GIPITY_CAPTURE=off on dispatches).
+  daemonStreamCapture: true,
+  ensureInstalled() {
+    return ensureClaudeInstalled().installed;
+  },
+  installHint: `npm install -g ${CLAUDE_PACKAGE}`
+};
+
+// src/agents/codex.ts
+var codexAdapter = {
+  key: "codex",
+  source: "codex",
+  displayName: "Codex",
+  providerName: "OpenAI",
+  binary: "codex",
+  models: [
+    { id: "gpt-5.1-codex", label: "GPT-5.1 Codex" },
+    { id: "gpt-5.1-codex-mini", label: "GPT-5.1 Codex Mini" }
+  ],
+  buildInteractiveArgs({ resume, model }) {
+    const args = [];
+    if (model) args.push("--model", model);
+    if (resume) args.push("resume", resume);
+    return args;
+  },
+  buildHeadlessArgs({ message, resume, model, bypassApprovals, jsonStream }) {
+    const args = resume ? ["exec", "resume", resume, message] : ["exec", message];
+    if (model) args.push("--model", model);
+    if (bypassApprovals) {
+      args.push(
+        "-s",
+        "workspace-write",
+        "-c",
+        "sandbox_workspace_write.network_access=true",
+        "--dangerously-bypass-hook-trust",
+        "--skip-git-repo-check"
+      );
+    }
+    if (jsonStream) args.push("--json");
+    return args;
+  },
+  sessionIdFromStreamEvent(event) {
+    if (event?.type === "thread.started" && typeof event.thread_id === "string") {
+      return event.thread_id;
+    }
+    return null;
+  },
+  hooksSupportedOnPlatform(platform2) {
+    return platform2 !== "win32";
+  },
+  // No stream-json ingest mapper for Codex: relay dispatches keep hook
+  // capture ON (GIPITY_CONVERSATION_GUID binds it) and the transcript
+  // parser mirrors the session; the daemon tracks byte-level progress only.
+  daemonStreamCapture: false,
+  oneTimeSetupNote: "Codex runs project hooks only after a one-time approval: run /hooks inside Codex and approve the Gipity entries, or session recording stays off.",
+  installHint: "npm install -g @openai/codex"
+};
+
+// src/agents/grok.ts
+var grokAdapter = {
+  key: "grok",
+  source: "grok",
+  displayName: "Grok",
+  providerName: "xAI",
+  binary: "grok",
+  models: [
+    { id: "grok-4.5", label: "Grok 4.5" },
+    { id: "grok-code", label: "Grok Code" }
+  ],
+  buildInteractiveArgs({ resume, model }) {
+    const args = [];
+    if (model) args.push("--model", model);
+    if (resume) args.push("--resume", resume);
+    return args;
+  },
+  buildHeadlessArgs({ message, resume, model, bypassApprovals, jsonStream }) {
+    const args = ["-p", message];
+    if (model) args.push("--model", model);
+    if (resume) args.push("--resume", resume);
+    if (bypassApprovals) args.push("--always-approve");
+    if (jsonStream) args.push("--output-format", "streaming-json");
+    return args;
+  },
+  sessionIdFromStreamEvent(event) {
+    const fromParams = event?.params?.sessionId;
+    if (typeof fromParams === "string" && fromParams) return fromParams;
+    if (typeof event?.sessionId === "string" && event.sessionId) return event.sessionId;
+    return null;
+  },
+  hooksSupportedOnPlatform() {
+    return true;
+  },
+  daemonStreamCapture: false,
+  // Verified live (2026-07-13): grok -p fires NO plugin hooks - not even
+  // SessionStart/Stop - so headless capture is launcher-driven: pin the
+  // session id, then replay ~/.grok/sessions/<cwd>/<sid>/chat_history.jsonl
+  // through the capture runner after the run.
+  headlessCapture: {
+    sessionIdArgs: (sessionId) => ["--session-id", sessionId]
+  },
+  installHint: "curl -fsSL https://grok.x.ai/install.sh | sh   (or see docs.x.ai/grok-build)"
+};
+
+// src/agents/index.ts
+var AGENT_ADAPTERS = [
+  claudeCodeAdapter,
+  codexAdapter,
+  grokAdapter
+];
+var AGENT_KEYS = AGENT_ADAPTERS.map((a) => a.key);
+function getAdapter(key) {
+  const found = AGENT_ADAPTERS.find((a) => a.key === key);
+  if (!found) throw new Error(`Unknown agent "${key}". Valid: ${AGENT_KEYS.join(", ")}`);
+  return found;
+}
+function getAdapterBySource(source) {
+  const found = AGENT_ADAPTERS.find((a) => a.source === source);
+  if (!found) throw new Error(`No agent adapter for source "${source}"`);
+  return found;
+}
+
+// src/prefs.ts
+import { existsSync as existsSync13, mkdirSync as mkdirSync11, readFileSync as readFileSync16, writeFileSync as writeFileSync11 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join16 } from "path";
+var PREFS_PATH = join16(homedir11(), ".gipity", "prefs.json");
+function readPrefs() {
+  if (!existsSync13(PREFS_PATH)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync16(PREFS_PATH, "utf-8"));
+    return {
+      lastAgent: typeof parsed.lastAgent === "string" ? parsed.lastAgent : void 0,
+      lastModel: parsed.lastModel && typeof parsed.lastModel === "object" ? parsed.lastModel : void 0
+    };
+  } catch {
+    return {};
+  }
+}
+function writePrefs(update) {
+  try {
+    const current = readPrefs();
+    const next = {
+      ...current,
+      ...update,
+      lastModel: { ...current.lastModel, ...update.lastModel }
+    };
+    mkdirSync11(join16(homedir11(), ".gipity"), { recursive: true });
+    writeFileSync11(PREFS_PATH, JSON.stringify(next, null, 2) + "\n");
+  } catch {
+  }
+}
+
+// src/commands/build.ts
 var __clDir = dirname10(fileURLToPath2(import.meta.url));
 function readOwnPkg(fromDir) {
   for (let d = fromDir; ; d = dirname10(d)) {
-    const p = join16(d, "package.json");
-    if (existsSync13(p)) {
+    const p = join17(d, "package.json");
+    if (existsSync14(p)) {
       try {
-        const pkg2 = JSON.parse(readFileSync16(p, "utf-8"));
+        const pkg2 = JSON.parse(readFileSync17(p, "utf-8"));
         if (pkg2.name === "gipity") return pkg2;
       } catch {
       }
@@ -38669,12 +39075,12 @@ function localFsFallback(dir) {
   const topLevelEntries = [];
   const walk = (d, depth) => {
     try {
-      for (const name of readdirSync7(d).sort()) {
+      for (const name of readdirSync8(d).sort()) {
         if (isSyncIgnored(name)) continue;
         let isDir = false;
         let size = 0;
         try {
-          const st2 = statSync7(join16(d, name));
+          const st2 = statSync7(join17(d, name));
           isDir = st2.isDirectory();
           size = st2.isFile() ? st2.size : 0;
         } catch {
@@ -38683,7 +39089,7 @@ function localFsFallback(dir) {
         if (isDir) {
           folderCount++;
           if (depth === 0) topLevelEntries.push(`${name}/`);
-          walk(join16(d, name), depth + 1);
+          walk(join17(d, name), depth + 1);
         } else {
           fileCount++;
           totalBytes += size;
@@ -38716,8 +39122,8 @@ function hasStreamJsonFlag(args) {
 }
 function markFolderTrusted(dir) {
   try {
-    const file = join16(homedir11(), ".claude.json");
-    const cfg = existsSync13(file) ? JSON.parse(readFileSync16(file, "utf-8")) : {};
+    const file = join17(homedir12(), ".claude.json");
+    const cfg = existsSync14(file) ? JSON.parse(readFileSync17(file, "utf-8")) : {};
     if (typeof cfg !== "object" || cfg === null) return;
     if (typeof cfg.projects !== "object" || cfg.projects === null) cfg.projects = {};
     const entry = typeof cfg.projects[dir] === "object" && cfg.projects[dir] !== null ? cfg.projects[dir] : {};
@@ -38725,7 +39131,7 @@ function markFolderTrusted(dir) {
     entry.hasTrustDialogAccepted = true;
     cfg.projects[dir] = entry;
     const tmp = `${file}.gipity-tmp`;
-    writeFileSync10(tmp, JSON.stringify(cfg, null, 2));
+    writeFileSync12(tmp, JSON.stringify(cfg, null, 2));
     renameSync2(tmp, file);
   } catch {
   }
@@ -38747,10 +39153,22 @@ function suggestProjectName(existingSlugs) {
   }
   return `project-${Date.now().toString(36).slice(-6)}`;
 }
-var claudeCommand = new Command("claude").description("Set up and run Claude Code").option("--setup-only", "Do the Gipity setup but skip launching the agent").option("--new-project", "Create a fresh Gipity project instead of using cwd or the picker").option("--name <name>", "Name for --new-project (default: project-NNN)").option("--project <slug>", "Open an existing project by slug or id").option("--here", "Use the current directory instead of ~/GipityProjects/<slug>/").option("--quiet", "Suppress Claude's live progress output (headless --new-project/--project runs)").option("--model <model>", "Model for the Claude session, forwarded to claude (e.g. sonnet, opus, or a full id like claude-sonnet-5)").allowUnknownOption(true).allowExcessArguments(true).action(async (opts) => {
+function createLaunchCommand(name, cfg = {}) {
+  const cmd = new Command(name).description(cfg.presetAgent ? "Set up and run Claude Code (legacy alias of `gipity build`)" : "Start building from anywhere - pick a project, pick your coding agent, go").option("--setup-only", "Do the Gipity setup but skip launching the agent").option("--new-project", "Create a fresh Gipity project instead of using cwd or the picker").option("--name <name>", "Name for --new-project (default: project-NNN)").option("--project <slug>", "Open an existing project by slug or id").option("--here", "Use the current directory instead of ~/GipityProjects/<slug>/").option("--quiet", "Suppress the agent's live progress output (headless --new-project/--project runs)").option("--model <model>", "Model for the session (e.g. opus, sonnet - or skip it to use your agent's own default)").option("--bypass-approvals", "Skip the agent's interactive tool approvals (headless runs; the relay daemon sets this)").allowUnknownOption(true).allowExcessArguments(true);
+  if (!cfg.presetAgent) {
+    cmd.option("--agent <agent>", `Which coding agent to launch: ${AGENT_KEYS.join(", ")} (default: your last-used)`);
+  }
+  cmd.action(async (opts) => {
+    await runLaunch(name, cfg, opts);
+  });
+  return cmd;
+}
+var buildCommand = createLaunchCommand("build");
+var claudeCommand = createLaunchCommand("claude", { presetAgent: "claude" });
+async function runLaunch(cmdName, cmdCfg, opts) {
   try {
     const runStart = Date.now();
-    const rawArgs = process.argv.slice(process.argv.indexOf("claude") + 1);
+    const rawArgs = process.argv.slice(process.argv.indexOf(cmdName) + 1);
     if (rawArgs[0] === "install") {
       const r = ensureClaudeInstalled({ force: rawArgs.includes("--force") });
       if (r.alreadyPresent) console.log(`  ${success("Claude Code already installed.")}`);
@@ -38791,7 +39209,7 @@ var claudeCommand = new Command("claude").description("Set up and run Claude Cod
       process.exit(1);
     }
     if (nonInteractive && !getConfig() && !opts.newProject && !opts.project) {
-      console.error(`  ${error("No Gipity project in cwd. Run `gipity claude` (interactive) first, or pass --new-project / --project <slug>.")}`);
+      console.error(`  ${error("No Gipity project in cwd. Run `gipity build` (interactive) first, or pass --new-project / --project <slug>.")}`);
       process.exit(1);
     }
     if (!nonInteractive) {
@@ -38830,7 +39248,7 @@ var claudeCommand = new Command("claude").description("Set up and run Claude Cod
     let existing = getConfig();
     let forceAdoptCwd = false;
     if (existing && !opts.newProject && !opts.project && !nonInteractive) {
-      const cwdHasConfig = existsSync13(resolve14(process.cwd(), ".gipity.json"));
+      const cwdHasConfig = existsSync14(resolve14(process.cwd(), ".gipity.json"));
       if (!cwdHasConfig && isLikelyEmpty(process.cwd())) {
         const ancestorRoot = dirname10(getConfigPath());
         console.log(`  ${bold("You are inside an existing Gipity project.")}
@@ -38879,8 +39297,8 @@ var claudeCommand = new Command("claude").description("Set up and run Claude Cod
         }
         project = found;
       }
-      const projectDir2 = opts.here ? process.cwd() : join16(getProjectsRoot(), project.slug);
-      mkdirSync10(projectDir2, { recursive: true });
+      const projectDir2 = opts.here ? process.cwd() : join17(getProjectsRoot(), project.slug);
+      mkdirSync12(projectDir2, { recursive: true });
       process.chdir(projectDir2);
       clearConfigCache();
       let agentGuid = "";
@@ -38907,10 +39325,7 @@ var claudeCommand = new Command("claude").description("Set up and run Claude Cod
       } catch (err) {
         console.log(`  ${warning("Could not sync files (will retry on next prompt):")} ${err.message}`);
       }
-      setupClaudeHooks();
-      setupClaudeMd();
-      setupAgentsMd();
-      setupGitignore();
+      setupProjectTools();
       if (nonInteractive) {
         headlessNewProject = isNewProject;
       } else {
@@ -38922,10 +39337,7 @@ var claudeCommand = new Command("claude").description("Set up and run Claude Cod
       console.log(`  Project: ${brand(existing.projectSlug)} ${muted(`(${existing.projectGuid})`)}`);
       console.log(`  ${success("Already set up.")}
 `);
-      setupClaudeHooks();
-      setupClaudeMd();
-      setupAgentsMd();
-      setupGitignore();
+      setupProjectTools();
       let doSync = true;
       const projectRoot = dirname10(getConfigPath());
       const scan = scanForAdoption(projectRoot);
@@ -39008,8 +39420,8 @@ var claudeCommand = new Command("claude").description("Set up and run Claude Cod
       } else {
         project = result.project;
         isNewProject = result.kind === "create-new";
-        const projectDir2 = join16(getProjectsRoot(), project.slug);
-        mkdirSync10(projectDir2, { recursive: true });
+        const projectDir2 = join17(getProjectsRoot(), project.slug);
+        mkdirSync12(projectDir2, { recursive: true });
         process.chdir(projectDir2);
         clearConfigCache();
         try {
@@ -39037,15 +39449,44 @@ var claudeCommand = new Command("claude").description("Set up and run Claude Cod
         }
       }
       initialPrompt = "";
-      setupClaudeHooks();
-      setupClaudeMd();
-      setupAgentsMd();
-      setupGitignore();
+      setupProjectTools();
       console.log(`  ${success(`Project "${project.name}" ready.`)}
 `);
     }
     if (opts.setupOnly) {
-      console.log(`  Done. cd ${process.cwd()} && gipity claude`);
+      console.log(`  Done. cd ${process.cwd()} && gipity ${cmdName}`);
+      return;
+    }
+    const prefs = readPrefs();
+    let agentKey = cmdCfg.presetAgent ?? (typeof opts.agent === "string" ? opts.agent.toLowerCase() : void 0);
+    if (agentKey && !AGENT_KEYS.includes(agentKey)) {
+      console.error(`  ${error(`Unknown agent "${agentKey}".`)} ${muted(`Valid: ${AGENT_KEYS.join(", ")}`)}`);
+      process.exit(1);
+    }
+    if (!agentKey) {
+      if (nonInteractive) {
+        agentKey = prefs.lastAgent && AGENT_KEYS.includes(prefs.lastAgent) ? prefs.lastAgent : "claude";
+      } else {
+        agentKey = await pickAgent(prefs.lastAgent);
+      }
+    }
+    const adapter = getAdapter(agentKey);
+    const modelFlagGiven = rawArgs.some((a) => a === "--model" || a.startsWith("--model="));
+    let pickedModel = null;
+    if (!nonInteractive && !modelFlagGiven && !cmdCfg.presetAgent) {
+      pickedModel = await pickModel(adapter, prefs.lastModel?.[adapter.key] ?? null);
+      writePrefs({ lastAgent: adapter.key, lastModel: { [adapter.key]: pickedModel } });
+    }
+    if (adapter.key !== "claude") {
+      await launchNonClaudeAgent(adapter, {
+        cmdName,
+        opts,
+        rawArgs,
+        nonInteractive,
+        headlessOut,
+        runStart,
+        pickedModel
+      });
       return;
     }
     if (!isClaudeInstalled()) {
@@ -39071,7 +39512,7 @@ var claudeCommand = new Command("claude").description("Set up and run Claude Cod
           if (resumeSid) {
             try {
               const found = await get(
-                `/conversations/claude-code/by-session/${encodeURIComponent(resumeSid)}`
+                `/conversations/remote/by-session/${encodeURIComponent(resumeSid)}?source=claude_code`
               );
               convGuidForHooks = found.data.conversation_guid;
             } catch {
@@ -39079,8 +39520,8 @@ var claudeCommand = new Command("claude").description("Set up and run Claude Cod
           }
           if (!convGuidForHooks && cfg?.projectGuid) {
             const created = await post(
-              "/conversations/claude-code",
-              { project_guid: cfg.projectGuid, device_guid: device.guid, origin: "local" }
+              "/conversations/remote",
+              { project_guid: cfg.projectGuid, device_guid: device.guid, source: "claude_code", origin: "local" }
             );
             convGuidForHooks = created.data.conversation_guid;
           }
@@ -39091,10 +39532,10 @@ var claudeCommand = new Command("claude").description("Set up and run Claude Cod
         }
       }
     }
-    const claudeIdx = process.argv.indexOf("claude");
-    const rawClaudeArgs = process.argv.slice(claudeIdx + 1);
-    const gipityBooleanFlags = /* @__PURE__ */ new Set(["--setup-only", "--new-project", "--here", "--quiet"]);
-    const gipityValueFlags = ["--api-base", "--name", "--project"];
+    const cmdIdx = process.argv.indexOf(cmdName);
+    const rawClaudeArgs = process.argv.slice(cmdIdx + 1);
+    const gipityBooleanFlags = /* @__PURE__ */ new Set(["--setup-only", "--new-project", "--here", "--quiet", "--bypass-approvals"]);
+    const gipityValueFlags = ["--api-base", "--name", "--project", "--agent"];
     const claudeArgs = [];
     for (let i = 0; i < rawClaudeArgs.length; i++) {
       const arg = rawClaudeArgs[i];
@@ -39110,6 +39551,9 @@ var claudeCommand = new Command("claude").description("Set up and run Claude Cod
       console.log(`  ${bold("Launching Claude Code, powered by Gipity.")}`);
       console.log(`  ${muted("Just tell Claude what you'd like to build or do - everything Claude can do,")}`);
       console.log(`  ${muted("plus hosting, databases, and live deploys on Gipity.")}`);
+      if (convGuidForHooks) {
+        console.log(`  ${muted(`This session is saved to Gipity - watch it live at ${brand("prompt.gipity.ai")}. (--no-capture on init to disable.)`)}`);
+      }
       console.log("");
     }
     let allArgs;
@@ -39150,6 +39594,7 @@ Sending to Claude Code: ${userMsg}
       }
     } else {
       allArgs = initialPrompt ? [initialPrompt, ...claudeArgs] : claudeArgs;
+      if (pickedModel) allArgs.push("--model", pickedModel);
     }
     if (nonInteractive && (opts.newProject || opts.project)) {
       const hasPermFlag = allArgs.some((a) => a === "--permission-mode" || a.startsWith("--permission-mode=") || a === "--dangerously-skip-permissions");
@@ -39186,8 +39631,11 @@ Sending to Claude Code: ${userMsg}
 ${doneLine}
 
 `);
-      else console.log(`
+      else {
+        console.log(`
   ${doneLine}`);
+        console.log(`  ${muted(`Next time: gipity build from anywhere, or cd ${process.cwd()} && claude.`)}`);
+      }
       process.exit(code ?? 0);
     });
   } catch (err) {
@@ -39195,7 +39643,201 @@ ${doneLine}
   ${error(`Error: ${err.message}`)}`);
     process.exit(1);
   }
-});
+}
+async function pickAgent(lastUsed) {
+  const defaultKey = lastUsed && AGENT_KEYS.includes(lastUsed) ? lastUsed : "claude";
+  const defaultIdx = AGENT_ADAPTERS.findIndex((a) => a.key === defaultKey) + 1;
+  console.log(`  ${bold("Which coding agent?")}
+`);
+  AGENT_ADAPTERS.forEach((a, i) => {
+    const installed = binaryOnPath(a.binary) || a.key === "claude" && isClaudeInstalled();
+    const notes = [];
+    if (a.key === lastUsed) notes.push("last used");
+    if (!installed) notes.push(a.ensureInstalled ? "not installed - we'll install it" : "not installed");
+    if (a.key === "codex" && !a.hooksSupportedOnPlatform(process.platform)) {
+      notes.push("session recording unavailable on Windows");
+    }
+    const note = notes.length ? `  ${muted(`(${notes.join(", ")})`)}` : "";
+    console.log(`    ${bold(`${i + 1}.`)} ${a.displayName} ${muted(`(${a.providerName})`)}${note}`);
+  });
+  console.log("");
+  const choice = await pickOne("Choose", AGENT_ADAPTERS.length, defaultIdx);
+  console.log("");
+  return AGENT_ADAPTERS[choice - 1].key;
+}
+async function pickModel(adapter, lastUsed) {
+  console.log(`  ${bold("Which model?")}
+`);
+  const lastIsModel = lastUsed && adapter.models.some((m) => m.id === lastUsed);
+  const defaultIdx = lastIsModel ? adapter.models.findIndex((m) => m.id === lastUsed) + 2 : 1;
+  console.log(`    ${bold("1.")} Agent default ${muted(defaultIdx === 1 ? "(recommended)" : "")}`);
+  adapter.models.forEach((m, i) => {
+    const note = m.id === lastUsed ? `  ${muted("(last used)")}` : "";
+    console.log(`    ${bold(`${i + 2}.`)} ${m.label}${note}`);
+  });
+  console.log("");
+  const choice = await pickOne("Choose", adapter.models.length + 1, defaultIdx);
+  console.log("");
+  return choice === 1 ? null : adapter.models[choice - 2].id;
+}
+async function launchNonClaudeAgent(adapter, ctx) {
+  const { opts, rawArgs, nonInteractive, headlessOut, runStart, pickedModel } = ctx;
+  if (!binaryOnPath(adapter.binary)) {
+    let installed = false;
+    if (adapter.ensureInstalled) {
+      console.log(`  ${adapter.displayName} not found - installing it now...`);
+      installed = adapter.ensureInstalled();
+    }
+    if (!installed && !binaryOnPath(adapter.binary)) {
+      console.error(`  ${error(`${adapter.displayName} is not installed.`)} Install it with: ${adapter.installHint}`);
+      console.error(`  ${muted(`Then run: gipity ${ctx.cmdName} --agent ${adapter.key}`)}`);
+      process.exit(1);
+    }
+  }
+  const booleanFlags = /* @__PURE__ */ new Set(["--setup-only", "--new-project", "--here", "--quiet", "--bypass-approvals"]);
+  const valueFlags = ["--api-base", "--name", "--project", "--agent"];
+  let message = null;
+  let resume;
+  let model = pickedModel ?? void 0;
+  const extras = [];
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    if (booleanFlags.has(arg)) continue;
+    if (valueFlags.includes(arg)) {
+      i++;
+      continue;
+    }
+    if (valueFlags.some((f) => arg.startsWith(`${f}=`))) continue;
+    if (arg === "-p" || arg === "--print") {
+      message = rawArgs[++i] ?? "";
+      continue;
+    }
+    if (arg.startsWith("-p=") || arg.startsWith("--print=")) {
+      message = arg.slice(arg.indexOf("=") + 1);
+      continue;
+    }
+    if (arg === "--model") {
+      model = rawArgs[++i];
+      continue;
+    }
+    if (arg.startsWith("--model=")) {
+      model = arg.slice("--model=".length);
+      continue;
+    }
+    if (arg === "--resume") {
+      resume = rawArgs[++i];
+      continue;
+    }
+    if (arg.startsWith("--resume=")) {
+      resume = arg.slice("--resume=".length);
+      continue;
+    }
+    extras.push(arg);
+  }
+  let convGuid = process.env.GIPITY_CONVERSATION_GUID ?? null;
+  if (!convGuid) {
+    const device = getDevice();
+    const config = getConfig();
+    if (device && config?.projectGuid) {
+      try {
+        if (resume) {
+          try {
+            const found = await get(
+              `/conversations/remote/by-session/${encodeURIComponent(resume)}?source=${encodeURIComponent(adapter.source)}`
+            );
+            convGuid = found.data.conversation_guid;
+          } catch {
+          }
+        }
+        if (!convGuid) {
+          const created = await post(
+            "/conversations/remote",
+            { project_guid: config.projectGuid, device_guid: device.guid, source: adapter.source, origin: "local" }
+          );
+          convGuid = created.data.conversation_guid;
+        }
+      } catch (err) {
+        if (!nonInteractive) {
+          console.error(`  ${error(`Could not create Gipity conversation: ${err?.message || err}`)}`);
+        }
+      }
+    }
+  }
+  let agentArgs;
+  let syntheticSid = null;
+  if (nonInteractive) {
+    const bypass = Boolean(opts.bypassApprovals || opts.newProject || opts.project);
+    agentArgs = [
+      ...adapter.buildHeadlessArgs({ message: message ?? "", resume, model, bypassApprovals: bypass, jsonStream: false }),
+      ...extras
+    ];
+    if (adapter.headlessCapture) {
+      syntheticSid = resume ?? randomUUID();
+      if (!resume) agentArgs.push(...adapter.headlessCapture.sessionIdArgs(syntheticSid));
+    }
+    if (message) headlessOut(`
+Sending to ${adapter.displayName}: ${message}
+`);
+  } else {
+    agentArgs = [...adapter.buildInteractiveArgs({ resume, model }), ...extras];
+    console.log(`  ${bold(`Launching ${adapter.displayName}, powered by Gipity.`)}`);
+    console.log(`  ${muted(`Just tell ${adapter.displayName} what you'd like to build or do - plus hosting,`)}`);
+    console.log(`  ${muted("databases, and live deploys on Gipity.")}`);
+    if (convGuid) {
+      console.log(`  ${muted(`This session is saved to Gipity - watch it live at ${brand("prompt.gipity.ai")}. (--no-capture on init to disable.)`)}`);
+    }
+    if (adapter.oneTimeSetupNote) {
+      console.log(`  ${warning(adapter.oneTimeSetupNote)}`);
+    }
+    console.log("");
+  }
+  const childEnv2 = { ...process.env };
+  if (convGuid) childEnv2.GIPITY_CONVERSATION_GUID = convGuid;
+  const agentCmd = resolveCommand(adapter.binary);
+  const child = spawnCommand(agentCmd, agentArgs, {
+    stdio: "inherit",
+    cwd: process.cwd(),
+    env: childEnv2
+  });
+  child.on("error", (err) => {
+    console.error(`
+  ${error(err.code === "ENOENT" ? `${adapter.displayName} not found. Install it: ${adapter.installHint}` : `Failed to launch ${adapter.displayName}: ${err.message}`)}`);
+    process.exit(1);
+  });
+  child.on("exit", (code) => {
+    if (syntheticSid && convGuid) {
+      flushHeadlessCapture(adapter, syntheticSid, convGuid);
+    }
+    const doneLine = `Done (${formatElapsed2(Date.now() - runStart)})`;
+    if (nonInteractive) process.stderr.write(`
+${doneLine}
+
+`);
+    else {
+      console.log(`
+  ${doneLine}`);
+      console.log(`  ${muted(`Next time: gipity build from anywhere, or cd ${process.cwd()} && ${adapter.binary}.`)}`);
+    }
+    process.exit(code ?? 0);
+  });
+}
+function flushHeadlessCapture(adapter, sessionId, convGuid) {
+  const runner = join17(__clDir, "..", "hooks", "capture-runner.js");
+  if (!existsSync14(runner)) return;
+  const payload = JSON.stringify({ session_id: sessionId, cwd: process.cwd() });
+  const env = { ...process.env, GIPITY_CONVERSATION_GUID: convGuid };
+  for (const event of ["session-start", "stop"]) {
+    try {
+      spawnSyncCommand(process.execPath, [runner, adapter.key, event], {
+        input: payload,
+        env,
+        timeout: 6e4,
+        stdio: ["pipe", "ignore", "ignore"]
+      });
+    } catch {
+    }
+  }
+}
 async function pickOrCreateProject(projects, existingSlugs) {
   const filtered = projects.filter((p) => !p.is_default);
   const cwd = process.cwd();
@@ -39256,9 +39898,9 @@ async function pickFromAll(filtered) {
 function formatNewProjectLabel(existingSlugs) {
   const slug = suggestProjectName(existingSlugs);
   const root = getProjectsRoot();
-  const home = homedir11();
-  const display2 = root === home || root.startsWith(home + sep4) ? "~" + root.slice(home.length) : root;
-  return `${display2}${sep4}${slug}`;
+  const home = homedir12();
+  const display2 = root === home || root.startsWith(home + sep5) ? "~" + root.slice(home.length) : root;
+  return `${display2}${sep5}${slug}`;
 }
 async function confirmAdoptCwd(cwd) {
   process.stdout.write(`  ${muted("Scanning directory...")} `);
@@ -40919,11 +41561,11 @@ jobCommand.command("cancel <runGuid>").description("Cancel a queued or running j
   }
 }));
 jobCommand.command("run-local <name>").description("Run the job in a local Docker container against your local filesystem (no platform round-trip)").option("--image <image>", "Docker image to run inside", "easyclaw/sandbox:latest").option("--no-deps", "Skip pip/npm install even if a deps file is present").action(async (name, opts) => {
-  const { existsSync: existsSync23, statSync: statSync10 } = await import("node:fs");
-  const { resolve: resolve19, join: join25 } = await import("node:path");
+  const { existsSync: existsSync24, statSync: statSync10 } = await import("node:fs");
+  const { resolve: resolve20, join: join26 } = await import("node:path");
   const { spawnCommand: spawnCommand2, spawnSyncCommand: spawnSyncCommand2 } = await Promise.resolve().then(() => (init_platform(), platform_exports));
-  const jobDir = resolve19(process.cwd(), "jobs", name);
-  if (!existsSync23(jobDir) || !statSync10(jobDir).isDirectory()) {
+  const jobDir = resolve20(process.cwd(), "jobs", name);
+  if (!existsSync24(jobDir) || !statSync10(jobDir).isDirectory()) {
     console.error(error(`jobs/${name}/ not found in current directory`));
     process.exit(1);
   }
@@ -40944,7 +41586,7 @@ jobCommand.command("run-local <name>").description("Run the job in a local Docke
     },
     { file: "main.sh", runtime: "bash", entry: "bash" }
   ];
-  const picked = variants.find((v7) => existsSync23(join25(jobDir, v7.file)));
+  const picked = variants.find((v7) => existsSync24(join26(jobDir, v7.file)));
   if (!picked) {
     console.error(error(`No main.py / main.js / main.sh found under jobs/${name}/`));
     process.exit(1);
@@ -40969,7 +41611,7 @@ jobCommand.command("run-local <name>").description("Run the job in a local Docke
     "-v",
     `${jobDir}:/work`
   ];
-  const needsDeps = opts.deps !== false && picked.depsFile && picked.installCmd && existsSync23(join25(jobDir, picked.depsFile));
+  const needsDeps = opts.deps !== false && picked.depsFile && picked.installCmd && existsSync24(join26(jobDir, picked.depsFile));
   const handlerCmd = `${picked.entry} /work/${picked.file}`;
   let shellCmd;
   if (needsDeps && picked.installCmd) {
@@ -41144,7 +41786,7 @@ emailCommand.command("log").description("Recent email() sends from your app").op
 init_api();
 init_config();
 init_colors();
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
+import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync13 } from "fs";
 import { resolve as resolvePath2, dirname as dirname11, relative as relative5, isAbsolute } from "path";
 
 // src/provider-docs.ts
@@ -41165,7 +41807,7 @@ async function downloadFile(url, filename) {
   const buffer = Buffer.from(await res.arrayBuffer());
   const outPath = correctExtension(filename, buffer);
   ensureOutputDir(outPath);
-  writeFileSync11(outPath, buffer);
+  writeFileSync13(outPath, buffer);
   const savedPath = resolvePath2(outPath);
   await pushGenerated(savedPath);
   return savedPath;
@@ -41201,7 +41843,7 @@ function correctExtension(filename, buf) {
 function ensureOutputDir(output) {
   const dir = dirname11(resolvePath2(output));
   try {
-    mkdirSync11(dir, { recursive: true });
+    mkdirSync13(dir, { recursive: true });
   } catch (err) {
     throw new Error(`can't create the output directory ${dir} (${err.code || err.message}). Pick a different -o path.`);
   }
@@ -41434,14 +42076,14 @@ var generateCommand = new Command("generate").description("Generate images, vide
 init_api();
 init_config();
 init_colors();
-import { existsSync as existsSync14, readFileSync as readFileSync17 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync18 } from "fs";
+import { join as join18 } from "path";
 function readInstalledKitReadme(name) {
   const root = getProjectRoot() ?? process.cwd();
-  const kitDir = join17(root, "src", "packages", name);
-  if (!existsSync14(join17(kitDir, "package.json"))) return null;
-  const readme = join17(kitDir, "README.md");
-  return existsSync14(readme) ? readFileSync17(readme, "utf-8") : null;
+  const kitDir = join18(root, "src", "packages", name);
+  if (!existsSync15(join18(kitDir, "package.json"))) return null;
+  const readme = join18(kitDir, "README.md");
+  return existsSync15(readme) ? readFileSync18(readme, "utf-8") : null;
 }
 var skillCommand = new Command("skill").description("Task docs - read the matching skill before building");
 skillCommand.command("list").description("List skills").option("--json", "Output as JSON").action((opts) => run("List", async () => {
@@ -41614,7 +42256,7 @@ var domainCommand = new Command("domain").description("Manage custom domains").a
 }));
 
 // src/commands/realtime.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { dirname as dirname12, resolve as resolve15 } from "path";
 init_api();
 init_config();
@@ -41622,7 +42264,7 @@ init_colors();
 function hasDeployManifest() {
   const cfgPath = getConfigPath();
   if (!cfgPath) return false;
-  return existsSync15(resolve15(dirname12(cfgPath), "gipity.yaml"));
+  return existsSync16(resolve15(dirname12(cfgPath), "gipity.yaml"));
 }
 var roomCommand = new Command("room").description("Manage realtime rooms").argument("[action]", "list | create | delete | info", "list").argument("[name]", "room name (for create | delete | info)").option("--type <type>", "room type for create: state | relay", "state").option("--auth <level>", "auth level for create: public | user", "public").option("--max-clients <n>", "max clients for create (1-200)").option("--json", "Output as JSON").action((action, name, opts) => run("Realtime room", async () => {
   const config = requireConfig();
@@ -41798,7 +42440,7 @@ async function pollTestStatus(projectGuid, runGuid, opts) {
         }
       }
     }
-    await new Promise((resolve19) => setTimeout(resolve19, getPollInterval()));
+    await new Promise((resolve20) => setTimeout(resolve20, getPollInterval()));
   }
 }
 var testCommand = new Command("test").description("Run tests").argument("[path]", 'Test path filter (e.g. "api", "e2e/portal")').option("--filter <path>", "Alias for the positional test path filter").option("--timeout <ms>", "Per-test timeout in ms", "30000").option("--retry <n>", "Retry failed tests N times", "0").option("--no-sync", "Skip sync-up before tests").option("--json", "Output as JSON").action((pathFilter, opts) => run("Test", async () => {
@@ -42008,21 +42650,21 @@ var locationCommand = new Command("location").description("Show location").argum
 }));
 
 // src/commands/doctor.ts
-import { existsSync as existsSync17, readFileSync as readFileSync19, statSync as statSync8 } from "fs";
-import { join as join19 } from "path";
-import { homedir as homedir13 } from "os";
+import { existsSync as existsSync18, readFileSync as readFileSync20, statSync as statSync8 } from "fs";
+import { join as join20, resolve as resolve16 } from "path";
+import { homedir as homedir14 } from "os";
 
 // src/updater/state.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync12, mkdirSync as mkdirSync12, existsSync as existsSync16 } from "fs";
-import { join as join18 } from "path";
-import { homedir as homedir12 } from "os";
-var GIPITY_DIR = join18(homedir12(), ".gipity");
-var LOCAL_DIR = join18(GIPITY_DIR, "local");
-var LOCAL_PKG_DIR = join18(LOCAL_DIR, "node_modules", "gipity");
-var LOCAL_ENTRY = join18(LOCAL_PKG_DIR, "dist", "index.js");
-var STATE_FILE = join18(GIPITY_DIR, "update-state.json");
-var SETTINGS_FILE = join18(GIPITY_DIR, "settings.json");
-var UPDATE_LOG = join18(GIPITY_DIR, "update.log");
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync14, mkdirSync as mkdirSync14, existsSync as existsSync17 } from "fs";
+import { join as join19 } from "path";
+import { homedir as homedir13 } from "os";
+var GIPITY_DIR = join19(homedir13(), ".gipity");
+var LOCAL_DIR = join19(GIPITY_DIR, "local");
+var LOCAL_PKG_DIR = join19(LOCAL_DIR, "node_modules", "gipity");
+var LOCAL_ENTRY = join19(LOCAL_PKG_DIR, "dist", "index.js");
+var STATE_FILE = join19(GIPITY_DIR, "update-state.json");
+var SETTINGS_FILE = join19(GIPITY_DIR, "settings.json");
+var UPDATE_LOG = join19(GIPITY_DIR, "update.log");
 var DEFAULT_STATE = {
   installedVersion: null,
   lastCheckAt: 0,
@@ -42033,24 +42675,24 @@ var DEFAULT_SETTINGS = {
   autoUpdates: true
 };
 function ensureDir() {
-  mkdirSync12(GIPITY_DIR, { recursive: true });
+  mkdirSync14(GIPITY_DIR, { recursive: true });
 }
 function readState() {
-  if (!existsSync16(STATE_FILE)) return { ...DEFAULT_STATE };
+  if (!existsSync17(STATE_FILE)) return { ...DEFAULT_STATE };
   try {
-    return { ...DEFAULT_STATE, ...JSON.parse(readFileSync18(STATE_FILE, "utf-8")) };
+    return { ...DEFAULT_STATE, ...JSON.parse(readFileSync19(STATE_FILE, "utf-8")) };
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState(state) {
   ensureDir();
-  writeFileSync12(STATE_FILE, JSON.stringify(state, null, 2));
+  writeFileSync14(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function readSettings() {
-  if (!existsSync16(SETTINGS_FILE)) return { ...DEFAULT_SETTINGS };
+  if (!existsSync17(SETTINGS_FILE)) return { ...DEFAULT_SETTINGS };
   try {
-    return { ...DEFAULT_SETTINGS, ...JSON.parse(readFileSync18(SETTINGS_FILE, "utf-8")) };
+    return { ...DEFAULT_SETTINGS, ...JSON.parse(readFileSync19(SETTINGS_FILE, "utf-8")) };
   } catch {
     return { ...DEFAULT_SETTINGS };
   }
@@ -42066,7 +42708,7 @@ function updatesDisabled() {
 init_colors();
 init_auth();
 var NODE_MIN_MAJOR = 18;
-function versionManagerNode(execPath, env = process.env, home = homedir13()) {
+function versionManagerNode(execPath, env = process.env, home = homedir14()) {
   const norm = (s) => s.replace(/\\/g, "/").replace(/\/+$/, "") + "/";
   const p = norm(execPath);
   const h = norm(home);
@@ -42083,10 +42725,10 @@ function versionManagerNode(execPath, env = process.env, home = homedir13()) {
   return null;
 }
 function localVersion() {
-  const pkgPath = join19(LOCAL_PKG_DIR, "package.json");
-  if (!existsSync17(pkgPath)) return null;
+  const pkgPath = join20(LOCAL_PKG_DIR, "package.json");
+  if (!existsSync18(pkgPath)) return null;
   try {
-    return JSON.parse(readFileSync19(pkgPath, "utf-8")).version ?? null;
+    return JSON.parse(readFileSync20(pkgPath, "utf-8")).version ?? null;
   } catch {
     return null;
   }
@@ -42094,7 +42736,7 @@ function localVersion() {
 function shimVersion() {
   try {
     const url = new URL("../../package.json", import.meta.url);
-    return JSON.parse(readFileSync19(url, "utf-8")).version;
+    return JSON.parse(readFileSync20(url, "utf-8")).version;
   } catch {
     return "unknown";
   }
@@ -42109,7 +42751,7 @@ function rel(t) {
 }
 function relayAutostartInstalled() {
   try {
-    return existsSync17(planFor({ cliPath: resolveCliPath() }).path);
+    return existsSync18(planFor({ cliPath: resolveCliPath() }).path);
   } catch (err) {
     if (err instanceof UnsupportedPlatformError) return null;
     return null;
@@ -42147,7 +42789,7 @@ function gatherEnv(opts = {}) {
   const cli = {
     shim_version: shimVersion(),
     local_version: localVersion(),
-    local_install_ok: existsSync17(LOCAL_ENTRY),
+    local_install_ok: existsSync18(LOCAL_ENTRY),
     auto_updates: !dis.disabled,
     updates_disabled_reason: dis.disabled ? dis.reason ?? null : null,
     last_check_at: updState.lastCheckAt,
@@ -42177,12 +42819,15 @@ var doctorCommand = new Command("doctor").description("Check install + environme
   console.log(`${muted("claude code     ")} installed ${yn(env.claude.installed)} \xB7 authenticated ${yn(env.claude.authenticated)}`);
   const autostartLabel = env.relay.autostart === null ? muted("n/a") : yn(env.relay.autostart);
   console.log(`${muted("relay           ")} paired ${yn(env.relay.paired)} \xB7 running ${yn(env.relay.running)} \xB7 autostart ${autostartLabel}${env.relay.paused ? warning(" \xB7 paused") : ""}${env.relay.device ? muted(`  (${env.relay.device.name})`) : ""}`);
-  console.log(`${muted("ready           ")} ${env.ready ? success("yes") : warning("no - run `gipity claude` (or the desktop app) to finish setup")}`);
+  if (existsSync18(resolve16(process.cwd(), ".codex", "hooks.json"))) {
+    console.log(`${muted("codex hooks     ")} ${warning("written")} - session capture needs a one-time approval: run /hooks inside Codex in this project`);
+  }
+  console.log(`${muted("ready           ")} ${env.ready ? success("yes") : warning("no - run `gipity build` (or the desktop app) to finish setup")}`);
   const state = readState();
   const settings = readSettings();
   const dis = updatesDisabled();
   const local = localVersion();
-  const localOk = existsSync17(LOCAL_ENTRY);
+  const localOk = existsSync18(LOCAL_ENTRY);
   console.log("");
   console.log(bold("CLI install"));
   console.log(`${muted("shim version    ")} ${shimVersion()}`);
@@ -42190,17 +42835,17 @@ var doctorCommand = new Command("doctor").description("Check install + environme
   console.log(`${muted("local install   ")} ${LOCAL_PKG_DIR}`);
   console.log("");
   console.log(`${muted("auto-updates    ")} ${dis.disabled ? warning(`disabled (${dis.reason})`) : success("enabled")}`);
-  console.log(`${muted("settings file   ")} ${existsSync17(SETTINGS_FILE) ? SETTINGS_FILE : dim("(default)")}  autoUpdates=${settings.autoUpdates}`);
+  console.log(`${muted("settings file   ")} ${existsSync18(SETTINGS_FILE) ? SETTINGS_FILE : dim("(default)")}  autoUpdates=${settings.autoUpdates}`);
   console.log(`${muted("last check      ")} ${rel(state.lastCheckAt)}`);
   console.log(`${muted("last error      ")} ${state.lastError ? error(state.lastError) : dim("none")}`);
-  console.log(`${muted("state file      ")} ${existsSync17(STATE_FILE) ? STATE_FILE : dim("(none yet)")}`);
-  console.log(`${muted("update log      ")} ${existsSync17(UPDATE_LOG) ? `${UPDATE_LOG} (${statSync8(UPDATE_LOG).size} bytes)` : dim("(none yet)")}`);
+  console.log(`${muted("state file      ")} ${existsSync18(STATE_FILE) ? STATE_FILE : dim("(none yet)")}`);
+  console.log(`${muted("update log      ")} ${existsSync18(UPDATE_LOG) ? `${UPDATE_LOG} (${statSync8(UPDATE_LOG).size} bytes)` : dim("(none yet)")}`);
   console.log("");
   console.log(dim("Force an update with: gipity update"));
 });
 
 // src/updater/check.ts
-import { appendFileSync, existsSync as existsSync18 } from "fs";
+import { appendFileSync, existsSync as existsSync19 } from "fs";
 init_platform();
 var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
 function log(line) {
@@ -42235,7 +42880,7 @@ function installVersion(version) {
     stdio: "ignore"
   });
   if (res.error) log(`npm spawn failed: ${res.error.message}`);
-  return res.status === 0 && existsSync18(LOCAL_ENTRY);
+  return res.status === 0 && existsSync19(LOCAL_ENTRY);
 }
 async function runCheck(opts = {}) {
   const state = readState();
@@ -42309,17 +42954,17 @@ var updateCommand = new Command("update").description("Update the CLI").action(a
 init_api();
 init_utils();
 init_colors();
-import { existsSync as existsSync21, readFileSync as readFileSync22, unlinkSync as unlinkSync7 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync23, unlinkSync as unlinkSync7 } from "fs";
 import { spawn as spawn2 } from "child_process";
 
 // src/relay/daemon.ts
 init_platform();
 init_config();
-import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync14, existsSync as existsSync20, readFileSync as readFileSync21, writeFileSync as writeFileSync13, chmodSync as chmodSync3, closeSync as closeSync4, openSync as openSync4, unlinkSync as unlinkSync6 } from "fs";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync16, existsSync as existsSync21, readFileSync as readFileSync22, writeFileSync as writeFileSync15, chmodSync as chmodSync3, closeSync as closeSync4, openSync as openSync4, unlinkSync as unlinkSync6 } from "fs";
 import { stat, readFile } from "fs/promises";
 import { createInterface as createInterface2 } from "readline";
-import { homedir as homedir15, hostname as hostname5, platform as osPlatform3, loadavg as loadavg2, freemem as freemem2, totalmem as totalmem2, cpus as cpus2 } from "os";
-import { join as join22 } from "path";
+import { homedir as homedir16, hostname as hostname5, platform as osPlatform3, loadavg as loadavg2, freemem as freemem2, totalmem as totalmem2, cpus as cpus2 } from "os";
+import { join as join23 } from "path";
 init_auth();
 init_api();
 
@@ -43025,7 +43670,7 @@ var DeltaBatcher = class {
 };
 
 // src/relay/daemon.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/relay/agent-token.ts
 init_api();
@@ -43074,22 +43719,22 @@ async function revokeRelayAgentToken() {
 // src/relay/diagnostics.ts
 init_platform();
 init_client_context();
-import { cpus, freemem, totalmem, loadavg, release, uptime, homedir as homedir14 } from "os";
-import { statfsSync, readdirSync as readdirSync8 } from "fs";
-import { join as join20 } from "path";
+import { cpus, freemem, totalmem, loadavg, release, uptime, homedir as homedir15 } from "os";
+import { statfsSync, readdirSync as readdirSync9 } from "fs";
+import { join as join21 } from "path";
 var PROBE_TIMEOUT_MS = 4e3;
 function parseVersion(out) {
   const m = out.match(/\d+\.\d+(?:\.\d+)?(?:[-.\w]*)?/);
   return m ? m[0] : void 0;
 }
 function runProbe(cmd, args) {
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     let out = "";
     let settled = false;
     const done = (s) => {
       if (!settled) {
         settled = true;
-        resolve19(s);
+        resolve20(s);
       }
     };
     let child;
@@ -43143,12 +43788,12 @@ async function detectGpu() {
 function diskUsage() {
   try {
     if (typeof statfsSync !== "function") return void 0;
-    const st2 = statfsSync(join20(homedir14(), "GipityProjects"), { bigint: false });
+    const st2 = statfsSync(join21(homedir15(), "GipityProjects"), { bigint: false });
     if (!st2 || !st2.bsize) return void 0;
     return { total: st2.bsize * st2.blocks, free: st2.bsize * st2.bavail };
   } catch {
     try {
-      const st2 = statfsSync(homedir14(), { bigint: false });
+      const st2 = statfsSync(homedir15(), { bigint: false });
       return { total: st2.bsize * st2.blocks, free: st2.bsize * st2.bavail };
     } catch {
       return void 0;
@@ -43157,7 +43802,7 @@ function diskUsage() {
 }
 function localProjectCount() {
   try {
-    return readdirSync8(join20(homedir14(), "GipityProjects"), { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).length;
+    return readdirSync9(join21(homedir15(), "GipityProjects"), { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).length;
   } catch {
     return void 0;
   }
@@ -43170,15 +43815,17 @@ async function collectDiagnostics() {
       return [];
     }
   })();
-  const [claude, codex, cursor, gpu] = await Promise.all([
+  const [claude, codex, grok, cursor, gpu] = await Promise.all([
     probeVersion("claude"),
     probeVersion("codex"),
+    probeVersion("grok"),
     probeVersion("cursor"),
     detectGpu()
   ]);
   const agents = {};
   if (claude) agents.claude_code = claude;
   if (codex) agents.codex = codex;
+  if (grok) agents.grok = grok;
   if (cursor) agents.cursor = cursor;
   return {
     collected_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -43286,8 +43933,8 @@ var SessionPool = class {
     const done = new Promise((r) => {
       markDone = r;
     });
-    return new Promise((resolve19, reject) => {
-      const turn = { onMessage: p.onMessage, resolve: resolve19, reject, interruptRequested: false, wasHot, done, markDone };
+    return new Promise((resolve20, reject) => {
+      const turn = { onMessage: p.onMessage, resolve: resolve20, reject, interruptRequested: false, wasHot, done, markDone };
       session.current = turn;
       session.state = "running";
       session.lastActivityAt = Date.now();
@@ -43464,7 +44111,7 @@ var SessionPool = class {
 // src/relay/daemon.ts
 init_config();
 init_api();
-var RELAY_LOG_PATH = join22(homedir15(), ".gipity", "relay.log");
+var RELAY_LOG_PATH = join23(homedir16(), ".gipity", "relay.log");
 var HEARTBEAT_INTERVAL_MS = parseInt(process.env.GIPITY_RELAY_HEARTBEAT_MS || "60000", 10);
 var DIAGNOSTICS_INTERVAL_MS = parseInt(process.env.GIPITY_RELAY_DIAGNOSTICS_MS || String(24 * 60 * 60 * 1e3), 10);
 var LONG_POLL_TIMEOUT_MS = parseInt(process.env.GIPITY_RELAY_POLL_TIMEOUT_MS || "35000", 10);
@@ -43564,7 +44211,7 @@ function lockLogPerms(dir, file) {
     chmodSync3(dir, 448);
   } catch {
   }
-  if (!existsSync20(file)) {
+  if (!existsSync21(file)) {
     try {
       closeSync4(openSync4(file, "a", 384));
     } catch {
@@ -43581,8 +44228,8 @@ function log2(level, msg, extra) {
   const pretty = `${C7.dim(hhmmss())} ${badge(level)} ${C7.bold(msg)}${formatExtra(extra)}`;
   process.stderr.write(pretty + "\n");
   try {
-    const dir = join22(homedir15(), ".gipity");
-    mkdirSync14(dir, { recursive: true });
+    const dir = join23(homedir16(), ".gipity");
+    mkdirSync16(dir, { recursive: true });
     lockLogPerms(dir, RELAY_LOG_PATH);
     const json = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level, msg, ...extra ?? {} });
     appendFileSync3(RELAY_LOG_PATH, json + "\n");
@@ -43706,10 +44353,10 @@ async function heartbeatLoop(ctx) {
     }
     await Promise.race([
       sleep4(HEARTBEAT_INTERVAL_MS, ctx.abort.signal),
-      new Promise((resolve19) => {
+      new Promise((resolve20) => {
         heartbeatPoke = () => {
           heartbeatPoke = null;
-          resolve19();
+          resolve20();
         };
       })
     ]);
@@ -43753,9 +44400,9 @@ async function dispatchLoop(ctx, opts) {
     while (inflight.size >= MAX_CONCURRENT_DISPATCHES && !ctx.abort.signal.aborted) {
       await Promise.race([
         ...inflight,
-        new Promise((resolve19) => {
-          if (ctx.abort.signal.aborted) return resolve19();
-          ctx.abort.signal.addEventListener("abort", () => resolve19(), { once: true });
+        new Promise((resolve20) => {
+          if (ctx.abort.signal.aborted) return resolve20();
+          ctx.abort.signal.addEventListener("abort", () => resolve20(), { once: true });
         })
       ]);
     }
@@ -43982,7 +44629,7 @@ function isSafeSessionId(s) {
 function transcriptPathFor(cwd, sessionId) {
   if (!isSafeSessionId(sessionId)) return null;
   const slug = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-  return join22(homedir15(), ".claude", "projects", slug, `${sessionId}.jsonl`);
+  return join23(homedir16(), ".claude", "projects", slug, `${sessionId}.jsonl`);
 }
 function formatDuration(ms2) {
   const totalSec = ms2 / 1e3;
@@ -44051,7 +44698,7 @@ async function handleDispatch(claimed) {
     { onWarn: (msg, meta) => log2("warn", msg, { id: d.short_guid, ...meta }) }
   );
   const pushSystem = (content) => {
-    queue.push({ kind: "system", content, ts: (/* @__PURE__ */ new Date()).toISOString(), source_uuid: randomUUID() });
+    queue.push({ kind: "system", content, ts: (/* @__PURE__ */ new Date()).toISOString(), source_uuid: randomUUID2() });
   };
   const flushQueue = async () => {
     await queue.close(3e4);
@@ -44097,11 +44744,16 @@ async function handleDispatch(claimed) {
     }
     if (!syncFailed) pushSystem(bootstrapped ? "Project files synced." : "Attached files synced.");
   }
+  const adapter = getAdapterBySource(d.remote_type ?? "claude_code");
+  if (adapter.key !== "claude") {
+    await handleNonClaudeDispatch(adapter, d, cwd, queue, pushSystem, flushQueue);
+    return;
+  }
   if (SESSION_POOL_ENABLED) {
     const handled = await tryHandleViaPool(d, cwd, queue, pushSystem, flushQueue);
     if (handled) return;
   }
-  const args = ["claude", "-p", d.message, "--permission-mode", "bypassPermissions"];
+  const args = ["build", "--agent", "claude", "-p", d.message, "--permission-mode", "bypassPermissions"];
   args.push("--append-system-prompt", GIPITY_QUESTION_PROTOCOL);
   if (d.model) {
     args.push("--model", d.model);
@@ -44109,7 +44761,7 @@ async function handleDispatch(claimed) {
   if (d.kind === "resume" && d.remote_session_id) {
     args.push("--resume", d.remote_session_id);
   }
-  log2("debug", "spawning gipity claude", {
+  log2("debug", "spawning gipity build --agent claude", {
     id: d.short_guid,
     cwd,
     args,
@@ -44158,8 +44810,8 @@ async function handleDispatch(claimed) {
   const header = `Running Claude Code - ${counts.join(" + ")} words${resumeNote}`;
   const ts2 = (/* @__PURE__ */ new Date()).toISOString();
   queue.push(
-    { kind: "prompt", prompt: d.message, ts: ts2, source_uuid: randomUUID() },
-    { kind: "system", content: header, ts: ts2, source_uuid: randomUUID() }
+    { kind: "prompt", prompt: d.message, ts: ts2, source_uuid: randomUUID2() },
+    { kind: "system", content: header, ts: ts2, source_uuid: randomUUID2() }
   );
   const t0 = Date.now();
   let exitCode = 1;
@@ -44206,7 +44858,61 @@ async function handleDispatch(claimed) {
     await ack(d.short_guid, "done", void 0, metrics);
   } else {
     log2("warn", "dispatch child exited nonzero", { id: d.short_guid, exitCode, ms: ms2 });
-    await ack(d.short_guid, "error", `gipity claude exited with code ${exitCode}${stderrNote}`);
+    await ack(d.short_guid, "error", `Claude Code exited with code ${exitCode}${stderrNote}`);
+  }
+}
+async function handleNonClaudeDispatch(adapter, d, cwd, queue, pushSystem, flushQueue) {
+  const args = ["build", "--agent", adapter.key, "-p", d.message, "--bypass-approvals"];
+  if (d.model) args.push("--model", d.model);
+  if (d.kind === "resume" && d.remote_session_id) args.push("--resume", d.remote_session_id);
+  log2("debug", `spawning gipity build --agent ${adapter.key}`, {
+    id: d.short_guid,
+    cwd,
+    args,
+    conv: d.conversation_guid,
+    chain: d.kind === "resume" ? `resume ${d.remote_session_id}` : "start (fresh session)"
+  });
+  const words = d.message.trim().split(/\s+/).filter(Boolean).length;
+  pushSystem(`Running ${adapter.displayName} - ${words.toLocaleString("en-US")} words`);
+  const t0 = Date.now();
+  let exitCode = 1;
+  let spawnErr = null;
+  let killed = false;
+  let runtimeLimit = false;
+  let stderrTail = "";
+  try {
+    const result = await spawnGipityClaude(args, cwd, d, queue, { streamJson: false });
+    exitCode = result.exitCode;
+    killed = result.killed;
+    runtimeLimit = result.runtimeLimit ?? false;
+    stderrTail = result.stderrTail ?? "";
+  } catch (err) {
+    spawnErr = err?.message || String(err);
+    log2("error", "dispatch spawn failed", { id: d.short_guid, err: spawnErr });
+  }
+  const dur = formatDuration(Date.now() - t0);
+  if (!spawnErr && !killed) {
+    try {
+      await spawnSync2(cwd, PROJECT_SYNC_TIMEOUT_MS);
+    } catch (err) {
+      log2("warn", "sync after dispatch failed", { id: d.short_guid, err: err?.message });
+    }
+  }
+  const stderrNote = stderrTail ? `: ${stderrTail.slice(0, 300)}` : "";
+  const tail = runtimeLimit ? `stopped after ${dur} (runtime limit)` : killed ? `cancelled (${dur})` : spawnErr ? `failed (${dur}: ${spawnErr})` : exitCode === 0 ? `finished (${dur})` : `failed (${dur}, exit ${exitCode}${stderrNote})`;
+  pushSystem(`${adapter.displayName} ${tail}`);
+  await flushQueue();
+  if (runtimeLimit) {
+    await ack(d.short_guid, "error", `${adapter.displayName} stopped after ${dur} (runtime limit)`);
+  } else if (killed) {
+    await ack(d.short_guid, "cancelled");
+  } else if (spawnErr) {
+    await ack(d.short_guid, "error", spawnErr);
+  } else if (exitCode === 0) {
+    log2("info", "dispatch done", { id: d.short_guid, agent: adapter.key });
+    await ack(d.short_guid, "done");
+  } else {
+    await ack(d.short_guid, "error", `${adapter.displayName} exited with code ${exitCode}${stderrNote}`);
   }
 }
 async function wrapPoolMessage(d, cwd, resume) {
@@ -44248,8 +44954,8 @@ async function tryHandleViaPool(d, cwd, queue, pushSystem, flushQueue) {
   const words = d.message.trim().split(/\s+/).filter(Boolean).length;
   const ts0 = (/* @__PURE__ */ new Date()).toISOString();
   queue.push(
-    { kind: "prompt", prompt: d.message, ts: ts0, source_uuid: randomUUID() },
-    { kind: "system", content: `Running Claude Code - ${words.toLocaleString("en-US")} words${wasLive ? " (hot session)" : ""}`, ts: ts0, source_uuid: randomUUID() }
+    { kind: "prompt", prompt: d.message, ts: ts0, source_uuid: randomUUID2() },
+    { kind: "system", content: `Running Claude Code - ${words.toLocaleString("en-US")} words${wasLive ? " (hot session)" : ""}`, ts: ts0, source_uuid: randomUUID2() }
   );
   const phases = new PhaseTracker();
   const deltaAcc = new DeltaAccumulator(getRelaySecrets);
@@ -44304,7 +45010,7 @@ async function tryHandleViaPool(d, cwd, queue, pushSystem, flushQueue) {
     const ts2 = (/* @__PURE__ */ new Date()).toISOString();
     for (const e of entries) {
       e.ts = ts2;
-      if (!e.source_uuid) e.source_uuid = randomUUID();
+      if (!e.source_uuid) e.source_uuid = randomUUID2();
     }
     queue.push(...entries);
   };
@@ -44377,11 +45083,11 @@ async function resolveCwdForProject(d) {
     throw new Error(`Invalid project slug: ${JSON.stringify(d.project_slug)}`);
   }
   const root = getProjectsRoot();
-  const path5 = join22(root, d.project_slug);
-  const configPath = join22(path5, ".gipity.json");
-  if (existsSync20(configPath)) {
+  const path5 = join23(root, d.project_slug);
+  const configPath = join23(path5, ".gipity.json");
+  if (existsSync21(configPath)) {
     try {
-      const cfg = JSON.parse(readFileSync21(configPath, "utf-8"));
+      const cfg = JSON.parse(readFileSync22(configPath, "utf-8"));
       if (cfg.projectGuid === d.project_guid) return { cwd: path5, bootstrapped: false };
       log2("warn", "project dir exists but guid mismatch - using it anyway", {
         path: path5,
@@ -44393,9 +45099,9 @@ async function resolveCwdForProject(d) {
     }
   }
   log2("info", "bootstrapping new project dir", { slug: d.project_slug, path: path5 });
-  mkdirSync14(path5, { recursive: true });
+  mkdirSync16(path5, { recursive: true });
   const apiBase2 = getApiBaseOverride() || DEFAULT_API_BASE;
-  writeFileSync13(configPath, JSON.stringify({
+  writeFileSync15(configPath, JSON.stringify({
     projectGuid: d.project_guid,
     projectSlug: d.project_slug,
     accountSlug: d.account_slug,
@@ -44407,10 +45113,7 @@ async function resolveCwdForProject(d) {
   const origCwd = process.cwd();
   try {
     process.chdir(path5);
-    setupClaudeHooks();
-    setupClaudeMd();
-    setupAgentsMd();
-    setupGitignore();
+    setupProjectTools();
   } finally {
     process.chdir(origCwd);
   }
@@ -44475,7 +45178,7 @@ async function killRunningForConv(convGuid) {
     }
   }
   const graceTimers = [];
-  const escalate = new Promise((resolve19) => {
+  const escalate = new Promise((resolve20) => {
     const t = setTimeout(() => {
       for (const e of matches) {
         log2("warn", "previous dispatch ignored SIGTERM - escalating to SIGKILL", { conv: convGuid });
@@ -44484,7 +45187,7 @@ async function killRunningForConv(convGuid) {
         } catch {
         }
       }
-      resolve19();
+      resolve20();
     }, KILL_GRACE_MS);
     graceTimers.push(t);
   });
@@ -44495,7 +45198,7 @@ async function killRunningForConv(convGuid) {
 }
 async function spawnSync2(cwd, timeoutMs, onSpawn) {
   const cmd = process.env.GIPITY_RELAY_CLAUDE_CMD || resolveCommand("gipity");
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     const child = spawnCommand(cmd, ["sync", "--json"], {
       cwd,
       env: childEnv(),
@@ -44519,7 +45222,7 @@ async function spawnSync2(cwd, timeoutMs, onSpawn) {
         } catch {
         }
         try {
-          unlinkSync6(join22(cwd, ".gipity", "sync.lock"));
+          unlinkSync6(join23(cwd, ".gipity", "sync.lock"));
         } catch {
         }
         finish(() => reject(new Error(`timed out after ${Math.round(timeoutMs / 1e3)}s`)));
@@ -44535,7 +45238,7 @@ async function spawnSync2(cwd, timeoutMs, onSpawn) {
     child.on("exit", (code) => finish(() => {
       if (code === 0) {
         log2("info", "sync done", { cwd, stdoutLen });
-        resolve19();
+        resolve20();
       } else {
         reject(new Error(`gipity sync exited ${code}${stderrBuf ? `: ${stderrBuf.trim().slice(0, 300)}` : ""}`));
       }
@@ -44543,10 +45246,11 @@ async function spawnSync2(cwd, timeoutMs, onSpawn) {
   });
 }
 async function spawnGipityClaude(args, cwd, d, queue, meta) {
+  const streamJson = meta?.streamJson !== false;
   const cmd = process.env.GIPITY_RELAY_CLAUDE_CMD || resolveCommand("gipity");
-  const fullArgs = [...args, "--output-format", "stream-json", "--verbose", "--include-partial-messages"];
-  const env = childEnv({ GIPITY_CONVERSATION_GUID: d.conversation_guid, GIPITY_CAPTURE: "off" });
-  return new Promise((resolve19, reject) => {
+  const fullArgs = streamJson ? [...args, "--output-format", "stream-json", "--verbose", "--include-partial-messages"] : [...args];
+  const env = streamJson ? childEnv({ GIPITY_CONVERSATION_GUID: d.conversation_guid, GIPITY_CAPTURE: "off" }) : childEnv({ GIPITY_CONVERSATION_GUID: d.conversation_guid });
+  return new Promise((resolve20, reject) => {
     const child = spawnCommand(cmd, fullArgs, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
     let resolveExited = () => {
     };
@@ -44675,16 +45379,18 @@ async function spawnGipityClaude(args, cwd, d, queue, meta) {
       const ts2 = (/* @__PURE__ */ new Date()).toISOString();
       for (const e of entries) {
         e.ts = ts2;
-        if (!e.source_uuid) e.source_uuid = randomUUID();
+        if (!e.source_uuid) e.source_uuid = randomUUID2();
       }
       q.push(...entries);
     });
     child.stdout?.on("data", (chunk) => {
       stdoutBytesTotal += chunk.length;
       lastStdoutByteAt = Date.now();
-      splitter.push(chunk);
+      if (streamJson) splitter.push(chunk);
+    });
+    child.stdout?.on("end", () => {
+      if (streamJson) splitter.flush();
     });
-    child.stdout?.on("end", () => splitter.flush());
     const errPrefix = C7.dim("\u2502 ");
     const stderrTail = [];
     const errRl = child.stderr ? createInterface2({ input: child.stderr }) : null;
@@ -44710,7 +45416,7 @@ async function spawnGipityClaude(args, cwd, d, queue, meta) {
       if (signal === "SIGTERM" || signal === "SIGKILL") killed = true;
       if (finalResult) {
         finalResult.ts = (/* @__PURE__ */ new Date()).toISOString();
-        finalResult.source_uuid = randomUUID();
+        finalResult.source_uuid = randomUUID2();
         q.push(finalResult);
       }
       if (unmapped.size > 0) {
@@ -44724,7 +45430,7 @@ async function spawnGipityClaude(args, cwd, d, queue, meta) {
       void postProgress(d.conversation_guid, buildProgressPayload(false));
       if (ownQueue) await q.close();
       cleanup();
-      resolve19({
+      resolve20({
         exitCode: code ?? 1,
         killed,
         runtimeLimit,
@@ -44738,10 +45444,10 @@ async function runDispatchSync(d, cwd) {
   let killed = false;
   try {
     await spawnSync2(cwd, PROJECT_SYNC_TIMEOUT_MS, (child) => {
-      const exited = new Promise((resolve19) => {
+      const exited = new Promise((resolve20) => {
         child.once("exit", (_code, signal) => {
           if (signal === "SIGTERM") killed = true;
-          resolve19();
+          resolve20();
         });
       });
       running.set(d.short_guid, { child, convGuid: d.conversation_guid, exited });
@@ -44772,18 +45478,18 @@ function killDispatch(shortGuid) {
   return false;
 }
 function sleep4(ms2, signal) {
-  return new Promise((resolve19) => {
-    if (signal?.aborted) return resolve19();
+  return new Promise((resolve20) => {
+    if (signal?.aborted) return resolve20();
     let onAbort = null;
     const t = setTimeout(() => {
       if (onAbort && signal) signal.removeEventListener("abort", onAbort);
-      resolve19();
+      resolve20();
     }, ms2);
     if (signal) {
       onAbort = () => {
         clearTimeout(t);
         signal.removeEventListener("abort", onAbort);
-        resolve19();
+        resolve20();
       };
       signal.addEventListener("abort", onAbort, { once: true });
     }
@@ -44796,7 +45502,7 @@ init_colors();
 function requirePaired() {
   const device = getDevice();
   if (!device) {
-    console.error(`${error("No paired device.")} Run ${bold("gipity claude")} to pair this machine.`);
+    console.error(`${error("No paired device.")} Run ${bold("gipity connect")} to pair this machine.`);
     process.exit(1);
   }
   return device;
@@ -44937,7 +45643,7 @@ relayCommand.command("status").description("Show pairing status").option("--json
     return;
   }
   if (!s.device) {
-    console.log(`${muted("No paired device.")} Run ${brand("gipity claude")} to pair this machine.`);
+    console.log(`${muted("No paired device.")} Run ${brand("gipity connect")} to pair this machine.`);
     return;
   }
   console.log(`${bold("Device:")}      ${brand(s.device.name)} ${muted(`(${s.device.guid})`)}`);
@@ -44953,11 +45659,11 @@ relayCommand.command("run").description("Run the background service").option("-v
 });
 relayCommand.command("stop").description("Stop the background service").option("--force", "Force-stop if it doesn't exit cleanly within 5s").action(async (opts) => {
   const pidPath = getDaemonPidPath();
-  if (!existsSync21(pidPath)) {
+  if (!existsSync22(pidPath)) {
     console.log(muted("Background service isn't running."));
     return;
   }
-  const pid = parseInt(readFileSync22(pidPath, "utf-8").trim(), 10);
+  const pid = parseInt(readFileSync23(pidPath, "utf-8").trim(), 10);
   if (!pid || isNaN(pid)) {
     console.error(error("PID file is empty or malformed."));
     process.exit(1);
@@ -45081,8 +45787,8 @@ relayCommand.command("revoke").description("Revoke and forget this device").acti
   } catch {
   }
   const pidPath = getDaemonPidPath();
-  if (existsSync21(pidPath)) {
-    const pid = parseInt(readFileSync22(pidPath, "utf-8").trim(), 10);
+  if (existsSync22(pidPath)) {
+    const pid = parseInt(readFileSync23(pidPath, "utf-8").trim(), 10);
     if (pid && !isNaN(pid)) {
       try {
         process.kill(pid, "SIGTERM");
@@ -45095,13 +45801,13 @@ relayCommand.command("revoke").description("Revoke and forget this device").acti
 });
 relayCommand.command("log").description("Tail the service log").option("-n, --lines <n>", "How many lines to print (default 100)", "100").option("-f, --follow", "Follow the log like `tail -f`").action((opts) => {
   const path5 = RELAY_LOG_PATH;
-  if (!existsSync21(path5)) {
+  if (!existsSync22(path5)) {
     console.log(muted("No log file yet. Start the service with `gipity relay run` (or install it)."));
     return;
   }
   const lines = parseInt(opts.lines, 10) || 100;
   try {
-    const all = readFileSync22(path5, "utf-8").split("\n");
+    const all = readFileSync23(path5, "utf-8").split("\n");
     const tail = all.slice(-lines - 1).join("\n");
     process.stdout.write(tail);
   } catch (err) {
@@ -45127,7 +45833,7 @@ registerInstallCommands(relayCommand);
 function requirePaired2() {
   const device = getDevice();
   if (!device) {
-    console.error(`${error("No paired device.")} Run ${brand("gipity claude")} to pair this machine.`);
+    console.error(`${error("No paired device.")} Run ${brand("gipity connect")} to pair this machine.`);
     process.exit(1);
   }
   return device;
@@ -45136,9 +45842,9 @@ function requirePaired2() {
 // src/commands/setup.ts
 init_auth();
 init_colors();
-var setupCommand = new Command("setup").description("Set up this computer as a relay (no project, no launch)").action(async () => {
+var connectCommand = new Command("connect").alias("setup").description("Connect this computer to gipity.ai so the web CLI can drive it (no project, no launch)").action(async () => {
   try {
-    console.log(`  ${bold("Gipity setup")} ${muted("- get this computer ready as a relay")}`);
+    console.log(`  ${bold("Gipity connect")} ${muted("- let gipity.ai drive this computer")}`);
     console.log("");
     let auth = getAuth();
     if (auth && !sessionExpired()) {
@@ -45156,9 +45862,9 @@ var setupCommand = new Command("setup").description("Set up this computer as a r
     if (enabled) {
       const running2 = isRelayEnabled() && !isPaused();
       console.log(`  ${success("Done")} \u2014 your relay ${running2 ? "is running in the background" : "is set up"} and will start with your computer.`);
-      console.log(`  ${muted("Open")} ${brand("gipity.ai")} ${muted("and start a chat to drive Claude Code here. Manage it with `gipity relay status`.")}`);
+      console.log(`  ${muted("Open")} ${brand("gipity.ai")} ${muted("and start a chat to drive your coding agent here. Manage it with `gipity relay status`.")}`);
     } else {
-      console.log(`  ${muted("No relay set up. Run `gipity setup` again anytime, or `gipity claude` to build with Gipity.")}`);
+      console.log(`  ${muted("No relay set up. Run `gipity connect` again anytime, or `gipity build` to start building.")}`);
     }
     console.log("");
   } catch (err) {
@@ -45174,15 +45880,15 @@ init_api();
 init_auth();
 init_utils();
 init_colors();
-import { existsSync as existsSync22, rmSync as rmSync2, unlinkSync as unlinkSync8, readFileSync as readFileSync23, writeFileSync as writeFileSync14 } from "fs";
-import { homedir as homedir16, platform as osPlatform4 } from "os";
-import { join as join23, resolve as resolve17 } from "path";
+import { existsSync as existsSync23, rmSync as rmSync3, unlinkSync as unlinkSync8, readFileSync as readFileSync24, writeFileSync as writeFileSync16 } from "fs";
+import { homedir as homedir17, platform as osPlatform4 } from "os";
+import { join as join24, resolve as resolve18 } from "path";
 function removeGipityPluginConfig() {
-  const settingsPath = join23(homedir16(), ".claude", "settings.json");
-  if (!existsSync22(settingsPath)) return false;
+  const settingsPath = join24(homedir17(), ".claude", "settings.json");
+  if (!existsSync23(settingsPath)) return false;
   let settings;
   try {
-    settings = JSON.parse(readFileSync23(settingsPath, "utf-8"));
+    settings = JSON.parse(readFileSync24(settingsPath, "utf-8"));
   } catch {
     return false;
   }
@@ -45197,7 +45903,7 @@ function removeGipityPluginConfig() {
     if (Object.keys(settings.extraKnownMarketplaces).length === 0) delete settings.extraKnownMarketplaces;
     changed = true;
   }
-  if (changed) writeFileSync14(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (changed) writeFileSync16(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   return changed;
 }
 function removeInstallerPathLines() {
@@ -45205,11 +45911,11 @@ function removeInstallerPathLines() {
   const marker = "# Added by the Gipity installer";
   const touched = [];
   for (const name of [".bashrc", ".zshrc", ".profile"]) {
-    const rc2 = join23(homedir16(), name);
-    if (!existsSync22(rc2)) continue;
+    const rc2 = join24(homedir17(), name);
+    if (!existsSync23(rc2)) continue;
     let text;
     try {
-      text = readFileSync23(rc2, "utf-8");
+      text = readFileSync24(rc2, "utf-8");
     } catch {
       continue;
     }
@@ -45219,7 +45925,7 @@ function removeInstallerPathLines() {
     );
     if (kept.length === lines.length) continue;
     try {
-      writeFileSync14(rc2, kept.join("\n"));
+      writeFileSync16(rc2, kept.join("\n"));
       touched.push(rc2);
     } catch {
     }
@@ -45227,11 +45933,11 @@ function removeInstallerPathLines() {
   return touched;
 }
 function tildify2(p) {
-  const home = homedir16();
+  const home = homedir17();
   return p === home || p.startsWith(home + "/") ? "~" + p.slice(home.length) : p;
 }
 function resolveCliPath2() {
-  return resolve17(process.argv[1] ?? "gipity");
+  return resolve18(process.argv[1] ?? "gipity");
 }
 async function stopDaemon() {
   if (!isDaemonRunning()) return;
@@ -45265,7 +45971,7 @@ function removeServiceUnit() {
       const r = spawnSyncCommand(argv2[0], argv2.slice(1), { stdio: "ignore" });
       if (r.status !== 0) allOk = false;
     }
-    if (existsSync22(plan2.path)) {
+    if (existsSync23(plan2.path)) {
       try {
         unlinkSync8(plan2.path);
       } catch {
@@ -45288,9 +45994,9 @@ async function revokeDeviceBestEffort() {
 }
 var uninstallCommand = new Command("uninstall").description("Uninstall Gipity").option("--yes", "Skip confirmation prompts").action(async (opts) => {
   const autoYes = opts.yes || getAutoConfirm();
-  const gipityDir = join23(homedir16(), ".gipity");
-  const launcherBin = join23(gipityDir, "launcher", "bin", "gipity");
-  const installedViaLauncher = existsSync22(launcherBin);
+  const gipityDir = join24(homedir17(), ".gipity");
+  const launcherBin = join24(gipityDir, "launcher", "bin", "gipity");
+  const installedViaLauncher = existsSync23(launcherBin);
   console.log(`${bold("Gipity uninstall")} - this will:`);
   console.log(`\u2022 Stop the running relay daemon (if any)`);
   console.log(`\u2022 Remove the OS autostart service (launchd / systemd / Task Scheduler)`);
@@ -45325,9 +46031,26 @@ var uninstallCommand = new Command("uninstall").description("Uninstall Gipity").
   } else {
     console.log(`${muted("No Gipity entries in Claude Code settings.")}`);
   }
-  if (existsSync22(gipityDir)) {
+  if (grokInstallState().exists) {
+    spawnSyncCommand(resolveCommand("grok"), ["plugin", "uninstall", "gipity", "--confirm"], {
+      stdio: "ignore",
+      timeout: 6e4
+    });
+    console.log(`${success("Gipity plugin removed from Grok.")}`);
+  }
+  const agentSkills = agentSkillsState();
+  if (agentSkills.skills.length) {
+    for (const name of agentSkills.skills) {
+      try {
+        rmSync3(join24(AGENTS_SKILLS_DIR, name), { recursive: true, force: true });
+      } catch {
+      }
+    }
+    console.log(`${success(`Removed ${agentSkills.skills.length} Gipity skills from ~/.agents/skills.`)}`);
+  }
+  if (existsSync23(gipityDir)) {
     try {
-      rmSync2(gipityDir, { recursive: true, force: true });
+      rmSync3(gipityDir, { recursive: true, force: true });
       console.log(`${success(`Removed ${gipityDir}/`)}`);
     } catch (err) {
       console.error(`${error(`Could not remove ${gipityDir}: ${err?.message || err}`)}`);
@@ -45488,7 +46211,7 @@ gmailCommand.command("reply").description("Reply to a Gmail thread. Get thread-i
 }));
 
 // src/commands/text.ts
-import { readFileSync as readFileSync24 } from "fs";
+import { readFileSync as readFileSync25 } from "fs";
 init_colors();
 
 // src/helpers/text-analysis.ts
@@ -45643,10 +46366,10 @@ function areAnagrams(a, b7) {
 
 // src/commands/text.ts
 function resolveInput(args, opts) {
-  if (opts.file) return readFileSync24(opts.file, "utf-8");
+  if (opts.file) return readFileSync25(opts.file, "utf-8");
   if (args.length) return args.join(" ");
   try {
-    return readFileSync24(0, "utf-8");
+    return readFileSync25(0, "utf-8");
   } catch {
     return "";
   }
@@ -45851,9 +46574,9 @@ function collectRealFlags(argv2, program3) {
 }
 
 // src/trace.ts
-import { openSync as openSync5, writeSync, mkdirSync as mkdirSync15 } from "fs";
-import { join as join24 } from "path";
-import { homedir as homedir17 } from "os";
+import { openSync as openSync5, writeSync, mkdirSync as mkdirSync17 } from "fs";
+import { join as join25 } from "path";
+import { homedir as homedir18 } from "os";
 var TRACE_KEY = /* @__PURE__ */ Symbol.for("gipity.traceOutput");
 function installOutputTrace(label2) {
   if (process.env.GIPITY_TRACE_OUTPUT !== "1") return;
@@ -45864,10 +46587,10 @@ function installOutputTrace(label2) {
       existing.emit({ event: "reenter", label: label2 });
       return;
     }
-    const dir = join24(process.env.GIPITY_DIR || join24(homedir17(), ".gipity"), "trace");
-    mkdirSync15(dir, { recursive: true });
+    const dir = join25(process.env.GIPITY_DIR || join25(homedir18(), ".gipity"), "trace");
+    mkdirSync17(dir, { recursive: true });
     const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", "_").replace(/:/g, "-");
-    const fd2 = openSync5(join24(dir, `${stamp}-pid${process.pid}.jsonl`), "a");
+    const fd2 = openSync5(join25(dir, `${stamp}-pid${process.pid}.jsonl`), "a");
     const emit = (rec) => {
       try {
         writeSync(fd2, JSON.stringify({ t: (/* @__PURE__ */ new Date()).toISOString(), ...rec }) + "\n");
@@ -45903,11 +46626,11 @@ function installOutputTrace(label2) {
 // src/index.ts
 installOutputTrace("index");
 var __dirname = dirname13(fileURLToPath3(import.meta.url));
-var pkg = JSON.parse(readFileSync25(resolve18(__dirname, "../package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync26(resolve19(__dirname, "../package.json"), "utf-8"));
 function versionLabel() {
   const base = `v${pkg.version}`;
   try {
-    const info2 = JSON.parse(readFileSync25(resolve18(__dirname, "build-info.json"), "utf-8"));
+    const info2 = JSON.parse(readFileSync26(resolve19(__dirname, "build-info.json"), "utf-8"));
     if (info2?.sha) return `${base} (dev ${info2.sha}${info2.dirty ? ", modified" : ""})`;
   } catch {
   }
@@ -45949,7 +46672,7 @@ var servicesGroup = [serviceCommand, generateCommand, notifyCommand, paymentsCom
 var filesGroup = [syncCommand, fileCommand, pushCommand, uploadCommand, storageCommand];
 var gipGroup = [chatCommand, memoryCommand, agentCommand, approvalCommand, gmailCommand];
 var utilitiesGroup = [sandboxCommand, emailCommand, locationCommand, textCommand, bugCommand];
-var connectGroup = [loginCommand, logoutCommand, claudeCommand, setupCommand, relayCommand, githubCommand, creditsCommand, doctorCommand, updateCommand, uninstallCommand];
+var connectGroup = [loginCommand, logoutCommand, buildCommand, connectCommand, relayCommand, githubCommand, creditsCommand, doctorCommand, updateCommand, uninstallCommand];
 var HELP_SECTIONS = [
   { title: "Start here", cmds: startGroup },
   { title: "App build & ship", cmds: buildGroup },
@@ -46007,9 +46730,9 @@ program2.configureHelp({
     lines.push("");
     lines.push(bold("Quick start:"));
     lines.push(`  ${brand("gipity login")}    ${dim("- authenticate first if you haven't already")}`);
-    lines.push(`  ${brand("gipity init")}     ${dim("- link this dir + write CLAUDE.md/AGENTS.md primers for your AI tool")}`);
-    lines.push(`  ${brand("gipity setup")}    ${dim("- set up this computer as a relay to drive from gipity.ai (no launch)")}`);
-    lines.push(`  ${brand("gipity claude")}   ${dim("- or launch Claude Code with Gipity tools wired in")}`);
+    lines.push(`  ${brand("gipity init")}     ${dim("- link this dir + wire up every coding agent on this machine")}`);
+    lines.push(`  ${brand("gipity connect")}  ${dim("- connect this computer to gipity.ai so the web CLI can drive it")}`);
+    lines.push(`  ${brand("gipity build")}    ${dim("- or start from anywhere: pick a project, pick your agent, go")}`);
     lines.push("");
     lines.push(bold("Usage:"));
     lines.push(`  ${cmd.name()} [options] [command]`);
@@ -46043,6 +46766,8 @@ for (const cmd of HELP_SECTIONS.flatMap((s) => s.cmds)) {
 `);
   program2.addCommand(cmd);
 }
+configureHelp(claudeCommand);
+program2.addCommand(claudeCommand, { hidden: true });
 program2.helpCommand(false);
 function manifestCommand(c) {
   return {