gent-cli 14.0.0 → 20.0.0

package/README.md

@@ -25,7 +25,7 @@ Beyond a faithful git-like workflow, Gent adds:
 - **`gent resolve`** — an interactive conflict resolver (ours / theirs / both / edit / AI).
 - **`gent summary`** — a repository health dashboard, plus **`gent log --graph`**.
 - **Optional AI** (`gent commit --ai`, `gent explain`, `gent summary --ai`, AI option in `gent resolve`) — off by default, enabled with `ANTHROPIC_API_KEY`.
-- **Genti, your terminal mascot** — a chunky pixel bot that *acts out* your workflow: it carries a file crate to the cloud on `gent push`, walks one home on `gent pull`, and reconciles two branches on `gent merge`. It plays once (in place, no scrollback spam) after a successful command. Meet it directly with `gent pet` (add `--loop` to keep it running; try `gent pet push|pull|merge|auth`). Set `GENT_NO_PET=1` (or run in CI / a non-interactive shell) to turn the celebrations off.
+- **Genti, your terminal mascot** — a mint one-eyed sky-jelly that *acts out* your workflow: it floats a file crate to the cloud on `gent push`, carries one home on `gent pull`, and reconciles two branches on `gent merge`. It plays once (in place, no scrollback spam) after a successful command. Meet it directly with `gent pet` (add `--loop` to keep it running; try `gent pet push|pull|merge|auth`). Set `GENT_NO_PET=1` (or run in CI / a non-interactive shell) to turn the celebrations off.
 
 See [docs/COMMANDS.md](docs/COMMANDS.md) for the full reference and
 [docs/ALGORITHMS.md](docs/ALGORITHMS.md) for how the engines work.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gent-cli",
