gipity 1.0.428 → 1.1.1

package/dist/knowledge.js

@@ -54,7 +54,7 @@ Prefer the cheapest option that works - CLI and sandbox are instant and free, ap
 3. App services - runtime HTTP endpoints your deployed app calls directly at \`https://a.gipity.ai/api/<PROJECT_GUID>/services/*\`. Available: LLM, TTS, image, sound, music, transcribe, video, file upload, realtime, location, push notifications (Gipity Notify - \`gipity add notify\`, send from a function with the injected \`notify()\`; see \`app-notify\`). Load the matching skill (\`app-llm\`, \`app-tts\`, etc.) before writing service code - they have the schemas, auth pattern, and common-mistake guards. For one-off generation during development, prefer \`gipity generate <image|video|speech|sound|music>\` or \`gipity chat\` - direct generation always bills you (the owner), regardless of any service \`billing_mode\` (that setting only governs the deployed app's runtime calls; never flip it just to create assets). \`gipity generate\` saves to a generic file in the current directory by default (e.g. \`./generated.png\`) - pass \`-o <path>\` to write it straight into your source tree so it deploys (e.g. \`gipity generate image "hero banner" -o src/assets/images/hero.png\`) instead of generating at cwd and moving it.
 4. Delegate to Gip (\`gipity chat "<task>"\`) - only when the work genuinely needs agent reasoning or a tool not in the CLI, sandbox, or app services. Required for: Twitter/X search, Gmail, calendar, push notifications, video understanding, audio source isolation, cross-model second opinions, multi-step orchestration. Don't use \`gipity chat\` for anything the sandbox can do - it's slower and burns tokens.
 
-You are the developer. Write files in this directory - the Gipity Claude Code plugin's hooks auto-sync them to Gipity. Don't run \`npm install\`, \`npm start\`, \`node\`, or \`python\` locally; there is no local runtime. Code runs in the Gipity sandbox.
+You are the developer. Write files in this directory - Gipity's editor hooks (installed by \`gipity init\` into Claude Code, Grok, and Codex) auto-sync them to Gipity. Don't run \`npm install\`, \`npm start\`, \`node\`, or \`python\` locally; there is no local runtime. Code runs in the Gipity sandbox.
 
 ## Use first-party services before reaching outside
 
@@ -90,7 +90,7 @@ The full "when to add a template" rule and the definition of done are spelled ou
 
 Build loop: \`gipity add\` → edit files → \`gipity deploy dev --inspect\` → fix any errors → repeat until the definition of done is met. \`deploy --inspect\` deploys and then runs the page-inspect report on the live URL in one command; use a standalone \`gipity page inspect <url>\` only when re-checking without deploying.
 
-\`add\` writes real files to disk - Read a scaffolded file before your first Write/Edit to it, or the call fails \`"File has not been read yet"\`. Don't rewrite from memory of the template.
+\`add\` writes real files to disk - Read a scaffolded file with the Read tool before your first Write/Edit to it, or the call fails \`"File has not been read yet"\` (viewing it with \`cat\`/\`head\` in Bash does not count - the harness only tracks the Read tool). Don't rewrite from memory of the template.
 
 Make your file changes and verify they landed, then run \`gipity deploy dev\` once. \`0 uploaded, N unchanged\` means nothing changed on disk - fix the files, don't re-run deploy or probe the environment.
 
@@ -146,7 +146,7 @@ Every tool call returns its full output with that call. There is no output buffe
 
 This directory is the app root - it holds \`.gipity.json\` (and \`gipity.yaml\` for backends) and is already your cwd, so run app commands here. Don't \`cd\` to a git root (\`git rev-parse --show-toplevel\`): when the app is nested in a larger repo that resolves outside the app.
 
-Write files locally - the Gipity Claude Code plugin's hooks auto-push every save to Gipity and auto-pull remote changes (images, audio from \`gipity chat\`) before each turn. Use \`gipity sync\` if things get out of sync (or if the plugin isn't installed - \`gipity status --repair-hooks\` re-enables it). Deletes are safe - use \`rollback\` with a datetime to undo, or \`file_version_restore\` for individual files.
+Write files locally - Gipity's editor hooks (installed into Claude Code, Grok, and Codex by \`gipity init\`) auto-push every save to Gipity and auto-pull remote changes (images, audio from \`gipity chat\`) before each turn. Use \`gipity sync\` if things get out of sync (or if the hooks aren't installed - \`gipity status --repair-hooks\` re-enables them). Deletes are safe - use \`rollback\` with a datetime to undo, or \`file_version_restore\` for individual files.
 
 To keep local-only material (research clones, scratch data, vendored references) in the project directory without syncing or deploying it, list it in a \`.gipityignore\` at the project root - gitignore-style, one pattern per line, \`#\` comments. Ignored paths are invisible to sync in both directions; anything that already synced before being ignored stays on the server until you delete it.
 

package/dist/page-fixtures.js

@@ -8,12 +8,63 @@
 // Uses the same presigned init -> PUT -> complete flow the app file-upload
 // service exposes, with `public: true`. Cleanup goes through the matching
 // DELETE /api/:appGuid/uploads/:guid, which removes the public object too.
-import { readFileSync, statSync } from 'node:fs';
-import { basename } from 'node:path';
+import { readFileSync, statSync, existsSync, readdirSync } from 'node:fs';
+import { basename, resolve, relative, join } from 'node:path';
 import { post, del } from './api.js';
+import { getProjectRoot } from './config.js';
 import { guessMime } from './upload.js';
+/** Dirs a hand-made asset is never in, and that are expensive to walk. */
+const FIND_SKIP = new Set(['node_modules', '.git', '.gipity', 'dist', 'build', '.next', 'coverage']);
+/** Find files named `name` anywhere under `root` (breadth-first, bounded). */
+function findByBasename(root, name, limit = 3) {
+    const hits = [];
+    const queue = [root];
+    let visited = 0;
+    while (queue.length && hits.length < limit && visited < 500) {
+        const dir = queue.shift();
+        visited++;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (e.isDirectory()) {
+                if (!FIND_SKIP.has(e.name))
+                    queue.push(join(dir, e.name));
+            }
+            else if (e.name === name && hits.length < limit) {
+                hits.push(join(dir, e.name));
+            }
+        }
+    }
+    return hits;
+}
+/** Every `page` flag that takes a local file resolves it against the CURRENT
+ *  DIRECTORY, and a bare ENOENT from deep inside the upload path ("stat
+ *  './tmp/fist.jpg'") tells the caller nothing about where we looked or where
+ *  the file actually is. That costs an ls/find round-trip every time a file was
+ *  written somewhere other than where the caller assumed - which is exactly what
+ *  happens after a `cd` that failed, or a `gipity generate` run from a different
+ *  directory. So: name the absolute path we tried, the directory it was resolved
+ *  against, and - when a file with that basename exists elsewhere in the project
+ *  - the path that would have worked. Recovery becomes copy-paste, not a search. */
+export function assertLocalAsset(flag, localPath) {
+    const abs = resolve(localPath);
+    if (existsSync(abs))
+        return;
+    const root = getProjectRoot() ?? process.cwd();
+    const elsewhere = findByBasename(root, basename(localPath)).filter(p => p !== abs);
+    const found = elsewhere.length
+        ? `\nThat file DOES exist here — pass this path instead:\n${elsewhere.map(p => `  ${flag} ${relative(process.cwd(), p) || p}`).join('\n')}`
+        : `\nNothing named "${basename(localPath)}" under ${root} either. Generate a frame with \`gipity generate image "<description>" -o ${localPath}\`, or check the path.`;
+    throw new Error(`${flag} ${localPath}: no such file — looked for ${abs} (relative paths resolve against the current directory, ${process.cwd()}).${found}`);
+}
 /** Upload a local file to the app's public file store and return its URL. */
