gipity 1.0.417 → 1.0.420

package/README.md

@@ -138,7 +138,7 @@ gipity sync down     # Pull remote changes
 | `gipity chat <message>` | Send a message to your Gipity agent |
 | `gipity db` | Query, list, create, or drop project databases |
 | `gipity memory` | Read/write agent and project memory |
-| `gipity sandbox run <code>` | Execute code in a sandboxed container |
+| `gipity sandbox run <code> --lang <js\|py\|bash>` | Execute code in a sandboxed container (language is required) |
 | `gipity project` | List, create, switch, or delete projects |
 | `gipity agent` | List, create, switch, or configure agents |
 | `gipity approval` | List, create, answer, or cancel pending approvals |
@@ -208,7 +208,7 @@ gipity memory write design_notes "use dark theme" --project
 Run code in a sandboxed Docker container with no network access. JavaScript, Python, and Bash.
 
 ```bash
-gipity sandbox run "console.log('Hello')"
+gipity sandbox run "console.log('Hello')" --lang js
 gipity sandbox run "import pandas; print(pandas.__version__)" --lang py
 gipity sandbox run "echo hello" --lang bash
 ```

package/dist/adopt-cwd.js

@@ -175,16 +175,19 @@ export function formatCwdLabel(cwd) {
         return norm;
     return parts.slice(-2).join('/');
 }