-  "version": "14.0.0",
+  "version": "20.0.0",
   "description": "A modern, Git-like version control CLI with cloud sync, AI-powered superpowers (ask/review/docs/changelog), and zero-friction setup (gent setup/doctor/config).",
   "main": "src/index.js",
   "bin": {
@@ -8,14 +8,17 @@
   },
   "scripts": {
     "start": "node src/index.js",
-    "test": "node --check src/index.js && node --test tests/diff.test.js tests/merge.test.js tests/hash.test.js tests/merge-base.test.js tests/file-system.test.js && node tests/offline-e2e.js",
-    "test:unit": "node --test tests/diff.test.js tests/merge.test.js tests/hash.test.js tests/merge-base.test.js tests/file-system.test.js",
+    "test": "node --check src/index.js && node --test tests/diff.test.js tests/merge.test.js tests/hash.test.js tests/merge-base.test.js tests/file-system.test.js tests/web-urls.test.js && node tests/offline-e2e.js && node --test tests/git-compat/engine.test.js tests/git-compat/cli.test.js tests/git-compat/transport.test.js tests/git-compat/migrate.test.js",
+    "test:unit": "node --test tests/diff.test.js tests/merge.test.js tests/hash.test.js tests/merge-base.test.js tests/file-system.test.js tests/web-urls.test.js",
     "test:e2e": "node tests/offline-e2e.js",
     "test:remote:e2e": "node tests/remote-e2e.js",
     "demo": "bash demo.sh",
     "link": "npm link",
     "unlink": "npm unlink",
-    "prepublishOnly": "echo 'Ready to publish gent-cli!'"
+    "prepublishOnly": "echo 'Ready to publish gent-cli!'",
+    "test:canonical": "node --test tests/git-compat/engine.test.js tests/git-compat/cli.test.js tests/git-compat/transport.test.js tests/git-compat/migrate.test.js",
+    "test:independence": "node tests/git-compat/independence.js",
+    "test:interop": "node --test tests/interop/canonical.test.js"
   },
   "keywords": [
     "cli",

package/src/commands/canonical.js

@@ -0,0 +1,242 @@
+/** Canonical command adapters. Legacy repositories retain their v12 handlers
+ * until migration ships; no canonical command falls back to a legacy writer.
+ */
+const fs = require('fs').promises;
+const path = require('path');
+const repository = require('../utils/repository');
+const ops = require('../utils/gent-ops');
+const merge = require('../utils/merge-ops');
+const stash = require('../utils/stash-ops');
+const journal = require('../utils/canonical-journal');
+const worktree = require('../utils/worktree');
+const { GitIndex } = require('../utils/git-index');
+const { Lock } = require('../utils/lockfile');
+const { AttributesMatcher, looksBinary } = require('../utils/attributes');
+const { formatUnifiedDiff } = require('../utils/diff-engine');
+
+async function locatedCanonical() {
+    let found;
+    try { found = await repository.findGitdir(); } catch (error) {
+        if (error.code === 'GENT_NOT_A_REPOSITORY') return null;
+        throw error;
+    }
+    if (await repository.isLegacyRepository(found.commondir)) return null;
+    return repository.open();
+}
+
+function route(name, legacy) {
+    const handler = async (...args) => {
+        try {
+            for (let dir = process.cwd(); ; dir = path.dirname(dir)) {
+                if (await fs.access(path.join(dir, '.gent-migration.json')).then(() => true, () => false)) throw new Error('interrupted migration; use gent migrate --continue or --abort');
+                if (path.dirname(dir) === dir) break;
+            }
+            if (name === 'init') {
+                const options = args[0] || {};
+                if (!options.objectFormat) {
+                    const existing = await locatedCanonical();
+                    if (!existing) return legacy(...args);
+                    console.log(`Repository already initialized: ${existing.gitdir}`);
+                    return;
+                }
+                if (options.objectFormat !== 'sha256') throw new Error('only --object-format=sha256 is supported');
+                if (options.remote) throw new Error('canonical remote creation is not implemented yet');
+                const result = await repository.init(process.cwd());
+                console.log(`Initialized SHA-256 repository: ${result.gitdir}`);
+                return;
+            }
+            // CLI-global settings remain available inside canonical repositories.
+            if (name === 'config' && args[1]?.[0] && !/^(user\.|core\.|remote\.|branch\.)/i.test(args[1][0])) {
+                return legacy(...args);
+            }
+            const repo = await locatedCanonical();
+            if (!repo) return legacy(...args);
+            if (!handlers[name]) throw new Error(`gent ${name} is not implemented for canonical repositories yet`);
+            const readOnly = ['status', 'log', 'show', 'diff', 'summary'].includes(name);
+            let lock;
+            try {
+                if (!readOnly) {
+                    lock = await Lock.acquire(path.join(repo.gentWorktreeMetaDir, 'operation'));
+                    await repo.assertNoExternalOperation(`gent ${name}`);
+                    if (!(name === 'checkout' && args[1]?.abort)) await worktree.assertNoPendingCheckout(repo, `gent ${name}`);
+                }
+                const checkpointed = ['commit', 'checkout', 'reset', 'merge'].includes(name) && !args[1]?.abort && !args[0]?.abort;
+                const checkpoint = checkpointed ? await journal.begin(repo, name) : null;
+                const result = await handlers[name](repo, ...args);
+                if (checkpoint) await journal.finish(repo, checkpoint);
+                return result;
+            } finally { if (lock) await lock.release(); }
+        } catch (error) {
+            console.error(`Error: ${error.message}`);
+            process.exitCode = 1;
+        }
+    };
+    if (legacy.redo) handler.redo = route('redo', legacy.redo);
+    return handler;
+}
+
+const transport = require('../utils/smart-http');
+const handlers = {
+    async remote(repo, sub, args = []) {
+        const [name = 'origin', url] = args;
+        transport.nameCheck(name);
+        if (sub === 'add' || sub === 'set-url') {
+            if (!url) throw new Error('provide a remote URL');
+            if (sub === 'add' && repo.config.get(`remote.${name}.url`)) throw new Error('remote already exists');
+            repo.localConfig.set(`remote.${name}.url`, transport.remoteUrl(url));
+            repo.localConfig.set(`remote.${name}.fetch`, `+refs/heads/*:refs/remotes/${name}/*`);
+            await repo.localConfig.save();
+        } else if (sub === 'remove') {
+            repo.localConfig.unset(`remote.${name}.url`);
+            repo.localConfig.unset(`remote.${name}.fetch`);
+            await repo.localConfig.save();
+        } else if (!sub) console.log(transport.configured(repo, name));
+        else throw new Error('use remote add|set-url|remove');
+    },
+    async fetch(repo, remote = 'origin') { await transport.fetch(repo, remote); console.log(`Fetched ${remote}`); },
+    async push(repo, remote = 'origin', branch, options = {}) {
+        await transport.push(repo, remote, branch, options); console.log('Push complete');
+    },
+    async pull(repo, remote = 'origin', branch) {
+        branch ||= (await repo.refs.head()).branch;
+        if (!branch) throw new Error('specify a branch from detached HEAD');
+        await transport.fetch(repo, remote);
+        const result = await merge.merge(repo, `refs/remotes/${remote}/${branch}`);
+        console.log(result.status);
+        if (result.status === 'conflicts') process.exitCode = 1;
+    },
+    async undo(repo, options = {}) {
+        if (options.list) { for (const item of (await journal.read(repo)).undo.slice().reverse()) console.log(item.name); }
+        else console.log(`Undid ${await journal.restore(repo)}`);
+    },
+    async redo(repo) { console.log(`Redid ${await journal.restore(repo, true)}`); },
+    async status(repo) {
+        const state = await ops.status(repo);
+        console.log(`On ${state.head.branch || 'detached HEAD'}`);
+        for (const item of state.staged) console.log(`staged ${item.status}: ${item.path}`);
+        for (const item of state.unstaged) console.log(`unstaged ${item.status}: ${item.path}`);
+        for (const name of state.conflicted) console.log(`conflict: ${name}`);
+        for (const name of state.untracked) console.log(`untracked: ${name}`);
+        if (!state.staged.length && !state.unstaged.length && !state.conflicted.length && !state.untracked.length) console.log('Working tree clean');
+    },
+    async add(repo, files, options) {
+        const result = await ops.addPaths(repo, files, options);
+        console.log(`Staged ${result.staged.length} change(s), ${result.removed.length} deletion(s)`);
+    },
+    async rm(repo, files, options) { await ops.removePaths(repo, files, options); },
+    async commit(repo, options) {
+        if (options.ai) throw new Error('AI commit messages are not connected to canonical repositories yet');
+        if (!options.message) throw new Error('provide a commit message with -m');
+        if (options.all) {
+            const index = await GitIndex.read(repo.indexPath);
+            const files = [...new Set(index.entries.map(e => path.join(repo.worktree, e.path)))];
+            if (files.length) await ops.addPaths(repo, files);
+        }
+        const result = await ops.createCommit(repo, options);
+        console.log(`[${result.branch || 'detached'} ${result.oid.slice(0, 12)}] ${options.message}`);
+    },
+    async branch(repo, name, options) {
+        if (options.delete) await ops.deleteBranch(repo, options.delete);
+        else if (name) await ops.createBranch(repo, name);
+        else for (const branch of await ops.listBranches(repo)) console.log(`${branch.current ? '*' : ' '} ${branch.name} ${branch.oid.slice(0, 12)}`);
+    },
+    async checkout(repo, target, options) {
+        if (options.abort) { await worktree.abortCheckout(repo); console.log('Checkout restored'); return; }
+        const result = await ops.checkout(repo, target, options);
+        console.log(`Switched to ${result.branch || result.oid}`);
+    },
+    async reset(repo, files, options) {
+        if (options.hard) await ops.reset(repo, 'hard', options.hard === true ? 'HEAD' : options.hard);
+        else if (options.soft) await ops.reset(repo, 'soft', options.soft === true ? 'HEAD' : options.soft);
+        else if (files.length) await ops.unstagePaths(repo, files);
+        else await ops.reset(repo, 'mixed', 'HEAD');
+    },
+    async merge(repo, branch, options) {
+        if (options.abort) return merge.abortMerge(repo);
+        if (options.continue) return merge.concludeMerge(repo, options.message);
+        const result = await merge.merge(repo, branch, options);
+        console.log(result.status);
+        if (result.status === 'conflicts') {
+            console.log('Resolve files, stage with gent add, then gent merge --continue or gent commit -m <message>.');
+            process.exitCode = 1;
+        }
+    },
+    async resolve(repo) {
+        const index = await GitIndex.read(repo.indexPath);
+        for (const name of index.conflicts().keys()) console.log(name);
+        console.log('Edit conflicted files, then gent add <path> and gent merge --continue.');
+    },
+    async stash(repo, sub = 'push', options = {}) {
+        const position = Number(options.index || 0);
+        if (!Number.isInteger(position) || position < 0) throw new Error('stash index must be a nonnegative integer');
+        if (sub === 'list') { for (const item of await stash.list(repo)) console.log(`stash@{${item.index}}: ${item.message}`); }
+        else if (sub === 'push' || sub === 'save') console.log((await stash.push(repo, options)).message);
+        else if (['apply', 'pop', 'drop'].includes(sub)) await stash[sub](repo, position, options);
+        else throw new Error(`unknown stash operation '${sub}'`);
+    },
+    async tag(repo, name, options) {
+        if (options.delete) await ops.deleteTag(repo, options.delete);
+        else if (name) await ops.createTag(repo, name, options);
+        else for (const item of await ops.listTags(repo)) console.log(item.name);
+    },
+    async log(repo, options) {
+        if (options.graph || options.stat) throw new Error('canonical log --graph/--stat formatting is not implemented yet; use log --oneline');
+        for (const commit of await ops.walkHistory(repo, { max: Number(options.number) })) {
+            console.log(`${commit.oid.slice(0, 12)} ${commit.message.toString().split('\n')[0]}`);
+        }
+    },
+    async show(repo, ref = 'HEAD', options = {}) {
+        const oid = await ops.peelToCommit(repo, ref);
+        const commit = await repo.objects.readCommit(oid);
+        console.log(`commit ${oid}\nParents: ${commit.parents.join(' ')}\n${commit.message.toString()}`);
+        if (options.patch !== false) {
+            const before = commit.parents.length ? await worktree.readTreeRecursive(repo, (await repo.objects.readCommit(commit.parents[0])).tree) : new Map();
+            await printTreeDiff(repo, before, await worktree.readTreeRecursive(repo, commit.tree));
+        }
+    },
+    async diff(repo, files, options) {
+        const index = await GitIndex.read(repo.indexPath);
+        if (index.hasConflicts()) throw new Error('resolve conflicts before requesting a canonical diff');
+        const staged = new Map(index.staged().map(e => [e.path, e]));
+        const head = await repo.refs.head();
+        const before = options.staged ? await worktree.readTreeRecursive(repo, head.oid ? (await repo.objects.readCommit(head.oid)).tree : null) : staged;
+        const after = options.staged ? staged : new Map();
+        if (!options.staged) {
+            const attrs = new AttributesMatcher(repo);
+            for (const [name, entry] of staged) {
+                const snapshot = await worktree.snapshotPath(repo, name);
+                if (snapshot) after.set(name, { ...entry, mode: snapshot.mode, bytes: snapshot.mode === 0o120000 ? Buffer.from(snapshot.content, 'base64') : await attrs.toIndex(name, Buffer.from(snapshot.content, 'base64')) });
+            }
+        }
+        await printTreeDiff(repo, before, after, files, options.stat);
+    },
+    async summary(repo, options = {}) {
+        if (options.ai) throw new Error('AI summary is not connected to canonical repositories yet');
+        console.log(`${(await ops.walkHistory(repo)).length} commits, ${(await ops.listBranches(repo)).length} branches`);
+        await handlers.status(repo);
+    },
+    async config(repo, sub = 'list', args = []) {
+        const [key, value] = args;
+        if (sub === 'get') console.log(repo.config.get(key, ''));
+        else if (sub === 'set') {
+            if (!key || value === undefined) throw new Error('usage: gent config set <key> <value>');
+            if (!/^user\.(name|email)$/i.test(key)) throw new Error('canonical config writes currently support user.name and user.email only');
+            repo.localConfig.set(key, value); await repo.localConfig.save();
+        } else throw new Error('use gent config get <key> or gent config set user.name/user.email <value>');
+    }
+};
+
+async function printTreeDiff(repo, before, after, files = [], stat = false) {
+    const wanted = files.map(name => repo.relativePath(path.resolve(name)));
+    for (const name of new Set([...before.keys(), ...after.keys()])) {
+        if (wanted.length && !wanted.some(p => name === p || name.startsWith(p + '/'))) continue;
+        const a = before.get(name), b = after.get(name);
+        const read = item => item ? (item.bytes || repo.objects.readBlob(item.oid)) : Buffer.alloc(0);
+        const oldBytes = await read(a), newBytes = await read(b);
+        if (oldBytes.equals(newBytes) && a?.mode === b?.mode) continue;
+        if (stat || looksBinary(oldBytes) || looksBinary(newBytes)) console.log(`${name}: ${oldBytes.length} -> ${newBytes.length} bytes`);
+        else console.log(formatUnifiedDiff(name, oldBytes.toString(), newBytes.toString()));
+    }
+}
+
+module.exports = { route };

package/src/commands/clone.js

@@ -28,7 +28,6 @@ const ora = require('ora');
 const { ensureDir, writeJSON, pathExists } = require('../utils/fileSystem');
 const { GENT_DIR, CONFIG_FILE, STAGING_FILE, COMMITS_FILE, API_ENDPOINTS, buildRepoUrl, parseRemoteUrl } = require('../utils/constants');
 const apiClient = require('../utils/api-client');
-const authStorage = require('../utils/auth-storage');
 const { storeBlob, readBlob } = require('../utils/hash-engine');
 
 /**
@@ -46,14 +45,6 @@ async function clone(url, directory, options) {
     const spinner = ora(`Cloning from ${url}...`).start();
 
     try {
-        // Check auth
-        const isAuth = await authStorage.isAuthenticated();
-        if (!isAuth) {
-            spinner.fail(chalk.red('Not authenticated'));
-            console.log(chalk.yellow('Run "gent login" first'));
-            return;
-        }
-
         // Parse URL
         const repoInfo = parseRemoteUrl(url);
         if (!repoInfo) {
@@ -183,10 +174,8 @@ async function clone(url, directory, options) {
         spinner.fail(chalk.red('Clone failed'));
         if (error.response?.status === 404) {
             console.error(chalk.red('Repository not found'));
-        } else if (error.response?.status === 401) {
-            console.error(chalk.red('Authentication failed — run "gent login"'));
-        } else if (error.response?.status === 403) {
-            console.error(chalk.red('Access denied — you do not have permission to clone this repository'));
+        } else if (error.response?.status === 401 || error.response?.status === 403) {
+            console.error(chalk.red('This repository is private or you do not have access to it. Run "gent login" to clone private repositories you can access.'));
         } else if (error.response?.data) {
             console.error(chalk.red(JSON.stringify(error.response.data)));
         } else {

package/src/commands/pet.js

@@ -1,11 +1,11 @@
 /**
  * Pet Command — "Genti", the gent mascot.
  *
- * A chunky pixel-block creature that lives in your terminal and *acts out*
+ * A mint one-eyed sky-jelly that lives in your terminal and *acts out*
  * gent workflows:
  *
  *   gent pet            → idle: Genti breathes, blinks, waves, drops a tip
- *   gent pet push       → walks a file crate to the cloud, over and over
+ *   gent pet push       → floats a file crate to the cloud, over and over
  *   gent pet pull       → carries a crate back from the cloud
  *   gent pet merge      → stands between two branches and "thinks" them together
  *   gent pet auth       → little sign-in scene
@@ -25,10 +25,10 @@ const FRAME_MS = 90;
 
 // ── Palette ──────────────────────────────────────────────────────────────
 const C = {
-    body:   chalk.hex('#c97b5a'),   // Genti's orange skin
-    shade:  chalk.hex('#9c5a3f'),   // bottom shading
-    eye:    chalk.hex('#15110f'),   // dark eye holes
-    mouth:  chalk.hex('#5a2f22'),
+    body:   chalk.hex('#55e6c1'),   // Genti's mint glow
+    shade:  chalk.hex('#168f86'),   // lower-body depth
+    eye:    chalk.hex('#7c3aed'),   // single violet eye
+    mouth:  chalk.hex('#34205f'),
     crate:  chalk.hex('#e0b64d'),   // file crate edges
     crateIn:chalk.hex('#b98a1f'),   // crate fill
     cloud:  chalk.hex('#d6def0'),   // remote / cloud
@@ -115,49 +115,27 @@ class Canvas {
 }
 
 // ── Mascot sprite ────────────────────────────────────────────────────────
-// Body is a 12-wide block with a 1-col margin (transparent) each side.
+// Wide fins, one eye, and ribbon tentacles give Genti a sky-jelly silhouette.
 function mascot({ blink = false, mouth = '_', armUp = false } = {}) {
-    const W = 12;
-    const rows = [];
-    rows[0] = ' ' + '#'.repeat(W) + ' ';
-    rows[1] = ' ' + '#'.repeat(W) + ' ';
-    rows[2] = ' ' + '#'.repeat(W) + ' ';   // eyes row
-    rows[3] = ' ' + '#'.repeat(W) + ' ';
-    rows[4] = ' ' + '#'.repeat(W) + ' ';   // mouth row
-    rows[5] = ' ' + '@'.repeat(W) + ' ';   // shaded chin
-
-    const grid = rows.map(r => r.split(''));
-    const eye = blink ? '#' : 'O';
-    // eyes at body cols 3-4 and 8-9 → +1 for margin
-    [3, 4].forEach(c => grid[2][c + 1] = eye);
-    [8, 9].forEach(c => grid[2][c + 1] = eye);
-    // mouth at cols 5-8 (row4)
-    for (let c = 5; c <= 8; c++) grid[4][c + 1] = mouth;
-    // ears (stick out at row2)
-    grid[2][0] = '#';
-    grid[2][W + 1] = '#';
-
-    let body = grid.map(r => r.join(''));
-
-    // arm (raised wave) sits to the right of the head on row1
-    if (armUp) {
-        const r1 = body[1].split('');
-        r1[W + 1] = '#';
-        body[1] = r1.join('');
-        body.unshift('             #'); // tiny raised hand
-    } else {
-        body.unshift('              ');
-    }
-    return body; // 7 rows (incl. leading arm/space row), 14 wide
+    const eye = blink ? '##' : 'OO';
+    const smile = mouth.repeat(4);
+    return [
+        armUp ? '#    ####     ' : '     ####     ',
+        armUp ? ' ## ########  ' : '  ##########  ',
+        ' ############ ',
+        '##############',
+        `  ####${eye}####  `,
+        `   ##${smile}##   `,
+        '    @@@@@@    ',
+    ];
 }
 
-// Legs are separate so they can shuffle while the body glides.
+// Ribbon tentacles trail independently so the sky-jelly appears to float.
 function legs(step) {
-    // step: 'stand' | 'a' | 'b'
     const map = {
-        stand: '   ##      ##  ',
-        a:     '   ##       #  ',
-        b:     '   #       ##  ',
+        stand: '    @ @ @     ',
+        a:     '     @ @ @    ',
+        b:     '   @ @ @      ',
     };
     return [map[step] || map.stand];
 }
@@ -402,63 +380,83 @@ const up = (n) => `\x1b[${n}A`;
  * @param {boolean} opts.altScreen  use the alternate screen buffer
  * @returns {Promise<void>}
  */
-function play(sceneName, { loop = false, footer = true, goodbye = false, altScreen = false, maxTicks = Infinity } = {}) {
-    return new Promise((resolve) => {
-        const scene = SCENES[sceneName] || SCENES.idle;
-        const cv = new Canvas(CV_W, CV_H);
-        const state = { count: 0, tip: TIPS[Math.floor(Math.random() * TIPS.length)] };
-        const totalTicks = loop ? Infinity : Math.min(scene.cycle + 1, maxTicks); // one clean cycle, capped
-        let t = 0;
-        let printed = false;
-        let done = false;
-
-        const footerLine = () => footer
-            ? chalk.gray('  ') +
-              (loop ? chalk.gray('Ctrl+C to leave') : C.body('Genti')) +
-              chalk.gray('   ·   more scenes: ') + C.say('gent pet push|pull|merge')
-            : '';
-
-        const paint = () => {
-            cv.clear();
-            scene.fn(cv, t, state);
-            if (sceneName === 'idle' && loop && t > 0 && t % scene.cycle === 0) {
-                state.tip = TIPS[Math.floor(Math.random() * TIPS.length)];
-            }
-            const lines = cv.render().split('\n');
-            lines.push(footerLine());
-            const block = lines.map(l => CLEAR_LINE + l).join('\n');
-            if (altScreen) {
-                process.stdout.write(HOME + block);
-            } else {
-                if (printed) process.stdout.write(up(lines.length));
-                process.stdout.write(block + '\n');
-            }
-            printed = true;
-        };
-
-        const finish = () => {
-            if (done) return;
-            done = true;
-            clearInterval(timer);
-            process.removeListener('SIGINT', onSig);
-            process.stdout.write(SHOW + (altScreen ? LEAVE_ALT : ''));
-            if (goodbye) {
-                console.log(C.body('  Genti waves.') + chalk.gray(' Come back with ') + C.say('gent pet') + chalk.gray('.'));
-            }
-            resolve();
-        };
+function runLoop(sceneName, {
+    loop = false, footer = true, goodbye = false, altScreen = false,
+    maxTicks = Infinity, clearOnStop = false, exitOnSig = false,
+} = {}) {
+    const scene = SCENES[sceneName] || SCENES.idle;
+    const cv = new Canvas(CV_W, CV_H);
+    const state = { count: 0, tip: TIPS[Math.floor(Math.random() * TIPS.length)] };
+    const totalTicks = loop ? Infinity : Math.min(scene.cycle + 1, maxTicks);
+    const blockH = CV_H + (footer ? 1 : 0);
+    let t = 0;
+    let printed = false;
+    let done = false;
+    let resolveFn;
+    const promise = new Promise((r) => { resolveFn = r; });
+
+    const footerLine = () => footer
+        ? chalk.gray('  ') +
+          (loop ? chalk.gray('Ctrl+C to cancel') : C.body('Genti the sky-jelly')) +
+          chalk.gray('   ·   more scenes: ') + C.say('gent pet push|pull|merge')
+        : '';
+
+    const paint = () => {
+        cv.clear();
+        scene.fn(cv, t, state);
+        if (sceneName === 'idle' && loop && t > 0 && t % scene.cycle === 0) {
+            state.tip = TIPS[Math.floor(Math.random() * TIPS.length)];
+        }
+        const lines = cv.render().split('\n');
+        lines.push(footerLine());
+        const block = lines.map(l => CLEAR_LINE + l).join('\n');
+        if (altScreen) {
+            process.stdout.write(HOME + block);
+        } else {
+            if (printed) process.stdout.write(up(lines.length));
+            process.stdout.write(block + '\n');
+        }
+        printed = true;
+    };
 
-        const onSig = () => finish();
+    // Erase the inline block so the caller can print clean output in its place.
+    const eraseBlock = () => {
+        if (!printed) return;
+        process.stdout.write(up(blockH));
+        for (let i = 0; i < blockH; i++) process.stdout.write(CLEAR_LINE + (i < blockH - 1 ? '\n' : ''));
+        process.stdout.write(up(blockH - 1));
+    };
+
+    const stop = () => {
+        if (done) return;
+        done = true;
+        clearInterval(timer);
+        process.removeListener('SIGINT', onSig);
+        if (clearOnStop && !altScreen) eraseBlock();
+        process.stdout.write(SHOW + (altScreen ? LEAVE_ALT : ''));
+        if (goodbye) {
+            console.log(C.body('  Genti waves.') + chalk.gray(' Come back with ') + C.say('gent pet') + chalk.gray('.'));
+        }
+        resolveFn();
+    };
 
-        process.stdout.write((altScreen ? ENTER_ALT + HOME : '') + HIDE);
+    const onSig = () => { stop(); if (exitOnSig) process.exit(130); };
+
+    process.stdout.write((altScreen ? ENTER_ALT + HOME : '') + HIDE);
+    paint();
+    const timer = setInterval(() => {
+        t++;
+        if (t >= totalTicks) { paint(); return stop(); }
         paint();
-        const timer = setInterval(() => {
-            t++;
-            if (t >= totalTicks) { paint(); return finish(); }
-            paint();
-        }, FRAME_MS);
-        process.on('SIGINT', onSig);
-    });
+    }, FRAME_MS);
+    process.on('SIGINT', onSig);
+
+    return { promise, stop };
+}
+
+// Play a scene to completion (or until Ctrl+C when looping). Resolves when done.
+function play(sceneName, opts = {}) {
+    return runLoop(sceneName, opts).promise;
 }
 
 /**
@@ -528,6 +526,32 @@ async function celebrate(scene) {
     } catch (_) { /* ignore — decoration only */ }
 }
 
