gipity 1.1.4 → 1.1.6

package/dist/knowledge.js

@@ -106,7 +106,7 @@ mkdir -p ~/GipityProjects/<slug> && cd ~/GipityProjects/<slug> && gipity init <s
 
 ## CLI quick reference
 
-Key commands: \`gipity add <template|kit>\`, \`gipity deploy dev\`, \`gipity sandbox run\`, \`gipity page inspect <url>\`, \`gipity page screenshot <url>\`, \`gipity db query "SQL"\`, \`gipity fn call <name>\`, \`gipity logs fn <name>\`, \`gipity secrets set <NAME> <value> [--account]\` (store an API key/token encrypted; read in functions via \`secrets.get('NAME')\` — never hardcode keys), \`gipity email send --to <addr> --subject <s> --body <b>\` (sends as \`gipity@gipity.ai\`; omit \`--to\` to self-send), \`gipity skill read <name>\`.
+Key commands: \`gipity add <template|kit>\`, \`gipity brand set --emoji <e>|--color <hex>\` (regenerate the app's icons + social share card), \`gipity deploy dev\`, \`gipity sandbox run\`, \`gipity page inspect <url>\`, \`gipity page screenshot <url>\`, \`gipity db query "SQL"\`, \`gipity fn call <name>\`, \`gipity logs fn <name>\`, \`gipity secrets set <NAME> <value> [--account]\` (store an API key/token encrypted; read in functions via \`secrets.get('NAME')\` — never hardcode keys), \`gipity email send --to <addr> --subject <s> --body <b>\` (sends as \`gipity@gipity.ai\`; omit \`--to\` to self-send), \`gipity skill read <name>\`.
 Rename for findability: \`gipity project rename <name>\` renames the current project's display name (the slug and deployed URLs never change); \`gipity chat rename <title>\` renames the current chat's tab title. Both are the display label users scan to switch between tabs — retitle a chat when the conversation clearly shifts to a new topic (sparingly, not every turn), and keep every project/chat title SHORT: 2-4 words, ≤40 characters, no trailing punctuation (e.g. "Stripe checkout", "Tetris game").
 Pull an existing remote project local (given its URL/slug): \`mkdir -p ~/GipityProjects/<slug> && cd ~/GipityProjects/<slug> && gipity init <slug>\` (adopts the matching project and syncs files down - this is the "clone").
 Move whole apps in/out: \`gipity save\` (export this project as a portable \`.gip\` bundle), \`gipity load <file.gip | github:owner/repo>\` (import as a NEW project; \`--inspect\` to preview), \`gipity github connect\` (1-2 click GitHub access for imports). Porting a Vercel/Replit/Lovable app? Load the \`app-import\` skill first.
@@ -148,6 +148,8 @@ Write files locally - Gipity's editor hooks (installed into Claude Code, Grok, a
 
 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.
 
+**WSL trap: user-dropped files may be in a Windows-side twin.** On WSL, a same-named folder often exists at \`C:\\Users\\<name>\\GipityProjects\\<project>\` (visible as \`/mnt/c/Users/<name>/GipityProjects/<project>\`) - from Windows Explorer it looks like "the project folder", so users drop new files (audio, images) there. Nothing syncs from it. If the user says files are "in the project" but you can't find them, check that path before searching wider; \`gipity sync\` prints a notice when such a twin exists.
+
 ### Where files go: deploy only ships \`src/\`
 
 Deploy is opt-in, not opt-out: the \`files\` phase uploads **only** what's under \`src/\` (plus \`functions/\` and \`migrations/\` as backend, not CDN files). Anything else at the project root is kept but never deployed. Put each kind of file in the right bucket so scratch and reference material can't bloat a deploy:
@@ -184,6 +186,7 @@ App development skills:
 - \`app-debugging\` - debug a deployed app: page inspect/eval, screenshots, function logs
 - \`app-development\` - functions, database, and API
 - \`app-import\` - import apps from GitHub/.gip bundles (incl. Vercel/Replit/Lovable porting) and export any project as a portable .gip - app_import tool, gipity save/load
+- \`app-records\` - Gipity Records: declared tables → validated CRUD, provenance, workflows, auto UI
 - \`app-testing\` - testing deployed app functions (ctx.fn.call/callAs, the isolated test DB)
 - \`deploy\` - the deploy pipeline & gipity.yaml manifest
 - \`jobs\` - long-running CPU + GPU compute jobs (Python / Node / bash)

package/dist/login-flow.js

@@ -10,9 +10,48 @@
  */
 import { publicPost } from './api.js';
 import { getAuth, saveAuth } from './auth.js';
+import { getConfig } from './config.js';
 import { prompt, decodeJwtExp } from './utils.js';
-import { success, error as clrError, muted } from './colors.js';
+import { success, error as clrError, warning, muted } from './colors.js';
 import { flushBugQueue } from './bug-queue.js';
+/** True when a fresh-account result would be a SURPRISE worth warning about:
+ *  either this directory is linked to an existing project, or this machine
+ *  already held a session for this exact email. A genuine first-time signup
+ *  (nothing linked, no prior session) must stay silent. */
+function newAccountWouldBeUnexpected(email, priorAuth) {
+    return !!getConfig() || priorAuth?.email.toLowerCase() === email.toLowerCase().trim();
+}
+/** Called right after `/auth/login` (send-code), before the code is entered -
+ *  the server already knows at this point whether the email matches an
+ *  existing account (bug cli#S2: logging into the wrong/new account was
+ *  previously silent until a later "not found" error). */
+export function warnBeforeCodeIfUnexpectedNewAccount(isNewUser, email, indent = '') {
+    if (isNewUser !== true)
+        return;
+    const priorAuth = getAuth();
+    if (!newAccountWouldBeUnexpected(email, priorAuth))
+        return;
+    const config = getConfig();
+    console.log(`${indent}${warning(`No existing Gipity account for ${email} — entering the code will CREATE a new one.`)}`);
+    if (config) {
+        console.log(`${indent}${muted(`This directory is linked to project ${config.projectSlug} (account ${config.accountSlug}). If you meant to log into that account, stop and re-check the email before entering the code.`)}`);
+    }
+}
+/** Called right after `/auth/verify` succeeds. `priorAuth` must be captured
+ *  BEFORE `saveAuth()` overwrites the cache - it's the only way to tell "this
+ *  machine already had a session for this email" from "first login ever". */
+export function warnIfUnexpectedNewAccount(isNewUser, email, priorAuth, indent = '') {
+    if (isNewUser !== true)
+        return;
+    if (!newAccountWouldBeUnexpected(email, priorAuth))
+        return;
+    const config = getConfig();
+    console.log(`${indent}${warning(`Logged into a NEW, empty account for ${email} — no prior account existed for this email.`)}`);
+    if (config) {
+        console.log(`${indent}${muted(`This directory is linked to project ${config.projectSlug} (account ${config.accountSlug}), which the new account does not own — project / skill / sync commands will fail with "not found".`)}`);
+    }
+    console.log(`${indent}${muted('If you expected an existing account, run: gipity status  — then gipity login again with the correct email.')}`);
+}
 /** Prompt for email + 6-digit code, persist the tokens, and return the new
  *  auth. Exits the process on empty input or a bad token (the caller can't
  *  proceed without a session). */
@@ -22,13 +61,15 @@ export async function interactiveLogin() {
         console.error(`\n  ${clrError('Email required.')}`);
         process.exit(1);
     }
-    await publicPost('/auth/login', { email });
+    const sendRes = await publicPost('/auth/login', { email });
     console.log('  Check your email for a 6-digit code.\n');
+    warnBeforeCodeIfUnexpectedNewAccount(sendRes.isNewUser, email, '  ');
     const code = await prompt('  Code: ');
     if (!code) {
         console.error(`\n  ${clrError('Code required.')}`);
         process.exit(1);
     }
+    const priorAuth = getAuth();
     const res = await publicPost('/auth/verify', { email, code });
     const exp = decodeJwtExp(res.accessToken);
     if (!exp) {
@@ -38,6 +79,7 @@ export async function interactiveLogin() {
     const expiresAt = new Date(exp * 1000).toISOString();
     saveAuth({ accessToken: res.accessToken, refreshToken: res.refreshToken, email, expiresAt });
     console.log(`  ${success(`Logged in (${email}).`)}`);
+    warnIfUnexpectedNewAccount(res.isNewUser, email, priorAuth, '  ');
     const delivered = await flushBugQueue().catch(() => 0);
     if (delivered > 0) {
         console.log(`  ${muted(`Delivered ${delivered} queued bug report${delivered === 1 ? '' : 's'}.`)}`);

package/dist/project-setup.js

@@ -36,6 +36,8 @@ export async function finalizeLocalProject(opts) {
         const sub = await substituteDir(opts.dir, {
             projectGuid: opts.projectGuid,
             projectName: opts.projectName,
+            accountSlug: opts.accountSlug,
+            projectSlug: opts.projectSlug,
         });
         if (sub.changed.length) {
             console.log(muted(`Resolved template vars in ${sub.changed.length} file${sub.changed.length > 1 ? 's' : ''}.`));

package/dist/relay/diagnostics.js

@@ -137,8 +137,8 @@ export async function collectDiagnostics() {
     } })();
     // Run the subprocess probes concurrently (each already bounded + best-effort)
     // so the whole snapshot costs one timeout, not the sum of four.
-    const [claude, codex, grok, cursor, gpu] = await Promise.all([
-        probeVersion('claude'), probeVersion('codex'), probeVersion('grok'), probeVersion('cursor'), detectGpu(),
+    const [claude, codex, grok, agy, cursor, gpu] = await Promise.all([
+        probeVersion('claude'), probeVersion('codex'), probeVersion('grok'), probeVersion('agy'), probeVersion('cursor'), detectGpu(),
     ]);
     const agents = {};
     if (claude)
@@ -147,6 +147,8 @@ export async function collectDiagnostics() {
         agents.codex = codex;
     if (grok)
         agents.grok = grok;
+    if (agy)
+        agents.agy = agy;
     if (cursor)
         agents.cursor = cursor;
     return {

package/dist/relay/onboarding.js

@@ -12,8 +12,7 @@
  * All the non-interactive primitives live in `setup.ts` (`pairDevice`,
  * `startDaemon`, `installAutostart`); this module is only the prompts + copy.
  */
-import { readFileSync } from 'node:fs';
-import { prompt, confirm } from '../utils.js';
+import { prompt, confirm, isWsl } from '../utils.js';
 import { bold, brand, dim, success, error as clrError, muted } from '../colors.js';
 import * as state from './state.js';
 import { UnsupportedPlatformError } from './installers.js';
@@ -27,21 +26,6 @@ export const ensureDaemonRunning = startDaemon;
  * ended up enabled (or was already), `false` if the user declined or a step
  * failed. Non-interactive flows (e.g. `gipity claude -p`) must not call this.
  */
-/** True inside Windows Subsystem for Linux (either env marker or kernel
- *  string). Used to explain autostart failures accurately - WSL ships without
- *  a systemd user session unless the user opts in via /etc/wsl.conf. */
-function isWsl() {
-    if (process.platform !== 'linux')
-        return false;
-    if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP)
-        return true;
-    try {
-        return /microsoft/i.test(readFileSync('/proc/version', 'utf-8'));
-    }
-    catch {
-        return false;
-    }
-}
 export async function runRelaySetup(opts) {
     const alreadyAnswered = state.getRelayEnabled() !== undefined;
     // `gipity claude` first-run: honor the user's prior choice and don't re-ask.
@@ -66,13 +50,13 @@ export async function runRelaySetup(opts) {
             console.log('');
             console.log(`  ${success('Registered as')} ${bold(existingDevice.name)} ${muted(`(${existingDevice.guid})`)}`);
             if (state.isPaused()) {
-                console.log(`  ${dim('The relay is paused — resume it with')} ${brand('gipity relay resume')}${dim('.')}`);
+                console.log(`  ${dim('The relay is paused - resume it with')} ${brand('gipity relay resume')}${dim('.')}`);
             }
             else {
                 console.log(`  ${dim('The relay is running. Open')} ${brand('gipity.ai')}${dim(' and type `/claude` to drive Claude Code here.')}`);
             }
             console.log('');
-            console.log(`  ${dim('To register this computer again — for example under a different name —')}`);
+            console.log(`  ${dim('To register this computer again (for example under a different name),')}`);
             console.log(`  ${dim('unregister it first, then re-run setup:')}`);
             console.log(`      ${brand('gipity relay revoke')}   ${dim('# unpairs this computer and removes the login service')}`);
             console.log(`      ${brand('gipity connect')}        ${dim('# register it again (asks for a new name)')}`);
@@ -82,34 +66,36 @@ export async function runRelaySetup(opts) {
     }
     // Header. `gipity setup` frames it as the deliberate action it is; the
     // `gipity claude` first-run frames it as an optional add-on it's offering.
+    // Lines are pre-wrapped short so they never rewrap in a normal terminal.
     if (opts.mode === 'run-now') {
         console.log(`  ${bold('Set up this computer as a relay')}`);
-        console.log(`  ${dim('A relay runs your coding agent (Claude Code, Codex, or Grok) here so you can drive it from the web (')}${brand('gipity.ai')}${dim(') on any browser.')}`);
-        console.log(`  ${dim('It uses your Claude, Codex, or Grok subscription — the cheapest way to pay for tokens.')}`);
+        console.log(`  ${dim('Gipity drives the coding agents on this computer from the web (')}${brand('gipity.ai')}${dim(')')}`);
+        console.log(`  ${dim('on any browser, desktop or phone. Uses your Claude, Codex, or Grok')}`);
+        console.log(`  ${dim('subscription - the cheapest way to pay for tokens.')}`);
     }
     else {
-        console.log(`  ${bold('Remote control of your coding agent')}`);
-        console.log(`  ${dim('Drive your coding agent on this computer from the web (')}${brand('gipity.ai')}${dim(') on any browser (desktop or phone).')}`);
-        console.log('');
-        console.log(`  ${dim('Enable now (takes 2 seconds) or turn on later with')} ${brand('gipity connect')}`);
+        console.log(`  ${bold('Optional:')} ${dim('Gipity can drive the coding agents on this computer from the')}`);
+        console.log(`  ${dim('web (')}${brand('gipity.ai')}${dim(') on any browser, desktop or phone. Like Claude Code remote')}`);
+        console.log(`  ${dim('control, but one pane for all your coding agents.')}`);
     }
     console.log('');
     const promptText = opts.mode === 'run-now'
-        ? '  Set up remote control on this computer?'
-        : '  Enable remote control?';
+        ? '  Set up remote control on this computer'
+        : '  Enable remote control';
     const enable = await confirm(promptText, { default: 'yes' });
     if (!enable) {
         state.setRelayEnabled(false);
-        console.log(`  ${muted('Skipped.')}`);
+        console.log(`  ${muted('Skipped. Turn on later with')} ${brand('gipity connect')}${muted('.')}`);
         console.log('');
         return false;
     }
+    console.log('');
     // Device name - show a friendly default (owner + device kind); Enter accepts.
     const defaultName = friendlyDeviceName();
     const rawName = await prompt(`  Device name [${bold(defaultName)}]: `);
     const name = (rawName || defaultName).trim();
     if (!name || name.length > 100) {
-        console.error(`  ${clrError('Device name must be 1–100 non-whitespace characters. Skipping.')}`);
+        console.error(`  ${clrError('Device name must be 1-100 non-whitespace characters. Skipping.')}`);
         state.setRelayEnabled(false);
         return false;
     }
@@ -128,13 +114,12 @@ export async function runRelaySetup(opts) {
         // run instead of silently opting the user out forever.
         return false;
     }
-    // Start the daemon for this session.
-    const startNow = await confirm('  Start the relay now (and on future `gipity build` runs)?', { default: 'yes' });
-    if (startNow) {
-        startDaemon();
-    }
+    // The user said yes to remote control - start the daemon now, no extra
+    // question. `gipity build` keeps it running on future runs.
+    startDaemon();
+    console.log('');
     // Offer OS-level autostart (launchd / systemd --user / Task Scheduler).
-    const autostartOs = await confirm('  Also start at OS login (auto-start with Windows / macOS / Linux)?', { default: 'yes' });
+    const autostartOs = await confirm('  Also start at OS login', { default: 'yes' });
     if (autostartOs) {
         try {
             const res = installAutostart();
@@ -152,9 +137,7 @@ export async function runRelaySetup(opts) {
                     console.log(`  ${muted('Autostart install returned non-zero - you can run')} ${brand('gipity relay install')} ${muted('later.')}`);
                 }
             }
-            else {
-                console.log(`  ${success('Auto-start installed.')} ${dim(res.summary)}`);
-            }
+            // Success is silent - the Done line below covers it.
         }
         catch (err) {
             if (err instanceof UnsupportedPlatformError) {
@@ -166,16 +149,15 @@ export async function runRelaySetup(opts) {
         }
     }
     // Diagnostics consent - default on, clearly opt-out. Only ask once.
+    // (No personal data or file paths are ever sent; `gipity relay diagnostics
+    // on|off` flips it later.)
     if (state.getDiagnosticsConsent() === undefined) {
-        const diag = await confirm('  Share anonymous diagnostics (CPU/GPU/memory/disk/versions) to improve reliability?', { default: 'yes' });
+        console.log('');
+        const diag = await confirm('  Share anonymous diagnostics info', { default: 'yes' });
         state.setDiagnosticsConsent(diag);
-        console.log(`  ${dim(diag
-            ? 'Thanks - no personal data or file paths are ever sent. Turn off anytime with `gipity relay diagnostics off`.'
-            : 'Diagnostics off. Turn on anytime with `gipity relay diagnostics on`.')}`);
     }
     console.log('');