-/** Format byte count handling KB/MB/GB. utils.formatSize tops out at MB,
- *  which prints "1024.0 MB" for the 1 GB refuse threshold. */
+/** Format byte count handling KB/MB/GB/TB. utils.formatSize tops out at MB,
+ *  which prints "1024.0 MB" for the 1 GB refuse threshold. TB matters for
+ *  storage quotas, where the top plan is a flat 1 TB. */
 export function formatBytes(n) {
     if (n < 1024)
         return `${n} B`;
-    if (n < 1024 * 1024)
+    if (n < 1024 ** 2)
         return `${(n / 1024).toFixed(1)} KB`;
-    if (n < 1024 * 1024 * 1024)
-        return `${(n / (1024 * 1024)).toFixed(1)} MB`;
-    return `${(n / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+    if (n < 1024 ** 3)
+        return `${(n / 1024 ** 2).toFixed(1)} MB`;
+    if (n < 1024 ** 4)
+        return `${(n / 1024 ** 3).toFixed(2)} GB`;
+    return `${(n / 1024 ** 4).toFixed(2)} TB`;
 }
 /** Adopt `cwd` as a Gipity project. Mirrors `gipity init`'s flow:
  *    1. Slug = slugify(basename(cwd)) - provided by caller (so caller can

package/dist/commands/claude.js

@@ -148,6 +148,17 @@ function formatElapsed(ms) {
  *  truncate the file. Best-effort: a malformed or unreadable config is left
  *  untouched and never blocks the launch. Headless `-p` runs skip the dialog
  *  already, so this is only needed for interactive launches. */
+/** True when the Claude Code argv asks for stream-json output (both the
+ *  `--output-format stream-json` and `--output-format=stream-json` forms).
+ *  Combined with an inherited GIPITY_CONVERSATION_GUID this identifies a
+ *  relay-daemon spawn, where the daemon owns capture and lifecycle-hook
+ *  capture must stand down. Exported for tests. */
+export function hasStreamJsonFlag(args) {
+    const idx = args.indexOf('--output-format');
+    if (idx !== -1 && args[idx + 1] === 'stream-json')
+        return true;
+    return args.includes('--output-format=stream-json');
+}
 export function markFolderTrusted(dir) {
     try {
         const file = join(homedir(), '.claude.json');
@@ -675,12 +686,15 @@ export const claudeCommand = new Command('claude')
         // we can't satisfy the claude_code ownership rule, so hooks stay
         // offline for this run.
         //
-        // Note: when `--output-format stream-json` is present in argv, the
-        // relay daemon is capturing Claude's stdout directly and the hook-
-        // based transcript capture would double-post every event. In that
-        // case we intentionally do NOT propagate GIPITY_CONVERSATION_GUID
-        // to the Claude child (see childEnv assignment below) - the hook's
-        // existing "no guid → silent no-op" guard then skips capture.
+        // Note: when this process was spawned BY the relay daemon (inherited
+        // GIPITY_CONVERSATION_GUID) with `--output-format stream-json`, the
+        // daemon is capturing Claude's stdout directly and hook-based capture
+        // would double-post every event. In that case we set GIPITY_CAPTURE=off
+        // on the Claude child (see childEnv assignment below) so the hook
+        // runner stands down. A USER-supplied stream-json run has no daemon
+        // behind it - hooks stay armed there, or the conversation would sit
+        // empty forever (the qwen-flight zero-message bug, 2026-07-07).
+        const inheritedConvGuid = Boolean(process.env.GIPITY_CONVERSATION_GUID);
         let convGuidForHooks = process.env.GIPITY_CONVERSATION_GUID ?? null;
         if (!convGuidForHooks) {
             const device = relayState.getDevice();
@@ -819,14 +833,16 @@ export const claudeCommand = new Command('claude')
         // throws EINVAL on Node >=18.20.2/20.12.2 - the CVE-2024-27980 fix).
         const claudeCmd = resolveCommand('claude');
         const childEnv = { ...process.env };
-        // Gate hook-based capture: when the daemon is streaming via
-        // --output-format stream-json, it owns the capture and any hook
-        // post would be a dupe. Leaving GIPITY_CONVERSATION_GUID unset in
-        // the child's env trips the hook runner's early-return guard.
-        const streamJsonIdx = allArgs.indexOf('--output-format');
-        const daemonCapturing = streamJsonIdx !== -1 && allArgs[streamJsonIdx + 1] === 'stream-json';
+        // Gate hook-based capture: only when the DAEMON is streaming via
+        // --output-format stream-json (inherited guid = daemon spawn) does it
+        // own the capture; any hook post would then be a dupe. GIPITY_CAPTURE=off
+        // stands the hook runner down explicitly - merely unsetting the guid is
+        // no longer enough now that the runner self-arms from .gipity.json.
+        // A user-supplied stream-json run (no inherited guid) keeps hooks armed.
+        const daemonCapturing = inheritedConvGuid && hasStreamJsonFlag(allArgs);
         if (daemonCapturing) {
             delete childEnv.GIPITY_CONVERSATION_GUID;
+            childEnv.GIPITY_CAPTURE = 'off';
         }
         else if (convGuidForHooks) {
             childEnv.GIPITY_CONVERSATION_GUID = convGuidForHooks;

package/dist/commands/generate.js

@@ -274,11 +274,61 @@ Examples:
         process.exit(1);
     }
 });
+// ── SOUND ──────────────────────────────────────────────────────────────
+const soundCommand = new Command('sound')
+    .description(`Generate a sound effect from a text description using AI.
+
+Always billed to you (the caller) - the app's service billing_mode does not
+apply to direct generation, so there is never a reason to flip a service to
+owner_pays just to create assets.
+
+Tips:
+  - Describe the sound, not a scene (e.g. "cartoon boing with a springy wobble")
+  - Omit --duration to let the model pick a natural length (billing is per second)
+  - --influence closer to 1 follows the text more literally
+
+Examples:
+  gipity generate sound "cartoon character saying oof"
+  gipity generate sound "thunder rolling in the distance" --duration 5
+  gipity generate sound "sci-fi laser blast" -o src/assets/sounds/laser.mp3`)
+    .argument('<text>', 'Text description of the sound effect (max 1000 characters)')
+    .option('--duration <seconds>', 'Clip length in seconds (0.5-30; default: automatic)', (v) => parseFloat(v))
+    .option('--influence <n>', 'How closely to follow the prompt, 0.0-1.0 (higher = more literal)', (v) => parseFloat(v))
+    .option('-o, --output <file>', 'Output path (default ./sound.mp3). For audio your app ships, write it into the source tree so it deploys, e.g. -o src/assets/sounds/boing.mp3; the cwd default is fine for one-off generation.')
+    .option('--json', 'Output as JSON')
+    .action(async (text, opts) => {
+    try {
+        const { config } = await resolveProjectContext();
+        const doGenerate = () => post(`/projects/${config.projectGuid}/generate/sound`, {
+            text,
+            duration_seconds: opts.duration,
+            prompt_influence: opts.influence,
+        });
+        const result = opts.json
+            ? await doGenerate()
+            : await withSpinner('Generating sound effect…', doGenerate, { done: null });
+        const filename = opts.output || 'sound.mp3';
+        const savedPath = await downloadFile(result.url, filename);
+        if (opts.json) {
+            console.log(JSON.stringify({ ...result, saved: savedPath }));
+        }
+        else {
+            const sizeKb = Math.round(result.size_bytes / 1024);
+            console.log(`${muted(`Generated sound effect (${sizeKb}KB)`)}`);
+            console.log(success(`Saved to ${savedPath}`));
+        }
+    }
+    catch (err) {
+        printCommandError('Sound generation', err);
+        process.exit(1);
+    }
+});
 // ── PARENT COMMAND ─────────────────────────────────────────────────────
 export const generateCommand = new Command('generate')
-    .description('Generate images, video, speech, or music')
+    .description('Generate images, video, speech, sound effects, or music')
     .addCommand(imageCommand)
     .addCommand(videoCommand)
     .addCommand(speechCommand)
+    .addCommand(soundCommand)
     .addCommand(musicCommand);
 //# sourceMappingURL=generate.js.map

package/dist/commands/init.js

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import { basename, resolve, dirname } from 'path';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { getAccountSlug } from '../api.js';
 import { getConfig, getConfigPath, saveConfigAt } from '../config.js';
 import { getAuth } from '../auth.js';
@@ -26,6 +26,7 @@ export const initCommand = new Command('init')
     .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('--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:
@@ -86,14 +87,28 @@ Working with an existing Gipity project:
             // artifact introduced by a newer CLI (e.g. aider's .aider.conf.yml)
             // would sync up as project content. Union in the current defaults.
             if (existing) {
+                let changed = false;
                 const cur = existing.ignore ?? (existing.ignore = []);
                 const missing = DEFAULT_SYNC_IGNORE.filter(e => !cur.includes(e));
                 if (missing.length) {
                     cur.push(...missing);
-                    saveConfigAt(cwd, existing);
+                    changed = true;
+                }
+                // `--no-capture` on a re-init is the documented way to opt an
+                // existing project out of session recording. One-way from flags:
+                // a bare re-run never silently reverses an explicit opt-out
+                // (delete the key or set it true in .gipity.json to re-enable).
+                if (opts.capture === false && existing.captureHooks !== false) {
+                    existing.captureHooks = false;
+                    changed = true;
                 }
+                if (changed)
+                    saveConfigAt(cwd, existing);
             }
             console.log(success(`Refreshed primer files: ${primerSummary}.`));
+            if (opts.capture === false) {
+                console.log(success('Session recording disabled for this project (captureHooks: false in .gipity.json).'));
+            }
             return;
         }
         // Refuse $HOME / system roots - adopting one as a project root would
@@ -156,9 +171,27 @@ Working with an existing Gipity project:
         }
         if (adopted.applied > 0)
             console.log(`Synced ${adopted.applied} change${adopted.applied > 1 ? 's' : ''} with Gipity.`);
+        // Session recording opt-out. Written after adopt so it lands in the
+        // freshly created .gipity.json regardless of how the link happened.
+        if (opts.capture === false) {
+            try {
+                const cfg = JSON.parse(readFileSync(resolve(cwd, '.gipity.json'), 'utf-8'));
+                cfg.captureHooks = false;
+                saveConfigAt(cwd, cfg);
+            }
+            catch { /* config missing/unreadable - nothing to opt out of */ }
+        }
         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.'));
+            // Recording happens by default (however Claude Code is launched), so
+            // say so up front - consent should be explicit, not discovered later.
+            if (opts.capture === false) {
+                console.log(muted('Session recording is off for this project (captureHooks: false in .gipity.json).'));
+            }
+            else {
+                console.log(muted('Claude Code sessions here are recorded to your Gipity project (view at prompt.gipity.ai). Opt out: gipity init --no-capture.'));
+            }
         }
         else {
             console.log(success('Ready! Open this directory in your AI coding tool.'));

package/dist/commands/page-inspect.js

@@ -4,6 +4,7 @@ import { formatSize } from '../utils.js';
 import { brand, bold, error as clrError, warning, muted, info } from '../colors.js';
 import { run } from '../helpers/index.js';
 import { capWaitMs } from './page-eval.js';
+import { TOUCH_DEVICES as INSPECT_DEVICES, resolveTouchDevice } from './page-screenshot.js';
 /** A console line is an error-level entry (page error or console.error). */
 const isErrorLine = (line) => /^error:/i.test(line);
 /** A message-less, cross-origin "Script error." The throwing <script> lacks
@@ -39,6 +40,7 @@ export const pageInspectCommand = new Command('inspect')
     .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('--fake-media', 'Grant a synthetic microphone + camera and auto-accept the getUserMedia prompt, so voice/camera apps run headlessly (audio is a built-in tone, not real speech)')
+    .option('--device <name>', `Inspect as a real touch device: ${INSPECT_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.')
     // Hidden redirect: agents reach for `page inspect --screenshot`. We don't take
     // an image here (`page screenshot` is the single path for that) — just point there.
@@ -60,6 +62,7 @@ export const pageInspectCommand = new Command('inspect')
             waitForSelector: opts.waitFor || undefined,
             waitForTimeoutMs: opts.waitFor ? waitForTimeoutMs : undefined,
             fakeMedia: opts.fakeMedia || undefined,
+            device: opts.device ? resolveTouchDevice(opts.device) : undefined,
             auth: opts.auth || undefined,
         };
         const res = await post(`/tools/browser/inspect`, inspectBody);

package/dist/commands/page-screenshot.js

@@ -7,13 +7,20 @@ import { brand, bold, muted, success } from '../colors.js';
 import { formatSize } from '../utils.js';
 import { run } from '../helpers/index.js';
 import { withSpinner } from '../progress.js';
+/** `mobile` and `tablet` name a real handset/tablet rather than just a window size.
+ *  The server emulates it end to end - mobile user-agent, DPR, and crucially TOUCH,
+ *  so a page that gates its mobile UI on `'ontouchstart' in window` or
+ *  `navigator.maxTouchPoints` renders that UI instead of its desktop layout. The
+ *  dimensions here mirror the device's own metrics (reported in meta.json).
+ *  `device` values must be ones the server's BROWSER_DEVICES accepts. */
 const DEVICE_PRESETS = {
     default: { width: 1280, height: 720 },
     desktop: { width: 1920, height: 1080 },
     laptop: { width: 1366, height: 768 },
-    tablet: { width: 768, height: 1024, deviceScaleFactor: 2 },
-    mobile: { width: 390, height: 844, deviceScaleFactor: 3 },
+    tablet: { width: 820, height: 1180, deviceScaleFactor: 2, device: 'iPad' },
+    mobile: { width: 393, height: 852, deviceScaleFactor: 3, device: 'iPhone 15' },
 };
+const TOUCH_DEVICE_ALIASES = { mobile: 'iPhone 15', tablet: 'iPad' };
 const LABEL_WIDTH = 18; // "Screenshot dims:" + trailing space
 function label(text) {
     return muted((text + ':').padEnd(LABEL_WIDTH));
@@ -77,14 +84,43 @@ function parseViewportString(s) {
     }
     return dpr ? { width, height, deviceScaleFactor: dpr } : { width, height };
 }
+/** Device metrics for the exact server device names, so `--device "Pixel 9"` works
+ *  alongside the friendly `mobile`/`tablet` presets. Mirrors agent-browser's own
+ *  descriptors; the server re-applies them, these are for filenames + meta. */
+const EXACT_DEVICE_VIEWPORTS = {
+    'iPhone 15': { width: 393, height: 852, deviceScaleFactor: 3, device: 'iPhone 15' },
+    'iPhone 16': { width: 393, height: 852, deviceScaleFactor: 3, device: 'iPhone 16' },
+    'iPhone 16 Pro': { width: 402, height: 874, deviceScaleFactor: 3, device: 'iPhone 16 Pro' },
+    'iPhone 17': { width: 402, height: 874, deviceScaleFactor: 3, device: 'iPhone 17' },
+    'iPad': { width: 820, height: 1180, deviceScaleFactor: 2, device: 'iPad' },
+    'iPad Pro': { width: 1024, height: 1366, deviceScaleFactor: 2, device: 'iPad Pro' },
+    'Pixel 9': { width: 412, height: 923, deviceScaleFactor: 2.625, device: 'Pixel 9' },
+    'Galaxy S25': { width: 360, height: 800, deviceScaleFactor: 3, device: 'Galaxy S25' },
+};
+/** Emulatable devices the server accepts (its BROWSER_DEVICES). Shared with
+ *  `page inspect` so both commands take the same names. */
+export const TOUCH_DEVICES = Object.keys(EXACT_DEVICE_VIEWPORTS);
+/** Case-insensitively resolve a device name or `mobile`/`tablet` alias to a server
+ *  device name. Used by `page inspect`, which takes one device rather than viewports. */
+export function resolveTouchDevice(name) {
+    const key = name.trim().toLowerCase();
+    if (TOUCH_DEVICE_ALIASES[key])
+        return TOUCH_DEVICE_ALIASES[key];
+    const exact = TOUCH_DEVICES.find((d) => d.toLowerCase() === key);
+    if (exact)
+        return exact;
+    throw new Error(`Unknown --device: "${name}" (known: mobile, tablet, ${TOUCH_DEVICES.join(', ')})`);
+}
 function resolveDevice(name) {
     const key = name.trim().toLowerCase();
     const preset = DEVICE_PRESETS[key];
-    if (!preset) {
-        const available = Object.keys(DEVICE_PRESETS).join(', ');
-        throw new Error(`Unknown --device preset: "${name}" (known: ${available})`);
-    }
-    return preset;
+    if (preset)
+        return preset;
+    const exact = TOUCH_DEVICES.find((d) => d.toLowerCase() === key);
+    if (exact)
+        return EXACT_DEVICE_VIEWPORTS[exact];
+    const available = [...Object.keys(DEVICE_PRESETS), ...TOUCH_DEVICES].join(', ');
+    throw new Error(`Unknown --device preset: "${name}" (known: ${available})`);
 }
 function splitCsv(values) {
     if (!values || values.length === 0)
@@ -104,7 +140,7 @@ export const pageScreenshotCommand = new Command('screenshot')
     .option('--action <js>', 'Run JS in the page before capturing — e.g. click a button to enter a state ("document.getElementById(\'play\').click()"). Runs after the post-load delay, then settles again before the shot.')
     .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>', `Viewport preset(s): ${Object.keys(DEVICE_PRESETS).join(', ')} (comma-separated or repeat flag)`, appendOption, [])
+    .option('--device <names>', `Device preset(s): ${Object.keys(DEVICE_PRESETS).join(', ')} (comma-separated or repeat flag). mobile/tablet emulate a real touch device — touch events, mobile user-agent, DPR — 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 (audio is a built-in tone, not real speech)')
@@ -194,6 +230,8 @@ export const pageScreenshotCommand = new Command('screenshot')
                     width: s.viewport.width,
                     height: s.viewport.height,
                     device_scale_factor: s.viewport.deviceScaleFactor,
+                    ...(s.viewport.device ? { device: s.viewport.device } : {}),
+                    touch: !!s.viewport.touch,
                 },
                 width: s.width,
                 height: s.height,
@@ -215,6 +253,8 @@ export const pageScreenshotCommand = new Command('screenshot')
             console.log(`${label('Web page status')} ${meta.status}`);
         if (meta.performance)
             console.log(`${label('Web page perf')} ${fmtPerformance(meta.performance)}`);
+        if (s.viewport.device)
+            console.log(`${label('Emulated device')} ${s.viewport.device} ${muted('(touch events, mobile user-agent)')}`);
         const sizePart = formatSize(s.screenshotSizeBytes) + (meta.full ? ' (full page)' : '');
         console.log(`${label('Screenshot size')} ${sizePart}`);
         if (s.width && s.height)
@@ -234,7 +274,8 @@ export const pageScreenshotCommand = new Command('screenshot')
     for (let i = 0; i < meta.screenshots.length; i++) {
         const s = meta.screenshots[i];
         const dims = `${s.viewport.width}×${s.viewport.height}${s.viewport.deviceScaleFactor > 1 ? ` @${s.viewport.deviceScaleFactor}x` : ''}`;
-        console.log(`\n${brand('@ ' + dims)}`);
+        const deviceTag = s.viewport.device ? muted(` — ${s.viewport.device}, touch`) : '';
+        console.log(`\n${brand('@ ' + dims)}${deviceTag}`);
         const sizePart = formatSize(s.screenshotSizeBytes) + (meta.full ? ' (full page)' : '');
         console.log(`${label('Screenshot size')} ${sizePart}`);
         if (s.width && s.height)

package/dist/commands/sandbox.js

@@ -28,6 +28,81 @@ const INTERPRETERS = {
     bash: 'bash',
     sh: 'bash',
 };
+/** The three ways to pin a language, shown whenever none was pinned. */
+const PIN_LANGUAGE_HELP = [
+    '  gipity sandbox run bash "<code>"            # interpreter token (bash | python | node)',
+    '  gipity sandbox run --language bash "<code>" # explicit flag (js | py | bash)',
+    '  gipity sandbox run --file script.sh         # inferred from the file extension',
+].join('\n');
+/**
+ * Resolve the language from an explicit signal, or exit.
+ *
+ * Precedence: interpreter token > --language > --file extension.
+ *
+ * There is no default. js/python/bash are mutually exclusive, and plenty of
+ * snippets parse as more than one of them (`x = 1`, `a[0]`, `foo()`), so any
+ * default silently runs some fraction of input in the wrong interpreter. The old
+ * behavior defaulted to JavaScript, which meant a shell one-liner ran as JS and
+ * died with a Node `SyntaxError` at `/work/_run.js` - after paying for a project
+ * sync and a server round trip. Failing here instead costs nothing and says what
+ * to type. (`docs/skills/sandbox-tools.md` used to carry a hand-written "always
+ * pin the language" warning to work around this; the CLI enforces it now.)
+ */
+export function resolveLanguage(opts) {
+    const explicit = opts.langFromInterp
+        ?? (opts.langOpt ? LANG_MAP[opts.langOpt.toLowerCase()] ?? opts.langOpt : undefined);
+    if (explicit && !['javascript', 'python', 'bash'].includes(explicit)) {
+        console.error(clrError(`Invalid language: ${opts.langOpt}. Use: js, py, or bash`));
+        process.exit(1);
+    }
+    if (explicit)
+        return explicit;
+    const fromExt = opts.filePath
+        ? LANG_MAP[extname(opts.filePath).slice(1).toLowerCase()]
+        : undefined;
+    if (fromExt)
+        return fromExt;
+    if (opts.filePath) {
+        console.error(clrError(`Cannot infer the language of ${opts.filePath} from its extension (expected .js, .py, or .sh).`));
+        console.error(dim(`Pass --language explicitly:\n  gipity sandbox run --language py --file ${opts.filePath}`));
+        process.exit(1);
+    }
+    console.error(clrError('No language specified for inline code.'));
+    console.error(dim(`Pin it one of three ways:\n${PIN_LANGUAGE_HELP}`));
+    process.exit(1);
+}
+/** Truncate one arg for echoing back, so a 2 KB fragment doesn't flood the terminal. */
+function preview(arg) {
+    const flat = arg.replace(/\s+/g, ' ').trim();
+    return flat.length > 60 ? `${flat.slice(0, 57)}...` : flat;
+}
+/**
+ * Inline code arrived as several positional args, which means the caller's shell
+ * split it before the CLI ever saw it. The old message ("Unrecognized
+ * invocation") just restated the rules and left the caller to guess which one it
+ * broke - an agent that hits this typically retries the same mangled quoting.
+ *
+ * So: show the fragments we actually received (the split point is the evidence),
+ * then name the usual cause. On PowerShell a double-quoted string interpolates
+ * `$(...)` and backslash is NOT an escape character, so a POSIX-style
+ * `"... $(cmd) ... \"$f\" ..."` one-liner both runs `cmd` locally and terminates
+ * the string early at `\"`. That is exactly how one quoted arg becomes many.
+ */
+function explainSplitArgs(args) {
+    const looksInterpolated = args.some(a => a.includes('$(') || a.includes('`'));
+    const lines = [
+        clrError(`Inline code must be a single argument, but ${args.length} were received:`),
+        ...args.slice(0, 4).map((a, i) => dim(`  ${i + 1}: ${preview(a)}`)),
+        ...(args.length > 4 ? [dim(`  ... and ${args.length - 4} more`)] : []),
+        '',
+        'Your shell split the code before the CLI saw it.',
+    ];
+    if (looksInterpolated) {
+        lines.push(dim('In PowerShell a double-quoted string interpolates $(...), and backslash does not'), dim('escape a quote - so a POSIX one-liner runs its subshell locally and ends early.'));
+    }
+    lines.push('', 'Fix, in order of preference:', dim('  1. Put the code in a file (best for anything with quotes, $(...), or newlines):'), '       gipity sandbox run --file script.sh', dim('  2. Use the interpreter shorthand on a file:'), '       gipity sandbox run bash script.sh', dim('  3. Keep it inline, but as ONE argument your shell will not split:'), "       gipity sandbox run --language bash 'echo hi'");
+    return lines.join('\n');
+}
 /** Project-relative path from the process cwd, or undefined when there's
  *  no local config (one-off mode) or the cwd is at/above the project root. */
 function resolveRelativeCwd() {
@@ -45,7 +120,11 @@ export const sandboxCommand = new Command('sandbox')
 sandboxCommand
     .command('run [args...]')
     .description('Run code')
-    .option('--language <language>', 'Language: js, py, or bash', 'js')
+    // No default. js/python/bash are mutually exclusive and the same snippet can
+    // parse as more than one of them, so an implicit default silently runs code in
+    // the wrong interpreter. Every invocation must pin the language via this flag,
+    // an interpreter token, or a --file extension - see resolveLanguage().
+    .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('--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.', (v, prev) => [...(prev ?? []), v])
@@ -89,8 +168,12 @@ Pre-installed: Python (pandas, numpy, matplotlib, Pillow, scipy, bs4),
 CLI tools (ImageMagick, FFmpeg, webp/cwebp, optipng, jq, pandoc, exiftool,
 GCC/Rust).
 `)
-    .action((args = [], opts, command) => run('Sandbox', async () => {
-    const { config } = await resolveProjectContext();
+    .action((args = [], opts) => run('Sandbox', async () => {
+    // Everything below this point is pure argument validation - it reads the local
+    // filesystem and nothing else. It runs BEFORE resolveProjectContext() so a
+    // malformed invocation fails on the spot instead of first paying a project
+    // lookup (and printing a misleading "→ (project: …)" banner) only to reject
+    // the args a moment later.
     // Resolve the positional args into either inline code or a script-file path.
     // `run <interpreter> <file>` (e.g. `run python build_report.py`) is the natural
     // mental model, so accept it: a leading interpreter token + a path becomes
@@ -112,7 +195,7 @@ GCC/Rust).
         inlineCode = args[0];
     }
     else if (args.length > 1) {
-        console.error(clrError('Unrecognized invocation. Pass inline code as a single quoted arg, a script with --file <path>, or use the `run <python|node|bash> <file>` shorthand.'));
+        console.error(explainSplitArgs(args));
         process.exit(1);
     }
     if (inlineCode !== undefined && filePath) {
@@ -133,22 +216,13 @@ GCC/Rust).
             process.exit(1);
         }
     }
-    // Language precedence: interpreter token > file extension (unless --language
-    // was passed explicitly) > the --language value (default js).
-    const fromExt = filePath && !langFromInterp && command.getOptionValueSource('language') === 'default'
-        ? LANG_MAP[extname(filePath).slice(1).toLowerCase()]
-        : undefined;
-    const language = langFromInterp || fromExt || LANG_MAP[opts.language] || opts.language;
-    // True when the run fell back to the implicit JS default - nothing in the
-    // command shape pinned a language. Used to explain the execution mode if a
-    // shell/Python snippet gets parsed as JavaScript and blows up (see hint below).
-    const usedDefaultJs = !langFromInterp
-        && command.getOptionValueSource('language') === 'default'
-        && language === 'javascript';
-    if (!['javascript', 'python', 'bash'].includes(language)) {
-        console.error(clrError(`Invalid language: ${opts.language}. Use: js, py, or bash`));
-        process.exit(1);
-    }
+    // Language precedence: interpreter token > --language > file extension.
+    // There is deliberately no fallback: resolveLanguage() exits when nothing
+    // pinned one, rather than guessing. This runs BEFORE the project sync and the
+    // server round trip below, so a missing language costs nothing but the message.
+    const language = resolveLanguage({ langFromInterp, langOpt: opts.language, filePath });
+    // Args are good - now it's worth resolving (and announcing) the project.
+    const { config } = await resolveProjectContext();
     const timeout = parseInt(opts.timeout, 10);
     const cwd = resolveRelativeCwd();
     // Push local working-tree changes up before executing. The sandbox mirrors
@@ -207,12 +281,8 @@ GCC/Rust).
                 console.log(`${f}`);
         }
         if (res.data.exitCode !== 0) {
-            // A SyntaxError / CJS-loader trace under the implicit JS default almost
-            // always means the input was shell or Python that got run as JavaScript.
-            // The raw Node stack trace never says which mode ran, so name it.
-            if (usedDefaultJs && /SyntaxError|cjs\/loader|wrapSafe/.test(res.data.stderr || '')) {
-                console.error(dim('Hint: ran as JavaScript (the default). For a shell command pass `--language bash` (or `gipity sandbox run bash "<cmd>"`); for Python pass `--language py`.'));
-            }
+            // No "did you mean another language?" hint is needed: the language is now
+            // always something the caller pinned, never a silent default we chose.
             process.exit(res.data.exitCode);
         }
     }

package/dist/commands/service.js

@@ -13,7 +13,7 @@ const SERVICES = [
     { name: 'image/models', method: 'GET', desc: 'List image providers/models' },
     { name: 'tts', method: 'POST', desc: 'Text-to-speech ({ text, voice?, ... })' },
     { name: 'tts/voices', method: 'GET', desc: 'List TTS voices' },
-    { name: 'sound', method: 'POST', desc: 'Sound effect ({ prompt, duration_seconds? })' },
+    { name: 'sound', method: 'POST', desc: 'Sound effect ({ text, duration_seconds? })' },
     { name: 'music', method: 'POST', desc: 'Music generation ({ prompt, duration_seconds? })' },
     { name: 'video', method: 'POST', desc: 'Video generation ({ prompt, ... })' },
     { name: 'location/ip', method: 'POST', desc: 'IP geolocation ({ ip? })' },

package/dist/commands/storage.js

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
 import { get, patch } from '../api.js';
-import { brand, muted } from '../colors.js';
+import { formatBytes } from '../adopt-cwd.js';
+import { bold, brand, muted, warning } from '../colors.js';
 import { run } from '../helpers/index.js';
 /** Parse a CLI flag value as a positive whole number, or throw a friendly error.
  *  The server is the source of truth for the plan-cap bound; this just rejects
@@ -22,8 +23,49 @@ function printRetention(d, updated) {
     console.log(`  ${muted(`days: ${daysNote}, copies: ${countNote}`)}`);
     console.log(muted(`Plan allows up to ${d.maxDays} days / ${d.maxCount} copies.`));
 }
+function row(label, value, note = '') {
+    console.log(`  ${label.padEnd(16)} ${value.padStart(10)}${note ? `  ${muted(note)}` : ''}`);
+}
+function printUsage(d) {
+    const over = d.usedBytes > d.quotaBytes;
+    const pct = d.quotaBytes > 0 ? Math.round((d.usedBytes / d.quotaBytes) * 100) : 0;
+    const headline = `${formatBytes(d.usedBytes)} of ${formatBytes(d.quotaBytes)} used (${pct}%)`;
+    console.log(`Storage: ${over ? warning(headline) : brand(headline)}`);
+    console.log('');
+    const s = d.storage;
+    row('Live files', formatBytes(s.liveBytes), `${s.liveFiles.toLocaleString()} files`);
+    row('All versions', formatBytes(s.versionedBytes), `${s.versionCount.toLocaleString()} versions`);
+    row('Dedup saved', formatBytes(s.dedupSavedBytes), `${s.dedupedObjects.toLocaleString()} shared`);
+    row('Billed', formatBytes(s.physicalBytes), 'versions kept, dedup applied');
+    if (d.projects.length > 0) {
+        console.log('');
+        console.log(`${bold('By project')} ${muted('(live files only)')}`);
+        for (const p of d.projects) {
+            const name = p.projectName ?? '(no project)';
+            row(name.length > 16 ? `${name.slice(0, 15)}…` : name, formatBytes(p.liveBytes), `${p.liveFiles.toLocaleString()} files`);
+        }
+    }
+    const r = d.versionRetention;
+    console.log('');
+    console.log(muted(`Version retention: ${r.days} days / ${r.count} copies (plan allows up to ${r.maxDays} / ${r.maxCount}).`));
+    if (over) {
+        console.log(warning('Over quota. Delete files you no longer need, or keep less history with `gipity storage retention`.'));
+    }
+}
 export const storageCommand = new Command('storage')
     .description('Manage file storage settings');
+storageCommand
+    .command('usage')
+    .description('Show what is using your storage, per project and live vs. version history')
+    .option('--json', 'Output as JSON')
+    .action((opts) => run('Usage', async () => {
+    const res = await get('/users/me/storage');
+    if (opts.json) {
+        console.log(JSON.stringify(res.data));
+        return;
+    }
+    printUsage(res.data);
+}));
 storageCommand
     .command('retention')
     .description('View or adjust your file version-retention policy')

package/dist/hooks/capture-runner.js

@@ -2,7 +2,7 @@
 /**
  * Internal hook runner - invoked by Claude Code's lifecycle hooks
  * (SessionStart, Stop, SubagentStop, SessionEnd, and a throttled
- * PostToolUse for mid-run flushing) to mirror a terminal `gipity claude`
+ * PostToolUse for mid-run flushing) to mirror a terminal Claude Code
  * session into the Gipity server so the web CLI can display it read-only.
  *
  * Not a user-facing `gipity` subcommand by design: users never invoke
@@ -16,9 +16,22 @@
  *   source: 'claude-code' (today) | future: 'codex', …
  *   event:  'session-start' | 'stop' | 'subagent-stop' | 'session-end' | 'post-tool-use' | 'pre-compact'
  *
+ * Conversation binding, in order:
+ *   1. GIPITY_CONVERSATION_GUID env var - set by `gipity claude`, which
+ *      created/reused the conversation before spawning Claude Code.
+ *   2. A session_id → conv mapping persisted in the capture-state dir by
+ *      an earlier event of this session.
+ *   3. Self-arm: the session was launched WITHOUT `gipity claude` (bare
+ *      `claude` in a linked project dir). Resolve the project from
+ *      .gipity.json and ask the server to bind this session_id to a
+ *      conversation (POST /remote-sessions/resolve), then persist the
+ *      mapping. This is what makes bare `claude` sessions record.
+ *
  * Graceful no-ops (exit 0 silently):
- *   - GIPITY_CONVERSATION_GUID env var unset (hook fired from a bare
- *     `claude`, not `gipity claude`).
+ *   - GIPITY_CAPTURE=off - the relay daemon owns capture for this run
+ *     (it parses stream-json from stdout), or the caller opted out.
+ *   - No binding resolvable: not a Gipity project, `captureHooks: false`
+ *     in .gipity.json, or the resolve call failed.
  *   - The machine isn't paired - no device token available.
  *   - Anything unexpected (parse error, network error, etc.). We must
  *     not break the user's interactive session.
@@ -28,6 +41,7 @@ import { homedir } from 'os';
 import { join } from 'path';
 import { getDevice } from '../relay/state.js';
 import { deviceFetch } from '../relay/device-http.js';
+import { getConfig } from '../config.js';
 import { parseTranscript, } from '../capture/sources/claude-code.js';
 const CAPTURE_DIR = join(homedir(), '.gipity', 'capture-state');
 const INGEST_BATCH_MAX = 100; // server caps at 200; stay comfortably under
@@ -159,6 +173,117 @@ export function acquireLock(convGuid) {
     }
     return null;
 }
+// ─── conversation binding ────────────────────────────────────────────
+// Sessions launched via `gipity claude` carry GIPITY_CONVERSATION_GUID.
+// Bare `claude` in a linked project has no env binding, so the first
+// event resolves one from the server (keyed by the agent session_id) and
+// persists it here for every later event of the session.
+/** session_id is Claude Code's session UUID - filesystem-safe by
+ *  construction; the character guard keeps a hostile hook payload from
+ *  escaping the capture-state dir (used for both the mapping file and
+ *  the resolve lock). */
+function safeSessionKey(sessionId) {
+    return `sid-${sessionId.replace(/[^A-Za-z0-9._-]/g, '_')}`;
+}
+function sessionMapPath(sessionId) {
+    return join(CAPTURE_DIR, `${safeSessionKey(sessionId)}.json`);
+}
+function readSessionMap(sessionId) {
+    try {
+        const parsed = JSON.parse(readFileSync(sessionMapPath(sessionId), 'utf-8'));
+        return typeof parsed.conv_guid === 'string' ? parsed.conv_guid : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeSessionMap(sessionId, convGuid) {
+    mkdirSync(CAPTURE_DIR, { recursive: true });
+    writeFileSync(sessionMapPath(sessionId), JSON.stringify({ conv_guid: convGuid }) + '\n');
+}
+function deleteSessionMap(sessionId) {
+    try {
+        unlinkSync(sessionMapPath(sessionId));
+    }
+    catch { /* already gone */ }
+}
+/** Ask the server which conversation this session belongs to: the conv
+ *  already bound to this session_id (resume), the project's still-empty
+ *  placeholder, or a fresh one. Returns null on any failure - capture is
+ *  best-effort and must never break the session. */
+async function resolveFromServer(projectGuid, hook) {
+    let res;
+    try {
+        res = await deviceFetch('POST', '/remote-sessions/resolve', {
+            project_guid: projectGuid,
+            session_id: hook.session_id,
+            cwd: hook.cwd,
+        }, 15_000);
+    }
+    catch {
+        return null;
+    }
+    if (!res.ok)
+        return null;
+    try {
+        const body = await res.json();
+        return body.data?.conversation_guid ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Resolve the conversation this event writes to. Env binding first (set
+ *  by `gipity claude`), then the session's persisted mapping, then the
+ *  self-arm server resolve. The resolve is serialized per-session with
+ *  the same crash-safe lock the flushers use, so concurrent hooks (Stop +
+ *  SubagentStop) can't each mint a conversation: the loser polls for the
+ *  winner's mapping instead of racing the server. */
+export async function resolveConvGuid(hook, sleep = (ms) => new Promise(r => setTimeout(r, ms))) {
+    const fromEnv = process.env.GIPITY_CONVERSATION_GUID;
+    if (fromEnv)
+        return fromEnv;
+    const sessionId = hook.session_id;
+    if (!sessionId)
+        return null;
+    const mapped = readSessionMap(sessionId);
+    if (mapped)
+        return mapped;
+    // Self-arm gates: linked project, capture not opted out, machine paired
+    // (main() already checked the device, but resolveConvGuid is also the
+    // unit-tested entry - keep it self-sufficient).
+    const config = getConfig();
+    if (!config?.projectGuid || config.captureHooks === false)
+        return null;
+    if (!getDevice())
+        return null;
+    const release = acquireLock(safeSessionKey(sessionId));
+    if (!release) {
+        // Another hook instance is resolving this session right now. Give it
+        // a moment and use its result; bail silently if it never lands (the
+        // next event retries the whole resolution).
+        for (let i = 0; i < 10; i++) {
+            await sleep(300);
+            const conv = readSessionMap(sessionId);
+            if (conv)
+                return conv;
+        }
+        return null;
+    }
+    try {
+        // Re-check under the lock - the previous holder may have just finished.
+        const raced = readSessionMap(sessionId);
+        if (raced)
+            return raced;
+        const conv = await resolveFromServer(config.projectGuid, hook);
+        if (conv)
+            writeSessionMap(sessionId, conv);
+        return conv;
+    }
+    finally {
+        release();
+    }
+}
 async function readStdin() {
     if (process.stdin.isTTY)
         return '';
@@ -262,6 +387,8 @@ async function handleSessionEnd(convGuid, hook, source) {
         }];
     await postEntries(convGuid, entries);
     deleteState(convGuid);
+    if (hook.session_id)
+        deleteSessionMap(hook.session_id);
 }
 function displayName(source) {
     if (source === 'claude-code')
@@ -269,9 +396,12 @@ function displayName(source) {
     return source;
 }
 async function main() {
-    const convGuid = process.env.GIPITY_CONVERSATION_GUID;
-    if (!convGuid)
-        return; // bare `claude`, not `gipity claude`
+    // Explicit capture opt-out. Set by the relay daemon's dispatch spawns
+    // (the daemon parses stream-json from stdout - hook capture would
+    // double-post every event) and available to anyone wanting a one-off
+    // unrecorded session.
+    if (process.env.GIPITY_CAPTURE === 'off')
+        return;
     if (!getDevice())
         return; // machine not paired
     const [source, event] = process.argv.slice(2);
@@ -285,6 +415,9 @@ async function main() {
         }
         catch { /* ignore - event may not require transcript */ }
     }
+    const convGuid = await resolveConvGuid(hook);
+    if (!convGuid)
+        return; // not a Gipity-bound session - nothing to capture
     try {
         switch (event) {
             case 'session-start':

package/dist/knowledge.js

@@ -51,7 +51,7 @@ Prefer the cheapest option that works - CLI and sandbox are instant and free, ap
 
 1. CLI commands (fast, no agent overhead). The \`gipity\` CLI covers add, deploy, db, fn, logs, browser, sync, memory, skill, email, and more. All commands support \`--json\`. You can send email yourself - \`gipity email send\` goes out as the agent from \`gipity@gipity.ai\` with no setup or API keys (\`gipity skill read email\`); don't build a \`mailto:\` workaround or reach for an SMTP library.
 2. Cloud sandbox via \`gipity sandbox run\` - Docker container with pre-installed tools for media (ffmpeg, ImageMagick, sox), documents (pandoc, LibreOffice), and data (pandas, matplotlib, sqlite3). Run \`gipity skill read sandbox-tools\` for the full toolkit. No network from inside the sandbox - fetch what you need before sending it in.
-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|music>\` or \`gipity chat\`. \`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.
+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.
@@ -84,6 +84,8 @@ The one exception is app-level libraries the user imports into their own \`src/\
 
 ## Build loop
 
+Prefer a live Gipity URL over an ephemeral artifact. When you'd otherwise reach for a Claude Code Artifact (or any host's built-in page preview) to show the user something, build it as a Gipity app and \`gipity deploy dev\` instead - the result is a real, shareable URL on their own project, not a throwaway.
+
 The full "when to add a template" rule and the definition of done are spelled out in the two sections at the end of this document. In short: if the user wants something deployable (web app, game, API), \`gipity add <template>\` first (default \`web-simple\`); for a one-off task (analysis, PDFs, data work), use \`gipity sandbox run\` instead; to add a reusable building block to an existing app (e.g. multiplayer), \`gipity add <kit>\`.
 
 Build loop: \`gipity add\` → edit files → \`gipity deploy dev\` → \`gipity page inspect <url>\` → fix any errors → repeat until the definition of done is met.

package/dist/relay/daemon.js

@@ -1233,7 +1233,12 @@ export async function spawnGipityClaude(args, cwd, d, queue, meta) {
     // feed the ephemeral live-typing channel (see stream-delta.ts); whole
     // assistant/tool events still arrive unchanged for the persistent path.
     const fullArgs = [...args, '--output-format', 'stream-json', '--verbose', '--include-partial-messages'];
-    const env = childEnv({ GIPITY_CONVERSATION_GUID: d.conversation_guid });
+    // GIPITY_CAPTURE=off: the daemon owns capture for this dispatch (it
+    // parses the stream-json on stdout), so the plugin's lifecycle-hook
+    // capture must stand down. `gipity claude` sets the same sentinel on the
+    // Claude child when it detects a daemon spawn; setting it here too keeps
+    // dispatches double-post-free even across CLI version skew.
+    const env = childEnv({ GIPITY_CONVERSATION_GUID: d.conversation_guid, GIPITY_CAPTURE: 'off' });
     return new Promise((resolve, reject) => {
         const child = spawnCommand(cmd, fullArgs, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
         // `exited` fires when the child fully unwinds (exit event). Callers

package/dist/setup.js

@@ -145,7 +145,7 @@ export const LEGACY_MARKETPLACE_REPO = 'GipityAI/claude-plugin';
 // an installed plugin when the marketplace advances - only an explicit
 // `plugin install`/`update` does - so this constant is how a CLI upgrade tells
 // ensureGipityPluginInstalled() to refresh a stale user-scope install.
-export const GIPITY_PLUGIN_VERSION = '0.4.1';
+export const GIPITY_PLUGIN_VERSION = '0.5.0';
 /** True for hook commands the CLI itself wrote into settings.json in past
  *  versions. Matched by signature so migration strips exactly our own
  *  entries and never touches user-authored hooks. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gipity",
-  "version": "1.0.417",
+  "version": "1.0.420",
   "description": "The full-stack platform tuned for AI agents. Database, storage, auth, functions, deploy, and drop-in kits - all agent-tuned. Pair with Claude Code or use standalone.",
   "bin": {
     "gipity": "dist/updater/shim.js",
@@ -13,7 +13,7 @@
     "postbuild": "node scripts/gen-build-info.mjs",
     "dev": "tsc --watch",
     "test": "npm run test:smoke",
-    "test:smoke": "tsc && node --test dist/__tests__/utils.test.js dist/__tests__/platform.test.js dist/__tests__/colors.test.js dist/__tests__/config.test.js dist/__tests__/sync.test.js dist/__tests__/sync-apply.test.js dist/__tests__/sync-lock.test.js dist/__tests__/auth-lock.test.js dist/__tests__/api-401-retry.test.js dist/__tests__/push-cas.test.js dist/__tests__/upload.test.js dist/__tests__/progress.test.js dist/__tests__/updater.test.js dist/__tests__/cli-smoke.test.js dist/__tests__/claude-noninteractive.test.js dist/__tests__/claude-trust.test.js dist/__tests__/relay-state.test.js dist/__tests__/relay-daemon.test.js dist/__tests__/relay-diagnostics.test.js dist/__tests__/relay-installers.test.js dist/__tests__/relay-bridge-abort.test.js dist/__tests__/relay-redact.test.js dist/__tests__/relay-machine-id.test.js dist/__tests__/stream-json.test.js dist/__tests__/ingest-queue.test.js dist/__tests__/stream-delta.test.js dist/__tests__/phase-tracker.test.js dist/__tests__/relay-ingest-contract.test.js dist/__tests__/prompts.test.js dist/__tests__/capture-transcript.test.js dist/__tests__/flag-aliases.test.js dist/__tests__/client-context.test.js dist/__tests__/adopt-cwd.test.js dist/__tests__/cli-cmd-agent.test.js dist/__tests__/cli-cmd-approval.test.js dist/__tests__/cli-cmd-audit.test.js dist/__tests__/cli-cmd-chat.test.js dist/__tests__/cli-cmd-credits.test.js dist/__tests__/cli-cmd-db.test.js dist/__tests__/cli-cmd-deploy.test.js dist/__tests__/cli-cmd-domain.test.js dist/__tests__/cli-cmd-email.test.js dist/__tests__/cli-cmd-file.test.js dist/__tests__/cli-cmd-storage.test.js dist/__tests__/cli-cmd-fn.test.js dist/__tests__/cli-cmd-service.test.js dist/__tests__/cli-cmd-job.test.js dist/__tests__/cli-cmd-generate.test.js dist/__tests__/cli-cmd-gmail.test.js dist/__tests__/cli-cmd-info.test.js dist/__tests__/cli-cmd-init.test.js dist/__tests__/cli-cmd-location.test.js dist/__tests__/cli-cmd-text.test.js dist/__tests__/cli-cmd-login.test.js dist/__tests__/cli-cmd-logout.test.js dist/__tests__/cli-cmd-token.test.js dist/__tests__/cli-cmd-logs.test.js dist/__tests__/cli-cmd-memory.test.js dist/__tests__/cli-cmd-page.test.js dist/__tests__/cli-cmd-plan.test.js dist/__tests__/cli-cmd-project.test.js dist/__tests__/cli-cmd-rbac.test.js dist/__tests__/cli-cmd-realtime.test.js dist/__tests__/cli-cmd-records.test.js dist/__tests__/cli-cmd-relay.test.js dist/__tests__/cli-cmd-setup.test.js dist/__tests__/cli-cmd-doctor.test.js dist/__tests__/claude-setup.test.js dist/__tests__/cli-cmd-sandbox.test.js dist/__tests__/cli-cmd-add.test.js dist/__tests__/cli-cmd-remove.test.js dist/__tests__/cli-cmd-skill.test.js dist/__tests__/cli-cmd-test.test.js dist/__tests__/cli-cmd-workflow.test.js dist/__tests__/setup-skills-block.test.js dist/__tests__/setup-hooks.test.js",
+    "test:smoke": "tsc && node --test dist/__tests__/utils.test.js dist/__tests__/platform.test.js dist/__tests__/colors.test.js dist/__tests__/config.test.js dist/__tests__/sync.test.js dist/__tests__/sync-apply.test.js dist/__tests__/sync-lock.test.js dist/__tests__/auth-lock.test.js dist/__tests__/api-401-retry.test.js dist/__tests__/push-cas.test.js dist/__tests__/upload.test.js dist/__tests__/progress.test.js dist/__tests__/updater.test.js dist/__tests__/cli-smoke.test.js dist/__tests__/claude-noninteractive.test.js dist/__tests__/claude-trust.test.js dist/__tests__/relay-state.test.js dist/__tests__/relay-daemon.test.js dist/__tests__/relay-diagnostics.test.js dist/__tests__/relay-installers.test.js dist/__tests__/relay-bridge-abort.test.js dist/__tests__/relay-redact.test.js dist/__tests__/relay-machine-id.test.js dist/__tests__/stream-json.test.js dist/__tests__/ingest-queue.test.js dist/__tests__/stream-delta.test.js dist/__tests__/phase-tracker.test.js dist/__tests__/relay-ingest-contract.test.js dist/__tests__/prompts.test.js dist/__tests__/capture-transcript.test.js dist/__tests__/capture-lock.test.js dist/__tests__/capture-resolve.test.js dist/__tests__/flag-aliases.test.js dist/__tests__/client-context.test.js dist/__tests__/adopt-cwd.test.js dist/__tests__/cli-cmd-agent.test.js dist/__tests__/cli-cmd-approval.test.js dist/__tests__/cli-cmd-audit.test.js dist/__tests__/cli-cmd-chat.test.js dist/__tests__/cli-cmd-credits.test.js dist/__tests__/cli-cmd-db.test.js dist/__tests__/cli-cmd-deploy.test.js dist/__tests__/cli-cmd-domain.test.js dist/__tests__/cli-cmd-email.test.js dist/__tests__/cli-cmd-file.test.js dist/__tests__/cli-cmd-storage.test.js dist/__tests__/cli-cmd-fn.test.js dist/__tests__/cli-cmd-service.test.js dist/__tests__/cli-cmd-job.test.js dist/__tests__/cli-cmd-generate.test.js dist/__tests__/cli-cmd-gmail.test.js dist/__tests__/cli-cmd-info.test.js dist/__tests__/cli-cmd-init.test.js dist/__tests__/cli-cmd-location.test.js dist/__tests__/cli-cmd-text.test.js dist/__tests__/cli-cmd-login.test.js dist/__tests__/cli-cmd-logout.test.js dist/__tests__/cli-cmd-token.test.js dist/__tests__/cli-cmd-logs.test.js dist/__tests__/cli-cmd-memory.test.js dist/__tests__/cli-cmd-page.test.js dist/__tests__/cli-cmd-plan.test.js dist/__tests__/cli-cmd-project.test.js dist/__tests__/cli-cmd-rbac.test.js dist/__tests__/cli-cmd-realtime.test.js dist/__tests__/cli-cmd-records.test.js dist/__tests__/cli-cmd-relay.test.js dist/__tests__/cli-cmd-setup.test.js dist/__tests__/cli-cmd-doctor.test.js dist/__tests__/claude-setup.test.js dist/__tests__/cli-cmd-sandbox.test.js dist/__tests__/cli-cmd-add.test.js dist/__tests__/cli-cmd-remove.test.js dist/__tests__/cli-cmd-skill.test.js dist/__tests__/cli-cmd-test.test.js dist/__tests__/cli-cmd-workflow.test.js dist/__tests__/setup-skills-block.test.js dist/__tests__/setup-hooks.test.js",
     "test:smoke:quick": "node scripts/smoke-quick.mjs",
     "test:e2e": "tsc && GIPITY_E2E=1 node --test --test-timeout=180000 dist/__tests__/cli-e2e-live.test.js dist/__tests__/cli-e2e-sync-live.test.js dist/__tests__/cli-e2e-sync-stress-live.test.js dist/__tests__/cli-e2e-rollback-live.test.js dist/__tests__/cli-e2e-services-media-live.test.js dist/__tests__/cli-e2e-workflow-live.test.js dist/__tests__/cli-e2e-sandbox-live.test.js dist/__tests__/cli-e2e-page-fetch-live.test.js dist/__tests__/cli-e2e-page-test-live.test.js",
     "test:e2e:sync": "tsc && GIPITY_E2E=1 node --test --test-timeout=180000 dist/__tests__/cli-e2e-sync-live.test.js",