+/**
+ * Public: run `task` while Genti animates as the live loader — carrying the
+ * crate to the cloud on push, home on pull, etc. The animation loops until the
+ * task settles, then erases itself so the command can print its own result.
+ *
+ * Safe + transparent: with no TTY / GENT_NO_PET / CI it simply awaits the task
+ * with no animation. Always returns (or throws) exactly what `task` does.
+ *
+ * @param {string} scene           'push' | 'pull' | 'merge' | …
+ * @param {() => Promise<any>} task the real async work (e.g. the network call)
+ * @returns {Promise<any>}
+ */
+async function during(scene, task) {
+    if (!process.stdout.isTTY || process.env.GENT_NO_PET || process.env.CI || !SCENES[scene]) {
+        return task();
+    }
+    const anim = runLoop(scene, { loop: true, footer: true, altScreen: false, clearOnStop: true, exitOnSig: true });
+    try {
+        return await task();
+    } finally {
+        anim.stop();
+        await anim.promise;
+    }
+}
+
 module.exports = petCommand;
 module.exports.celebrate = celebrate;
 module.exports.banner = banner;
+module.exports.during = during;

package/src/commands/pull.js

@@ -73,14 +73,15 @@ async function pull(remoteName, branchName, options) {
 
         // 1. Fetch commits + objects for this branch in a single call. `since`
         //    lets the server send only what we don't have on a fast-forward.
-        spinner.text = `Fetching updates for ${branch}...`;
+        // Genti walks a crate home from the cloud while we fetch.
+        spinner.stop();
         let pullData;
         try {
             const pullUrl = buildRepoUrl(API_ENDPOINTS.REPO_PULL, repoInfo);
             const query = localHead
                 ? `?branch=${encodeURIComponent(branch)}&since=${encodeURIComponent(localHead)}`
                 : `?branch=${encodeURIComponent(branch)}`;
-            pullData = await apiClient.get(pullUrl + query);
+            pullData = await pet.during('pull', () => apiClient.get(pullUrl + query));
         } catch (error) {
             if (error.response?.status === 404) {
                 spinner.succeed(chalk.green('Remote branch not found — nothing to pull'));
@@ -138,7 +139,6 @@ async function pull(remoteName, branchName, options) {
 
             spinner.succeed(chalk.green(`Fast-forward: ${newCount} new commit(s)`));
             console.log(chalk.gray(`  ${remote}/${branch} → ${remoteHead.substring(0, 7)}`));
-            await pet.celebrate('pull');
         } else {
             // Diverged — need 3-way merge
             spinner.text = 'Branches diverged, merging...';
@@ -194,7 +194,6 @@ async function pull(remoteName, branchName, options) {
             } else {
                 spinner.succeed(chalk.green(`Merged ${newCount} remote commit(s)`));
                 console.log(chalk.gray(`  Merge commit: ${mergeCommit.hash.substring(0, 7)}`));
-                await pet.celebrate('pull');
             }
         }
     } catch (error) {

package/src/commands/push.js

@@ -232,20 +232,19 @@ async function push(remoteName, branchName, options) {
             tags: tagsToPush
         };
 
-        // Send to backend
+        // Send to backend — Genti carries the crate to the cloud while we wait.
         const pushUrl = buildRepoUrl(API_ENDPOINTS.REPO_PUSH, repoInfo);
-        const response = await apiClient.post(pushUrl, payload);
+        spinner.stop();
+        const response = await pet.during('push', () => apiClient.post(pushUrl, payload, { timeout: 120000 }));
 
         // Update remote ref
         config.remoteRefs[`${remote}/${branch}`] = localHead;
         await writeJSON(configPath, config);
 
-        spinner.succeed(chalk.green(`Pushed ${commitsToPush.length} commit(s) to ${remote}/${branch}`));
+        console.log(chalk.green(`✔ Pushed ${commitsToPush.length} commit(s) to ${remote}/${branch}`));
         console.log(chalk.gray(`  ${localHead.substring(0, 7)} → ${remote}/${branch}`));
         console.log(chalk.gray(`  ${packBlobs.length} blob(s), ${packTrees.length} tree(s) transferred`));
 
-        await pet.celebrate('push');
-
     } catch (error) {
         spinner.fail(chalk.red('Push failed'));