-    console.log(`  ${success(`Registered as ${bold(device.name)} (${device.guid}).`)}`);
-    console.log(`  ${dim('In the Gipity web CLI, type `/claude` to dispatch messages to this PC.')}`);
+    console.log(`  ${success(`Done! ${bold(device.name)} is set up. New chats from gipity.ai can now execute here.`)}`);
     console.log('');
     return true;
 }

package/dist/setup.js

@@ -32,6 +32,7 @@ export const PRIMER_FILES = {
     claude: 'CLAUDE.md',
     codex: 'AGENTS.md',
     grok: 'AGENTS.md', // Grok Build reads the AGENTS.md family (and CLAUDE.md) natively
+    agy: 'AGENTS.md', // Antigravity reads the same AGENTS.md/GEMINI.md rules family natively
     aider: 'AGENTS.md', // shares the Codex primer; aider is pointed at it via .aider.conf.yml
     gemini: 'GEMINI.md',
     copilot: '.github/copilot-instructions.md',
@@ -58,7 +59,7 @@ export const AIDER_CONF_FILE = '.aider.conf.yml';
  *  `ignore` package in config.ts. */
 export const SCRATCH_IGNORE = ['tmp/', '.tmp/', '*_tmp/', '.gipityscratch/'];
 export const DEFAULT_SYNC_IGNORE = [
-    'node_modules', '.git', '.gipity.json', '.gipity/', '.claude/', '.codex/', '.gitignore', AIDER_CONF_FILE,
+    'node_modules', '.git', '.gipity.json', '.gipity/', '.claude/', '.codex/', '.agents/', '.gitignore', AIDER_CONF_FILE,
     // Home-directory junk: a project created inside a real home dir (or one that
     // shells out) sweeps in a cache dir + shell dotfiles that are never app
     // files. `.cache/` alone can be gigabytes (it was 2.4 GB on one project),
@@ -398,9 +399,16 @@ export const AGENT_HOOKS_DIR = join(homedir(), '.gipity', 'agent-hooks');
  *  version and the exact skill names copied, so upgrades replace and uninstall
  *  removes precisely those. */
 export const AGENT_SKILLS_MANIFEST = join(homedir(), '.gipity', 'agent-skills.json');
-export function agentSkillsState() {
+// Antigravity (agy) reads skills from its own global customization root,
+// ~/.gemini/config/skills/ (confirmed against agy's own customization-system
+// docs) - NOT the cross-agent ~/.agents/skills Codex/OpenClaw-family tools
+// share. Same manifest pattern, separate directory + file so upgrades and
+// uninstall touch exactly the skills each tool actually reads.
+export const AGY_SKILLS_DIR = join(homedir(), '.gemini', 'config', 'skills');
+export const AGY_SKILLS_MANIFEST = join(homedir(), '.gipity', 'agy-skills.json');
+function skillsManifestState(manifestPath) {
     try {
-        const m = JSON.parse(readFileSync(AGENT_SKILLS_MANIFEST, 'utf-8'));
+        const m = JSON.parse(readFileSync(manifestPath, 'utf-8'));
         return {
             current: typeof m?.version === 'string' && versionGte(m.version, GIPITY_PLUGIN_VERSION),
             skills: Array.isArray(m?.skills) ? m.skills : [],
@@ -410,15 +418,21 @@ export function agentSkillsState() {
         return { current: false, skills: [] };
     }
 }
-/** Materialize the Gipity skills into ~/.agents/skills (the cross-agent skills
- *  dir Codex reads) and the plugin's hook scripts into ~/.gipity/agent-hooks.
- *  Source of truth is the same GipityAI/skills repo the Claude/Grok plugin
- *  installs clone - fetched with a shallow git clone into a temp dir.
- *  Best-effort: no git, no network, or a failed clone all leave things as they
- *  were; the next init retries. */
-export function ensureAgentSkillsInstalled() {
-    if (agentSkillsState().current)
-        return;
+export function agentSkillsState() {
+    return skillsManifestState(AGENT_SKILLS_MANIFEST);
+}
+export function agySkillsState() {
+    return skillsManifestState(AGY_SKILLS_MANIFEST);
+}
+/** Shared core: clone GipityAI/skills, copy every skill dir with a SKILL.md
+ *  into `skillsDir`, stage the plugin's hook scripts into ~/.gipity/agent-hooks
+ *  (shared infra - launch.sh/capture.cjs/sync-push.cjs are agent-agnostic, so
+ *  every caller re-stages them harmlessly), and record what was installed in
+ *  `manifestPath`. Source of truth is the same GipityAI/skills repo the
+ *  Claude/Grok plugin installs clone - fetched with a shallow git clone into a
+ *  temp dir. Best-effort: no git, no network, or a failed clone all leave
+ *  things as they were; the next init retries. */
+function installSkillsAndHooks(skillsDir, manifestPath, harnessLabel) {
     if (!binaryOnPath('git'))
         return;
     const tmp = mkdtempSync(join(tmpdir(), 'gipity-skills-'));
@@ -441,8 +455,8 @@ export function ensureAgentSkillsInstalled() {
                 continue;
             if (!existsSync(join(skillsSrc, entry.name, 'SKILL.md')))
                 continue;
-            mkdirSync(AGENTS_SKILLS_DIR, { recursive: true });
-            cpSync(join(skillsSrc, entry.name), join(AGENTS_SKILLS_DIR, entry.name), {
+            mkdirSync(skillsDir, { recursive: true });
+            cpSync(join(skillsSrc, entry.name), join(skillsDir, entry.name), {
                 recursive: true,
                 force: true,
             });
@@ -452,14 +466,27 @@ export function ensureAgentSkillsInstalled() {
         for (const script of readdirSync(join(repo, 'hooks', 'scripts'))) {
             cpSync(join(repo, 'hooks', 'scripts', script), join(AGENT_HOOKS_DIR, script), { force: true });
         }
-        writeFileSync(AGENT_SKILLS_MANIFEST, JSON.stringify({ version, skills: names }, null, 2) + '\n');
-        console.log(`Installed ${names.length} Gipity skills for Codex (~/.agents/skills).`);
+        writeFileSync(manifestPath, JSON.stringify({ version, skills: names }, null, 2) + '\n');
+        console.log(`Installed ${names.length} Gipity skills for ${harnessLabel} (${skillsDir}).`);
     }
     catch { /* best-effort - never break setup */ }
     finally {
         rmSync(tmp, { recursive: true, force: true });
     }
 }
+export function ensureAgentSkillsInstalled() {
+    if (agentSkillsState().current)
+        return;
+    installSkillsAndHooks(AGENTS_SKILLS_DIR, AGENT_SKILLS_MANIFEST, 'Codex');
+}
+/** Materialize the Gipity skills into Antigravity's global skill root. Mirrors
+ *  ensureAgentSkillsInstalled() but targets agy's own directory - see the
+ *  AGY_SKILLS_DIR comment above for why it differs from Codex's. */
+export function ensureAgySkillsInstalled() {
+    if (agySkillsState().current)
+        return;
+    installSkillsAndHooks(AGY_SKILLS_DIR, AGY_SKILLS_MANIFEST, 'Antigravity');
+}
 /** Pure core of the .codex/hooks.json merge: given the file's current content
  *  (`null` when absent), return the new content, or `null` when no change is
  *  needed. Adds the Gipity sync hook groups (push on file edits, pull before
@@ -535,6 +562,160 @@ export function setupCodexIntegration() {
     ensureAgentSkillsInstalled();
     setupCodexHooks();
 }
+// --- Google Antigravity (agy) --------------------------------------------
+// agy's hook system is a real departure from the Claude-format hooks Codex
+// and Grok reuse: project hooks live in `.agents/hooks.json` as a NAMED-block
+// object (not a flat `hooks` key), tool-scoped events (PreToolUse/PostToolUse)
+// require a `matcher` regex, and every hook command must print a JSON object
+// on stdout.
+//
+// Deliberately NOT wired: PreToolUse. Gipity only needs to OBSERVE tool calls
+// (capture) and react after a write lands (sync-push) - it has no reason to
+// gate them. A PreToolUse hook that answers `{"decision":"allow"}` genuinely
+// overrides agy's own approval prompt (confirmed against agy's own hooks
+// contract: `"allow"` means "automatically allow the tool execution"), so
+// registering one would auto-approve every tool agy runs - including shell
+// commands - in every Gipity-linked project, in BOTH headless and interactive
+// sessions. Confirmed live that headless `-p` writes succeed with no
+// PreToolUse hook at all, with or without `--dangerously-skip-permissions` -
+// so there is no capture/sync reason to have one, and Claude/Codex don't
+// silently touch agent approval either. PostToolUse/Stop route through a
+// small wrapper script (AGY_HOOKS_SCRIPT below) that does the real work
+// (sync-push + session capture) and then unconditionally prints `{}` - not
+// decision-gated, so degrading silently on a node-resolution failure is the
+// same acceptable risk every other harness's hooks already carry.
+/** Written verbatim into ~/.gipity/agent-hooks/agy-hooks.cjs by setupAgyHooks().
+ *  Unlike Codex's hook scripts (cloned from the GipityAI/skills repo), this
+ *  file is authored by the CLI itself - agy is not part of that repo's plugin
+ *  ecosystem, just a consumer of the same shared sync-push.cjs/capture.cjs.
+ *
+ *  post-tool-use: reads agy's PostToolUse payload (which - confirmed live -
+ *  carries `toolCall` directly, unlike agy's own docs suggest) and, for a
+ *  file-write tool, synthesizes a Claude-Code-shaped `{tool_input:{file_path}}`
+ *  payload for the UNMODIFIED sync-push.cjs (which only knows Claude/Grok's
+ *  field names) - then always forwards the raw payload to capture.cjs for
+ *  session mirroring (its normalizeHookInput already reads agy's camelCase
+ *  conversationId/transcriptPath fields).
+ *  stop: forwards the raw payload to capture.cjs for a final flush.
+ *  Either way, stdout is always `{}` - agy isn't gating on this response. */
+const AGY_HOOKS_SCRIPT = `#!/usr/bin/env node
+'use strict';
+const { spawnSync } = require('child_process');
+const { join } = require('path');
+
+const WRITE_TOOLS = new Set(['write_to_file', 'replace_file_content']);
+
+function readStdin() {
+  return new Promise((res) => {
+    let data = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (c) => { data += c; });
+    process.stdin.on('end', () => res(data));
+    process.stdin.on('error', () => res(data));
+  });
+}
+
+async function main() {
+  const event = process.argv[2];
+  const raw = await readStdin();
+  let payload = {};
+  try { payload = JSON.parse(raw); } catch { /* keep {} */ }
+
+  try {
+    if (event === 'post-tool-use') {
+      const toolCall = payload.toolCall;
+      const filePath = toolCall && toolCall.args && toolCall.args.TargetFile;
+      if (toolCall && WRITE_TOOLS.has(toolCall.name) && typeof filePath === 'string' && filePath) {
+        spawnSync(process.execPath, [join(__dirname, 'sync-push.cjs')], {
+          input: JSON.stringify({ tool_input: { file_path: filePath } }),
+          stdio: ['pipe', 'ignore', 'ignore'],
+          windowsHide: true,
+        });
+      }
+      spawnSync(process.execPath, [join(__dirname, 'capture.cjs'), 'agy', 'post-tool-use'], {
+        input: raw,
+        stdio: ['pipe', 'ignore', 'ignore'],
+        windowsHide: true,
+      });
+    } else if (event === 'stop') {
+      spawnSync(process.execPath, [join(__dirname, 'capture.cjs'), 'agy', 'stop'], {
+        input: raw,
+        stdio: ['pipe', 'ignore', 'ignore'],
+        windowsHide: true,
+      });
+    }
+  } catch { /* never let a side effect break the response below */ }
+
+  process.stdout.write('{}');
+}
+
+main();
+`;
+/** Pure core of the .agents/hooks.json merge for Antigravity (agy). Given the
+ *  file's current content (`null` when absent), return the new content, or
+ *  `null` when no change is needed. Our whole contribution lives under one
+ *  named key ('gipity'), so a re-run replaces it wholesale (simpler than
+ *  Codex's per-entry merge, and fine here since nothing else writes into this
+ *  key) while any other named hook block - the user's own, or another tool's -
+ *  is preserved untouched. Exported for unit testing. */
+export function applyAgyHooks(existing) {
+    const wrapper = join(AGENT_HOOKS_DIR, 'agy-hooks.cjs');
+    const launcher = join(AGENT_HOOKS_DIR, 'launch.sh');
+    const wrapCmd = (event) => `sh "${launcher}" "${wrapper}" ${event}`;
+    const block = {
+        PostToolUse: [
+            { matcher: '.*', hooks: [{ type: 'command', command: wrapCmd('post-tool-use'), timeout: 30 }] },
+        ],
+        Stop: [
+            { hooks: [{ type: 'command', command: wrapCmd('stop'), timeout: 60 }] },
+        ],
+    };
+    let settings = {};
+    if (existing !== null) {
+        try {
+            settings = JSON.parse(existing);
+        }
+        catch {
+            return null; // user file we can't parse - leave it alone
+        }
+    }
+    if (JSON.stringify(settings.gipity ?? null) === JSON.stringify(block))
+        return null; // already current
+    settings.gipity = block;
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+/** Write the project-level Antigravity hooks (.agents/hooks.json) and stage
+ *  the wrapper script it invokes. POSIX only, same constraint as Codex's
+ *  hooks (the commands run through a POSIX sh launcher). */
+export function setupAgyHooks() {
+    if (process.platform === 'win32')
+        return;
+    const cwd = resolve(process.cwd());
+    if (cwd === resolve(homedir()))
+        return; // never treat $HOME as a project
+    mkdirSync(AGENT_HOOKS_DIR, { recursive: true });
+    writeFileSync(join(AGENT_HOOKS_DIR, 'agy-hooks.cjs'), AGY_HOOKS_SCRIPT);
+    const path = join(cwd, '.agents', 'hooks.json');
+    const existing = existsSync(path) ? readFileSync(path, 'utf-8') : null;
+    const next = applyAgyHooks(existing);
+    if (next === null)
+        return;
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, next);
+    console.log(existing === null
+        ? 'Wrote Antigravity sync + session-capture hooks (.agents/hooks.json).'
+        : 'Updated Antigravity hooks (.agents/hooks.json).');
+}
+/** Full Antigravity integration: skills at its own global root + project sync
+ *  hooks. Gated on the agy binary so machines without it get only the
+ *  AGENTS.md primer. Unlike Codex, agy needs no one-time hook-approval nudge -
+ *  confirmed live that project hooks fire without any manual trust step. */
+export function setupAgyIntegration() {
+    if (!binaryOnPath('agy'))
+        return;
+    ensureAgySkillsInstalled();
+    setupAgyHooks();
+}
 export function setupClaudeHooks() {
     // All hooks ship in the plugin - enable it at user scope (and clean up any
     // legacy hook blocks in the user-global settings while we're there).
@@ -746,6 +927,7 @@ export const SUPPORTED_TOOLS = [
     { key: 'claude', label: 'Claude Code (CLAUDE.md + Gipity plugin)', setup: setupClaudeMd, integrate: setupClaudeHooks },
     { key: 'codex', label: 'OpenAI Codex (AGENTS.md + skills + sync hooks)', setup: setupAgentsMd, integrate: setupCodexIntegration },
     { key: 'grok', label: 'Grok Build (AGENTS.md + Gipity plugin)', setup: setupAgentsMd, integrate: ensureGrokPluginInstalled },
+    { key: 'agy', label: 'Antigravity (AGENTS.md + skills + sync hooks)', setup: setupAgentsMd, integrate: setupAgyIntegration },
     { key: 'aider', label: 'Aider (AGENTS.md + .aider.conf.yml)', setup: setupAiderMd, optIn: true },
     { key: 'gemini', label: 'Gemini CLI (GEMINI.md)', setup: setupGeminiMd },
     { key: 'copilot', label: 'GitHub Copilot (.github/copilot-instructions.md)', setup: setupCopilotMd },

package/dist/sync.js

@@ -154,7 +154,7 @@ export async function acquireLock(progress) {
             // First time we're forced to wait: open the spinner so the wait is visible
             // (with an elapsed timer) rather than reading as a frozen process.
             if (!waitSpinner) {
-                waitSpinner = progress?.spinner('Waiting for another sync to finish…') ?? null;
+                waitSpinner = progress?.spinner('Waiting for another sync to finish...') ?? null;
             }
             await new Promise(r => setTimeout(r, LOCK_POLL_MS));
         }
@@ -735,9 +735,9 @@ async function syncInner(projectGuid, root, ignore, opts, interactive) {
     const config = { projectGuid, ignore };
     const p = opts.progress;
     const baseline = readBaseline(projectGuid);
-    p?.phase('Scanning local files…');
+    p?.phase('Scanning local files...');
     const local = walkLocal(root, ignore, baseline.files);
-    p?.phase('Checking Gipity for changes…');
+    p?.phase('Checking Gipity for changes...');
     const remote = await fetchRemote(projectGuid);
     // Ignored paths are invisible on BOTH sides: filtering only the local walk
     // would classify a remote copy as "added" (pull it), then next pass as a
@@ -761,7 +761,7 @@ async function syncInner(projectGuid, root, ignore, opts, interactive) {
             needHash.push(path);
     }
     if (needHash.length)
-        p?.phase(`Hashing ${needHash.length} file${needHash.length === 1 ? '' : 's'}…`);
+        p?.phase(`Hashing ${needHash.length} file${needHash.length === 1 ? '' : 's'}...`);
     await ensureLocalHashes(root, local, needHash);
     const planned = plan(local, remote, baseline.files);
     if (opts.plan) {
@@ -890,7 +890,7 @@ async function syncInner(projectGuid, root, ignore, opts, interactive) {
             // Either way we fall through to the single-file recovery below rather than
             // proceeding on a half-empty tree - a partial download must never be
             // mistaken for a complete one.
-            errors.push(`Bulk download incomplete (${err.message}); recovering files individually…`);
+            errors.push(`Bulk download incomplete (${err.message}); recovering files individually...`);
         }
         finally {
             // Settle the bar even if the extracted-byte tally fell short of the
@@ -903,7 +903,7 @@ async function syncInner(projectGuid, root, ignore, opts, interactive) {
         // an earlier truncated pull.
         const missing = wantedDownloads.filter(a => !downloadedBytes.has(a.path));
         if (missing.length) {
-            p?.phase(`Recovering ${missing.length} file${missing.length === 1 ? '' : 's'} the bulk download dropped…`);
+            p?.phase(`Recovering ${missing.length} file${missing.length === 1 ? '' : 's'} the bulk download dropped...`);
             for (const a of missing) {
                 // Verify against the remote's content hash: the downloads pass records
                 // this sha into the baseline, so bytes that don't match it must be