-export async function uploadPublicFixture(projectGuid, localPath) {
+export async function uploadPublicFixture(projectGuid, localPath, flag = '--fixture') {
+    assertLocalAsset(flag, localPath);
     const name = basename(localPath);
     const size = statSync(localPath).size;
     const contentType = guessMime(localPath);
@@ -38,4 +89,42 @@ export async function uploadPublicFixture(projectGuid, localPath) {
 export async function deleteFixture(projectGuid, guid) {
     await del(`/api/${projectGuid}/uploads/${guid}`);
 }
+// ── camera feed ─────────────────────────────────────────────────────────────
+// A headless browser has no webcam, so a vision app (MediaPipe, YOLOX, any
+// getUserMedia consumer) can't be exercised at all: getUserMedia rejects, the
+// app shows its no-camera state, and the code path the user actually cares
+// about never runs. `--fake-media` alone only fixes the rejection — Chrome's
+// built-in synthetic device is a rolling test pattern, so a gesture/pose/object
+// model still sees nothing recognizable and every agent ends up stubbing the
+// model's own output to test around it.
+//
+// --camera closes that: host a real image/video and let the browser play it as
+// the webcam's frames, so the app's REAL pipeline (frames → model → app logic)
+// runs headlessly on input you control. Hosting reuses the fixture path above;
+// the browser side (fetch the file, feed it to Chrome's fake capture device)
+// is the server's job — the CLI just names the file and hands over its URL.
+/** Container formats Chrome's fake video-capture device can be fed from, plus
+ *  the still-image types the server transcodes into a looping single-frame
+ *  feed. Anything else is rejected here (fast, local) rather than after an
+ *  upload + a browser launch. */
+const CAMERA_EXTS = ['.png', '.jpg', '.jpeg', '.webp', '.mp4', '.webm', '.y4m', '.mjpeg'];
+/** Validate a --camera path before uploading it. Throws with the accepted list
+ *  and the in-platform way to produce a frame, so a wrong file type costs one
+ *  local error instead of an upload plus an opaque browser failure. */
+export function assertCameraFile(localPath) {
+    assertLocalAsset('--camera', localPath);
+    const ext = localPath.slice(localPath.lastIndexOf('.')).toLowerCase();
+    if (CAMERA_EXTS.includes(ext))
+        return;
+    throw new Error(`--camera ${basename(localPath)}: unsupported file type "${ext || '(none)'}" — the camera feed must be an image or video (${CAMERA_EXTS.join(', ')}).\n` +
+        `A still image is played as a looping single-frame feed, which is what a gesture/pose/object model needs.\n` +
+        `No frame to hand? Generate one: gipity generate image "a hand making a closed fist, palm to camera, plain background"`);
+}
+/** Host a local image/video as the browser's webcam feed. Same public-upload
+ *  path as a fixture (so it is fetchable from the browser container and is
+ *  deleted the same way), validated first. */
+export async function uploadCameraFeed(projectGuid, localPath) {
+    assertCameraFile(localPath);
+    return uploadPublicFixture(projectGuid, localPath, '--camera');
+}
 //# sourceMappingURL=page-fixtures.js.map

package/dist/prefs.js

@@ -0,0 +1,50 @@
+/**
+ * Machine-level user preferences (~/.gipity/prefs.json) - the `gipity build`
+ * picker's memory. Deliberately NOT in a project's .gipity.json: per-project
+ * storage would re-ask the agent/model questions on every new project, which
+ * defeats "hit enter twice".
+ *
+ * Shape:
+ *   {
+ *     "lastAgent": "claude",
+ *     "lastModel": { "claude": "opus", "codex": null }   // per-agent so a
+ *   }                                                    // Codex session never
+ *                                                        // clobbers the Claude pick
+ *
+ * A `lastModel` of null/absent means "Agent default" - launch passes no
+ * model flag and the agent's own model memory stays authoritative.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const PREFS_PATH = join(homedir(), '.gipity', 'prefs.json');
+export function readPrefs() {
+    if (!existsSync(PREFS_PATH))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(PREFS_PATH, 'utf-8'));
+        return {
+            lastAgent: typeof parsed.lastAgent === 'string' ? parsed.lastAgent : undefined,
+            lastModel: parsed.lastModel && typeof parsed.lastModel === 'object' ? parsed.lastModel : undefined,
+        };
+    }
+    catch {
+        return {}; // unreadable prefs must never block a launch
+    }
+}
+export function writePrefs(update) {
+    try {
+        const current = readPrefs();
+        const next = {
+            ...current,
+            ...update,
+            lastModel: { ...current.lastModel, ...update.lastModel },
+        };
+        mkdirSync(join(homedir(), '.gipity'), { recursive: true });
+        writeFileSync(PREFS_PATH, JSON.stringify(next, null, 2) + '\n');
+    }
+    catch {
+        /* best-effort - prefs are a convenience */
+    }
+}
+//# sourceMappingURL=prefs.js.map

package/dist/project-setup.js

@@ -7,7 +7,7 @@
 import { clearConfigCache, saveConfigAt, getApiBaseOverride, DEFAULT_API_BASE } from './config.js';
 import { sync } from './sync.js';
 import { createProgressReporter } from './progress.js';
-import { setupClaudeHooks, setupGitignore, DEFAULT_TOOLS, DEFAULT_SYNC_IGNORE } from './setup.js';
+import { setupProjectTools, DEFAULT_TOOLS, DEFAULT_SYNC_IGNORE } from './setup.js';
 import { substituteDir } from './template-vars.js';
 import { muted } from './colors.js';
 /** Write `.gipity.json` in `dir`, chdir into it so the hook/skill writers
@@ -61,15 +61,7 @@ export async function finalizeLocalProject(opts) {
             throw err;
         // soft mode - swallow; caller can log
     }
-    const tools = opts.tools ?? DEFAULT_TOOLS;
-    // Claude hooks (file-sync + capture) only matter if the Claude primer is
-    // being written. Skipping them for Codex/Gemini/Cursor-only inits avoids
-    // littering `.claude/settings.json` into projects that don't use Claude.
-    if (tools.some(t => t.key === 'claude'))
-        setupClaudeHooks();
-    for (const t of tools)
-        t.setup();
-    setupGitignore();
+    setupProjectTools(opts.tools ?? DEFAULT_TOOLS);
     return { applied };
 }
 //# sourceMappingURL=project-setup.js.map

package/dist/provider-docs.js

@@ -42,17 +42,17 @@ export const GEMINI_TTS_VOICES_DOC = `Zephyr, Puck, Charon, Kore, Fenrir, Leda,
 export const GEMINI_TTS_VOICES_SHORT = `Kore, Puck, Zephyr, Charon, Fenrir, Leda, Orus, Aoede, and 22 more`;
 export const IMAGE_GEMINI_ASPECT_RATIOS = `1:1, 16:9, 9:16, 4:3, 3:4, 3:2, 2:3, 4:5, 5:4, 21:9`;
 export const IMAGE_GEMINI_SIZES = `512, 1K, 2K, 4K`;
-export const IMAGE_MODELS_DOC = `openai: gpt-image-2, gpt-image-1.5. bfl: flux-2-pro, flux-2-flex, flux-2-max, flux-dev. gemini: gemini-2.5-flash-image, gemini-3.1-flash-image, gemini-3-pro-image`;
-export const IMAGE_PROVIDERS_BULLET = `- **OpenAI**: \`gpt-image-2, gpt-image-1.5\`
-- **BFL/Flux**: \`flux-2-pro, flux-2-flex, flux-2-max, flux-dev\`
-- **Gemini/Nano Banana**: \`gemini-2.5-flash-image, gemini-3.1-flash-image, gemini-3-pro-image\``;
+export const IMAGE_MODELS_DOC = `openai: gpt-image-2. bfl: flux-2-pro, flux-2-flex, flux-2-max, flux-2-klein-9b, flux-2-klein-4b. gemini: gemini-3.1-flash-lite-image, gemini-2.5-flash-image, gemini-3.1-flash-image, gemini-3-pro-image`;
+export const IMAGE_PROVIDERS_BULLET = `- **OpenAI**: \`gpt-image-2\`
+- **BFL/Flux**: \`flux-2-pro, flux-2-flex, flux-2-max, flux-2-klein-9b, flux-2-klein-4b\`
+- **Gemini/Nano Banana**: \`gemini-3.1-flash-lite-image, gemini-2.5-flash-image, gemini-3.1-flash-image, gemini-3-pro-image\``;
 export const IMAGE_PROVIDERS_LIST = `openai, bfl, gemini`;
 export const IMAGE_PROVIDER_DESCRIPTIONS = {
-    'openai': `OpenAI (gpt-image-2, gpt-image-1.5)`,
-    'bfl': `BFL/Flux (flux-2-pro, flux-2-flex, flux-2-max, flux-dev)`,
-    'gemini': `Gemini/Nano Banana (gemini-2.5-flash-image, gemini-3.1-flash-image, gemini-3-pro-image)`,
+    'openai': `OpenAI (gpt-image-2)`,
+    'bfl': `BFL/Flux (flux-2-pro, flux-2-flex, flux-2-max, flux-2-klein-9b, flux-2-klein-4b)`,
+    'gemini': `Gemini/Nano Banana (gemini-3.1-flash-lite-image, gemini-2.5-flash-image, gemini-3.1-flash-image, gemini-3-pro-image)`,
 };
-export const LLM_DEFAULT_MODELS_DOC = `OpenAI: gpt-4.1-nano (cheapest), gpt-5.4-mini (cheap reasoning). Anthropic: claude-haiku-4-5 (cheapest). Gemini: gemini-2.5-flash-lite (cheapest, 1M context)`;
+export const LLM_DEFAULT_MODELS_DOC = `OpenAI: gpt-5.4-nano (cheapest), gpt-5.4-mini (cheap reasoning). Anthropic: claude-haiku-4-5 (cheapest). Gemini: gemini-2.5-flash-lite (cheapest, 1M context)`;
 export const LLM_PROVIDERS_LIST = `anthropic, openai, gemini`;
 export const OPENAI_TTS_VOICES_DOC = `alloy, ash, ballad, coral, echo, fable, nova, onyx, sage, shimmer, verse`;
 export const TRANSCRIBE_PROVIDERS_DOC = `elevenlabs (default, Scribe v2), openai (GPT-4o Transcribe), gemini (Gemini 2.5 Flash - cheapest, multilingual)`;
@@ -63,7 +63,7 @@ export const TTS_PROVIDER_DESCRIPTIONS = {
     'gemini': `Gemini (30 voices: Kore, Puck, Zephyr, Charon, Fenrir, Leda, Orus, Aoede, and 22 more). Multi-speaker (up to 2) and 60+ languages`,
 };
 export const VIDEO_ASPECT_RATIOS = `16:9 (landscape), 9:16 (portrait), 1:1 (square)`;
-export const VIDEO_MODELS_DOC = `veo-3.1-generate-preview (best quality, ~$0.40/sec), veo-3.1-fast-generate-preview (faster, ~$0.15/sec), veo-3.1-lite-generate-preview (budget, ~$0.07/sec)`;
-export const VIDEO_MODELS_LIST = `veo-3.1-generate-preview, veo-3.1-fast-generate-preview, veo-3.1-lite-generate-preview`;
+export const VIDEO_MODELS_DOC = `veo-3.1-generate-preview (best quality, up to 4K, ~$0.40/sec), veo-3.1-fast-generate-preview (faster, ~$0.10/sec), veo-3.1-lite-generate-preview (budget, ~$0.05/sec), gemini-omni-flash-preview (3-10s @ 720p, conversational editing, ~$0.10/sec)`;
+export const VIDEO_MODELS_LIST = `veo-3.1-generate-preview, veo-3.1-fast-generate-preview, veo-3.1-lite-generate-preview, gemini-omni-flash-preview`;
 export const VIDEO_RESOLUTIONS = `720p, 1080p, 4k`;
 //# sourceMappingURL=provider-docs.js.map

package/dist/relay/daemon.js

@@ -6,12 +6,13 @@ import { homedir, hostname, platform as osPlatform, loadavg, freemem, totalmem,
 import { join } from 'path';
 import { getApiBaseOverride, DEFAULT_API_BASE } from '../config.js';
 import { getProjectsRoot } from './paths.js';
-import { setupClaudeHooks, setupClaudeMd, setupAgentsMd, setupGitignore, DEFAULT_SYNC_IGNORE } from '../setup.js';
+import { setupProjectTools, DEFAULT_SYNC_IGNORE } from '../setup.js';
 import { getAuth, readAuthFresh, refreshTokenIfNeeded, accessTokenExpired } from '../auth.js';
 import { post } from '../api.js';
 import * as state from './state.js';
 import { createLineSplitter, parseEvent, mapEventToEntries, } from './stream-json.js';
 import { IngestQueue } from './ingest-queue.js';
+import { ImageBlockRewriter } from './media-upload.js';
 import { DeltaAccumulator, DeltaBatcher } from './stream-delta.js';
 import { randomUUID } from 'crypto';
 import { deviceFetch, bridgeAbort as bridgeAbortImpl } from './device-http.js';
@@ -23,7 +24,8 @@ import { SessionPool, PoolFullError } from './session-pool.js';
 import { getConfig } from '../config.js';
 import { getAccountSlug } from '../api.js';
 import { buildFreshWrap, buildResumeWrap, buildProjectContextBlock } from '../prompts.js';
-import { fetchProjectStats } from '../commands/claude.js';
+import { fetchProjectStats } from '../commands/build.js';
+import { getAdapterBySource } from '../agents/index.js';
 // Re-exported so the existing `relay-bridge-abort.test.ts` keeps working.
 // New callers should import from device-http.js directly.
 export const bridgeAbort = bridgeAbortImpl;
@@ -875,7 +877,13 @@ async function handleDispatch(claimed) {
     // retry instead of the old fire-and-forget loss on network errors.
     // Daemon-authored entries get a random source_uuid so retried batches
     // dedup server-side.
-    const queue = new IngestQueue((entries) => postIngest(d.conversation_guid, entries), { onWarn: (msg, meta) => log('warn', msg, { id: d.short_guid, ...meta }) });
+    // The rewriter uploads any base64 image blocks (Read-of-screenshot
+    // results) to VFS and swaps in image_ref blocks before the batch posts —
+    // transcripts carry URLs, never image bytes. Retries re-enter it, which
+    // is safe: rewritten entries have nothing left to upload, and the server
+    // stores by content hash so a replayed upload dedups.
+    const rewriter = new ImageBlockRewriter(d.conversation_guid, (msg, meta) => log('warn', msg, { id: d.short_guid, ...meta }));
+    const queue = new IngestQueue(async (entries) => postIngest(d.conversation_guid, await rewriter.rewrite(entries)), { onWarn: (msg, meta) => log('warn', msg, { id: d.short_guid, ...meta }) });
     const pushSystem = (content) => {
         queue.push({ kind: 'system', content, ts: new Date().toISOString(), source_uuid: randomUUID() });
     };
@@ -886,6 +894,9 @@ async function handleDispatch(claimed) {
     let bootstrapped;
     try {
         ({ cwd, bootstrapped } = await resolveCwdForProject(d));
+        // Lets the rewriter map an absolute Read path (…/screenshots/x.png)
+        // to its project-relative VFS path for content-hash dedup.
+        rewriter.setCwd(cwd);
         log('debug', 'resolved project cwd', { id: d.short_guid, project: d.project_slug, cwd, bootstrapped });
     }
     catch (err) {
@@ -939,6 +950,15 @@ async function handleDispatch(claimed) {
         if (!syncFailed)
             pushSystem(bootstrapped ? 'Project files synced.' : 'Attached files synced.');
     }
+    // Which agent runs this dispatch. Older servers omit remote_type - they
+    // only ever dispatched Claude Code.
+    const adapter = getAdapterBySource(d.remote_type ?? 'claude_code');
+    // Non-Claude agents take the simpler hook-capture dispatch path: no
+    // stream-json ingest, no session pool.
+    if (adapter.key !== 'claude') {
+        await handleNonClaudeDispatch(adapter, d, cwd, queue, pushSystem, flushQueue);
+        return;
+    }
     // Phase 2: if the session pool is enabled, try to run this turn in a
     // long-lived Claude Code session (fast follow-up + clean interrupt). Any
     // failure - pool saturated, SDK error, wrap failure - falls through to the
@@ -948,8 +968,11 @@ async function handleDispatch(claimed) {
         if (handled)
             return;
     }
-    // Build argv for `gipity claude -p …` (or with --resume). No shell - argv
-    // as array so the message string can't be interpreted as shell syntax.
+    // Build argv for `gipity build --agent claude -p …` (or with --resume).
+    // No shell - argv as array so the message string can't be interpreted as
+    // shell syntax. (`build` is the renamed launcher; the flags below pass
+    // through it to the `claude` binary unchanged, exactly as the legacy
+    // `gipity claude -p` spawn did.)
     //
     // `--permission-mode bypassPermissions`: a relay dispatch has no
     // human on the other end to click "Approve" - Claude prompting would
@@ -957,7 +980,7 @@ async function handleDispatch(claimed) {
     // the device and dispatching the message; skipping the interactive
     // prompt is correct (same authority as running `claude -p` in a local
     // terminal yourself).
-    const args = ['claude', '-p', d.message, '--permission-mode', 'bypassPermissions'];
+    const args = ['build', '--agent', 'claude', '-p', d.message, '--permission-mode', 'bypassPermissions'];
     // Relay sessions run in -p mode, where Claude Code's AskUserQuestion tool
     // is unavailable - so without help the model would ask clarifying
     // questions as prose the user just types back. This system-prompt
@@ -974,7 +997,7 @@ async function handleDispatch(claimed) {
     if (d.kind === 'resume' && d.remote_session_id) {
         args.push('--resume', d.remote_session_id);
     }
-    log('debug', 'spawning gipity claude', {
+    log('debug', 'spawning gipity build --agent claude', {
         id: d.short_guid,
         cwd,
         args,
@@ -1113,7 +1136,92 @@ async function handleDispatch(claimed) {
     }
     else {
         log('warn', 'dispatch child exited nonzero', { id: d.short_guid, exitCode, ms });
-        await ack(d.short_guid, 'error', `gipity claude exited with code ${exitCode}${stderrNote}`);
+        await ack(d.short_guid, 'error', `Claude Code exited with code ${exitCode}${stderrNote}`);
+    }
+}
+/**
+ * Dispatch for non-Claude agents (Codex, Grok). Deliberately simpler than
+ * the Claude path: there is no stream-json ingest mapper for these agents -
+ * hook-based session capture (Phase C) owns the transcript. The spawned
+ * `gipity build --agent <key> -p …` child gets GIPITY_CONVERSATION_GUID (so
+ * capture posts into the right conversation) and capture is NOT turned off.
+ * The daemon contributes: the "Running <agent>" marker, byte-level progress
+ * heartbeats (spawnGipityClaude's generic plumbing with streamJson:false),
+ * post-run file sync, the tail marker, and the ack. The prompt entry itself
+ * arrives via capture from the agent's own transcript - the daemon doesn't
+ * push one, or it would render twice.
+ */
+async function handleNonClaudeDispatch(adapter, d, cwd, queue, pushSystem, flushQueue) {
+    // `gipity build` translates these into the agent's own argv via the same
+    // adapter (Codex: `exec …`; Grok: `-p … --always-approve`). Raw message -
+    // AGENTS.md carries the Gipity context for these agents; no wrapping.
+    const args = ['build', '--agent', adapter.key, '-p', d.message, '--bypass-approvals'];
+    if (d.model)
+        args.push('--model', d.model);
+    if (d.kind === 'resume' && d.remote_session_id)
+        args.push('--resume', d.remote_session_id);
+    log('debug', `spawning gipity build --agent ${adapter.key}`, {
+        id: d.short_guid, cwd, args, conv: d.conversation_guid,
+        chain: d.kind === 'resume' ? `resume ${d.remote_session_id}` : 'start (fresh session)',
+    });
+    const words = d.message.trim().split(/\s+/).filter(Boolean).length;
+    pushSystem(`Running ${adapter.displayName} - ${words.toLocaleString('en-US')} words`);
+    const t0 = Date.now();
+    let exitCode = 1;
+    let spawnErr = null;
+    let killed = false;
+    let runtimeLimit = false;
+    let stderrTail = '';
+    try {
+        const result = await spawnGipityClaude(args, cwd, d, queue, { streamJson: false });
+        exitCode = result.exitCode;
+        killed = result.killed;
+        runtimeLimit = result.runtimeLimit ?? false;
+        stderrTail = result.stderrTail ?? '';
+    }
+    catch (err) {
+        spawnErr = err?.message || String(err);
+        log('error', 'dispatch spawn failed', { id: d.short_guid, err: spawnErr });
+    }
+    const dur = formatDuration(Date.now() - t0);
+    // Same post-run reconcile as the Claude path: push files the agent wrote
+    // via Bash/scripts back to VFS before the ack (hooks only cover its
+    // native edit tools). Skipped on kill - the replacement dispatch owns the tree.
+    if (!spawnErr && !killed) {
+        try {
+            await spawnSync(cwd, PROJECT_SYNC_TIMEOUT_MS);
+        }
+        catch (err) {
+            log('warn', 'sync after dispatch failed', { id: d.short_guid, err: err?.message });
+        }
+    }
+    const stderrNote = stderrTail ? `: ${stderrTail.slice(0, 300)}` : '';
+    const tail = runtimeLimit
+        ? `stopped after ${dur} (runtime limit)`
+        : killed
+            ? `cancelled (${dur})`
+            : spawnErr
+                ? `failed (${dur}: ${spawnErr})`
+                : exitCode === 0
+                    ? `finished (${dur})`
+                    : `failed (${dur}, exit ${exitCode}${stderrNote})`;
+    pushSystem(`${adapter.displayName} ${tail}`);
+    await flushQueue();
+    if (runtimeLimit) {
+        await ack(d.short_guid, 'error', `${adapter.displayName} stopped after ${dur} (runtime limit)`);
+    }
+    else if (killed) {
+        await ack(d.short_guid, 'cancelled');
+    }
+    else if (spawnErr) {
+        await ack(d.short_guid, 'error', spawnErr);
+    }
+    else if (exitCode === 0) {
+        log('info', 'dispatch done', { id: d.short_guid, agent: adapter.key });
+        await ack(d.short_guid, 'done');
+    }
+    else {
+        await ack(d.short_guid, 'error', `${adapter.displayName} exited with code ${exitCode}${stderrNote}`);
     }
 }
 /**
@@ -1362,10 +1470,7 @@ async function resolveCwdForProject(d) {
     const origCwd = process.cwd();
     try {
         process.chdir(path);
-        setupClaudeHooks();
-        setupClaudeMd();
-        setupAgentsMd();
-        setupGitignore();
+        setupProjectTools();
     }
     finally {
         process.chdir(origCwd);
@@ -1552,6 +1657,11 @@ async function spawnSync(cwd, timeoutMs, onSpawn) {
     });
 }
 export async function spawnGipityClaude(args, cwd, d, queue, meta) {
+    // streamJson (default true) = the Claude path: parse the child's
+    // stream-json stdout into ingest entries and stand hook capture down.
+    // false = non-Claude agents (Codex/Grok): hook capture owns the
+    // transcript; stdout only feeds the byte-level progress heartbeat.
+    const streamJson = meta?.streamJson !== false;
     // resolveCommand: on Windows the bare `gipity` is a .cmd shim that spawn
     // can't launch without an explicit path. An explicit env override is used
     // verbatim (it may be a full path); only the default name is resolved.
@@ -1562,13 +1672,19 @@ export async function spawnGipityClaude(args, cwd, d, queue, meta) {
     // `--include-partial-messages` adds stream_event token deltas, which
     // 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 fullArgs = streamJson
+        ? [...args, '--output-format', 'stream-json', '--verbose', '--include-partial-messages']
+        : [...args];
     // 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' });
+    // dispatches double-post-free even across CLI version skew. Non-Claude
+    // agents are the opposite: hook capture IS the transcript path, so the
+    // sentinel must NOT be set.
+    const env = streamJson
+        ? childEnv({ GIPITY_CONVERSATION_GUID: d.conversation_guid, GIPITY_CAPTURE: 'off' })
+        : childEnv({ GIPITY_CONVERSATION_GUID: d.conversation_guid });
     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
@@ -1583,7 +1699,11 @@ export async function spawnGipityClaude(args, cwd, d, queue, meta) {
         // no longer drops stream content permanently (source_uuid dedup makes
         // the retries safe). Falls back to a local queue when the caller
         // didn't pass one (tests, direct invocation).
-        const q = queue ?? new IngestQueue((entries) => postIngest(d.conversation_guid, entries), { onWarn: (msg, meta) => log('warn', msg, { id: d.short_guid, ...meta }) });
+        const q = queue ?? (() => {
+            const rw = new ImageBlockRewriter(d.conversation_guid, (msg, meta) => log('warn', msg, { id: d.short_guid, ...meta }));
+            rw.setCwd(cwd);
+            return new IngestQueue(async (entries) => postIngest(d.conversation_guid, await rw.rewrite(entries)), { onWarn: (msg, meta) => log('warn', msg, { id: d.short_guid, ...meta }) });
+        })();
         const ownQueue = !queue;
         // Progress heartbeat state. Measured at the daemon boundary - this is
         // what we actually observe, not anything the child self-reports. These
@@ -1766,9 +1886,11 @@ export async function spawnGipityClaude(args, cwd, d, queue, meta) {
         child.stdout?.on('data', (chunk) => {
             stdoutBytesTotal += chunk.length;
             lastStdoutByteAt = Date.now();
-            splitter.push(chunk);
+            if (streamJson)
+                splitter.push(chunk);
         });
-        child.stdout?.on('end', () => splitter.flush());
+        child.stdout?.on('end', () => { if (streamJson)
+            splitter.flush(); });
         // Stderr: human-readable only (Claude's progress bars, errors).
         // Kept on the daemon's own stderr for `gipity relay log`, plus a
         // small tail ring so a crash with no stream output can include the

package/dist/relay/device-http.js

@@ -31,6 +31,28 @@ export function bridgeAbort(outer, inner) {
     outer.addEventListener('abort', onAbort, { once: true });
     return () => outer.removeEventListener('abort', onAbort);
 }
+/** Device-auth binary POST — raw bytes body (no JSON/base64 wrapping).
+ *  Used by the transcript-media upload, where the whole point is that the
+ *  image travels as bytes instead of base64. */
+export async function deviceFetchBinary(method, path, body, contentType, timeoutMs) {
+    const controller = timeoutMs ? new AbortController() : null;
+    const timer = controller ? setTimeout(() => controller.abort('timeout'), timeoutMs) : null;
+    try {
+        return await fetch(`${apiBase()}${path}`, {
+            method,
+            headers: {
+                'Authorization': `Bearer ${deviceToken()}`,
+                'Content-Type': contentType,
+            },
+            body: new Uint8Array(body),
+            signal: controller?.signal,
+        });
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 /** Device-auth HTTP helper. Sends `Authorization: Bearer <device-token>`
  *  + `Content-Type: application/json` to the configured API base. */
 export async function deviceFetch(method, path, body, timeoutMs, signal) {

package/dist/relay/diagnostics.js

@@ -137,14 +137,16 @@ 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, cursor, gpu] = await Promise.all([
-        probeVersion('claude'), probeVersion('codex'), probeVersion('cursor'), detectGpu(),
+    const [claude, codex, grok, cursor, gpu] = await Promise.all([
+        probeVersion('claude'), probeVersion('codex'), probeVersion('grok'), probeVersion('cursor'), detectGpu(),
     ]);
     const agents = {};
     if (claude)
         agents.claude_code = claude;
     if (codex)
         agents.codex = codex;
+    if (grok)
+        agents.grok = grok;
     if (cursor)
         agents.cursor = cursor;
     return {