mixdog 0.9.166 → 0.9.167

package/src/runtime/computer-bridge/error-recovery.mjs

@@ -14,52 +14,61 @@ function targetLabel(args) {
   return 'the exact target window';
 }
 
+const LIST_WINDOW_CODES = new Set([
+  'ambiguous_window_target', 'window_stale', 'window_target_not_found',
+]);
+const STALE_TARGET_CODES = new Set(['stale_frame', 'stale_target', 'target_mismatch']);
+const USER_YIELD_CODES = new Set([
+  'computer_user_control_active', 'computer_user_takeover', 'user_input_active',
+]);
+const DIAGNOSE_CODES = new Set([
+  'input_observation_unavailable', 'input_recovery_unconfirmed', 'computer_cursor_unavailable',
+]);
+const CLEANUP_CODES = new Set([
+  'computer_cleanup_pending', 'computer_abort_cleanup_unconfirmed',
+  'input_cleanup_unconfirmed', 'privileged_worker_cleanup_unconfirmed',
+]);
+const PIXEL_CODES = new Set(['pixel_unavailable', 'observation_unavailable']);
+
+function recaptureLeaseGuidance(code, target) {
+  if (code === 'computer_target_in_use') {
+    return `Another session owns ${target}. Do not retry the stale action; wait for its lease to release, then capture fresh state.`;
+  }
+  if (code === 'computer_foreground_available_recapture_required') {
+    return `The foreground lane is now available. Capture ${target} again before issuing any input.`;
+  }
+  return `The target lease is now available. Capture ${target} again before issuing any input.`;
+}
+
 function recoveryForCode(code, args) {
   const target = targetLabel(args);
-  if (code === 'ambiguous_window_target' || code === 'window_stale'
-    || code === 'window_target_not_found') {
-    return {
-      code,
-      next: 'list',
-      guidance: 'List windows and retry with one current exact window_id.',
-    };
+  if (LIST_WINDOW_CODES.has(code)) {
+    return { code, next: 'list', guidance: 'List windows and retry with one current exact window_id.' };
   }
-  if (code === 'stale_frame' || code === 'stale_target' || code === 'target_mismatch') {
+  if (STALE_TARGET_CODES.has(code)) {
     return {
-      code,
-      next: 'capture',
+      code, next: 'capture',
       guidance: `Capture ${target} again and use only the fresh ref, OCR mark, or frame_id.`,
     };
   }
   if (code === 'computer_target_available_recapture_required'
     || code === 'computer_foreground_available_recapture_required'
     || code === 'computer_target_in_use') {
-    return {
-      code,
-      next: 'capture',
-      guidance: code === 'computer_target_in_use'
-        ? `Another session owns ${target}. Do not retry the stale action; wait for its lease to release, then capture fresh state.`
-        : code === 'computer_foreground_available_recapture_required'
-          ? `The foreground lane is now available. Capture ${target} again before issuing any input.`
-          : `The target lease is now available. Capture ${target} again before issuing any input.`,
-    };
+    return { code, next: 'capture', guidance: recaptureLeaseGuidance(code, target) };
   }
-  if (code === 'computer_user_control_active' || code === 'computer_user_takeover' || code === 'user_input_active') {
+  if (USER_YIELD_CODES.has(code)) {
     return {
-      code,
-      next: 'wait_for_user',
+      code, next: 'wait_for_user',
       guidance: 'Computer Use yielded to the user. Call wait_for_user for bounded waiting. Ordinary physical input may resume after the host-configured quiet interval (default 5 seconds); explicit stops and uncertain cleanup/observation require the user. Timeout does not authorize input. After resumed, capture fresh state; never replay interrupted input. Manual Resume is also available on the overlay.',
     };
   }
-  if (code === 'input_observation_unavailable' || code === 'input_recovery_unconfirmed'
-    || code === 'computer_cursor_unavailable') {
+  if (DIAGNOSE_CODES.has(code)) {
     return {
       code, next: 'diagnose',
       guidance: 'Input or recovery could not be verified. Do not repeat the mutation. Diagnose the exact target and inspect fresh state only when user control is not active.',
     };
   }
-  if (code === 'computer_cleanup_pending' || code === 'computer_abort_cleanup_unconfirmed'
-    || code === 'input_cleanup_unconfirmed' || code === 'privileged_worker_cleanup_unconfirmed') {
+  if (CLEANUP_CODES.has(code)) {
     return {
       code, next: 'user',
       guidance: 'Worker exit and input release are not confirmed. Do not resume or reset the guard; wait for cleanup. Failed cleanup requires an explicitly approved host restart.',
@@ -67,36 +76,31 @@ function recoveryForCode(code, args) {
   }
   if (code.startsWith('menu_') || code === 'computer_command_timeout') {
     return {
-      code,
-      next: 'capture',
+      code, next: 'capture',
       guidance: `Capture ${target} again; empty accessibility automatically uses OCR. Use a fresh OCR mark or frame point and do not retry the same menu path unchanged.`,
     };
   }
   if (code === 'foreground_changed') {
     return {
-      code,
-      next: 'user',
+      code, next: 'user',
       guidance: 'Focus changed during dispatch. Do not pull it back or retry input automatically. Check user control, then obtain fresh state when control is available.',
     };
   }
   if (code === 'foreground_unavailable') {
     return {
-      code,
-      next: 'user',
+      code, next: 'user',
       guidance: `Windows did not grant foreground focus. Ask the user to activate ${target}, then capture fresh state. Do not substitute background input or repeat the failed gesture.`,
     };
   }
   if (code.startsWith('background_')) {
     return {
-      code,
-      next: 'capture',
+      code, next: 'capture',
       guidance: `Capture ${target} and inspect whether any input was delivered. Consider foreground only if no input was sent and visible control is within the user's scope; never silently change delivery or replay uncertain input.`,
     };
   }
-  if (code === 'pixel_unavailable' || code === 'observation_unavailable') {
+  if (PIXEL_CODES.has(code)) {
     return {
-      code,
-      next: 'capture',
+      code, next: 'capture',
       guidance: `Recapture ${target}; do not use coordinates until a fresh frame reports pixel_status="available".`,
     };
   }

package/src/runtime/computer-bridge/tool-defs.mjs

@@ -8,7 +8,7 @@ import {
 // recovery, and flows live in the built-in `computer-use` skill; the schema
 // below owns every field.
 const COMPUTER_TOOL_DESCRIPTION = [
-  'Operate the local Windows desktop through Mixdog (Windows only). Last resort after an MCP tool, shell/CLI, and Browser Use (browser): only native apps and GUI-only tools; never a stand-in for a page action browser refused.',
+  'Operate local Windows desktop apps, external browser windows, and OS dialogs through Mixdog. Last resort after an MCP tool, shell/CLI, and Browser Use where applicable; never a stand-in for a page action browser refused.',
   'Load the computer-use skill before first use.',
   'At most one computer call per model turn; chain same-window steps inside one act.',
   'Every window action names one exact target (window_id, or app resolving to one window); input requires a fresh observation from capture or the previous result.',

package/src/runtime/github/commands.mjs

@@ -78,7 +78,10 @@ export function buildGithubCommand(value) {
       return api(`${root}/actions/workflows/${encodeURIComponent(text('workflow'))}/dispatches`, 'POST', {
         ref: text('ref'), inputs: input.inputs || {},
       });
-    case 'run.list': return api(`${root}/actions/runs?${query}`);
+    case 'run.list':
+      return api(input.workflow
+        ? `${root}/actions/workflows/${encodeURIComponent(text('workflow'))}/runs?${query}`
+        : `${root}/actions/runs?${query}`);
     case 'run.view': return api(`${root}/actions/runs/${id()}`);
     case 'run.logs':
       return cli(['run', 'view', String(id()), '--repo', repo, input.failed ? '--log-failed' : '--log']);

package/src/runtime/github/contract.mjs

@@ -23,7 +23,7 @@ export const GITHUB_ACTIONS = Object.freeze({
   'pr.comments': { fields: ['number', 'page', 'limit'], list: true },
   'workflow.list': { fields: ['page', 'limit'], list: true, collection: 'workflows' },
   'workflow.run': { fields: ['workflow', 'ref', 'inputs'], write: true },
-  'run.list': { fields: ['page', 'limit'], list: true, collection: 'workflow_runs' },
+  'run.list': { fields: ['workflow', 'page', 'limit'], list: true, collection: 'workflow_runs' },
   'run.view': { fields: ['id'] },
   'run.logs': { fields: ['id', 'failed'] },
   'run.rerun': { fields: ['id', 'failed'], write: true },

package/src/runtime/github/tool.mjs

@@ -17,7 +17,7 @@ export const GITHUB_TOOL_DEF = {
       page: { type: 'integer', minimum: 1 },
       limit: { type: 'integer', minimum: 1, maximum: 100 },
       owner: { type: 'string', description: 'repo.list owner; omit for authenticated repositories.' },
-      state: { type: 'string', enum: ['open', 'closed', 'all'] },
+      state: { type: 'string', enum: ['open', 'closed', 'all'], description: 'issue.list/pr.list only.' },
       title: { type: 'string' },
       body: { type: 'string' },
       description: { type: 'string' },
@@ -31,7 +31,7 @@ export const GITHUB_TOOL_DEF = {
       sha: { type: 'string', description: 'Full PR head commit hash; review/merge only.' },
       method: { type: 'string', enum: ['merge', 'squash', 'rebase'] },
       event: { type: 'string', enum: ['COMMENT', 'APPROVE', 'REQUEST_CHANGES'] },
-      workflow: { type: 'string', description: 'Workflow file name or numeric id as text.' },
+      workflow: { type: 'string', description: 'workflow.run target or run.list filter: workflow file name or numeric id as text.' },
       ref: { type: 'string', description: 'Explicit branch/tag to dispatch workflow on.' },
       inputs: { type: 'object', additionalProperties: { type: 'string' }, description: 'workflow.run named string inputs.' },
       failed: { type: 'boolean', description: 'run.logs/rerun: failed jobs only.' },

package/src/runtime/media/adapters/antigravity-image.mjs

@@ -0,0 +1,72 @@
+/**
+ * Antigravity image adapter (`antigravity-oauth` lane).
+ *
+ * Nano Banana models behind the Cloud Code Assist gateway take the same
+ * Gemini `generateContent` payload as the API-key lane, wrapped in the gateway
+ * envelope the chat provider sends. Only the streaming route returns image
+ * parts: the unary route answers 200 with an empty candidate list. The image
+ * arrives as one inline part; the whole SSE body is read before decoding.
+ */
+import { randomUUID } from 'node:crypto';
+import { resolveAntigravityAuth } from '../auth.mjs';
+import { upstreamError } from '../upstream-error.mjs';
+import { geminiImageRequestBody, pickGeminiImagePart } from './gemini-image.mjs';
+import { CONTENT_ENDPOINTS, antigravityHeaders } from '../../agent/orchestrator/providers/antigravity-oauth-tokens.mjs';
+import { frameAndParseSse } from '../../agent/orchestrator/providers/lib/sse-framing.mjs';
+
+const REQUEST_TIMEOUT_MS = 180_000;
+
+export function antigravityImageRequestBody({ projectId, model, prompt, options = {}, references = [] }) {
+  return {
+    project: projectId,
+    model,
+    userAgent: 'antigravity',
+    requestType: 'agent',
+    requestId: `agent-${randomUUID()}`,
+    request: {
+      ...geminiImageRequestBody(prompt, options, references),
+      sessionId: `-${randomUUID()}`,
+    },
+  };
+}
+
+/** Candidate parts across the stream; the gateway nests each chunk under `response`. */
+export function antigravityImageParts(sseText) {
+  const parts = [];
+  let failure = null;
+  for (const event of frameAndParseSse(sseText).events) {
+    if (event.error) continue;
+    const value = event.value;
+    // In-band error events stay top level; content chunks are nested.
+    if (value?.error) failure = value.error.message || JSON.stringify(value.error);
+    const chunk = value?.response && typeof value.response === 'object' ? value.response : value;
+    const candidate = chunk?.candidates?.[0];
+    parts.push(...(candidate?.content?.parts || []));
+    const blocked = chunk?.promptFeedback?.blockReason;
+    if (blocked && !failure) failure = `prompt blocked (${blocked})`;
+  }
+  return { parts, failure };
+}
+
+export async function generateImage({ model, prompt, options = {}, references = [], signal }, {
+  fetchFn = fetch, resolveAuth = resolveAntigravityAuth, endpoint = CONTENT_ENDPOINTS[0],
+} = {}) {
+  const auth = await resolveAuth();
+  const body = antigravityImageRequestBody({ projectId: auth.projectId, model, prompt, options, references });
+  const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+  const res = await fetchFn(`${endpoint}/v1internal:streamGenerateContent?alt=sse`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${auth.token}`,
+      'Content-Type': 'application/json',
+      Accept: 'text/event-stream',
+      ...antigravityHeaders(),
+    },
+    body: JSON.stringify(body),
+    redirect: 'error',
+    signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+  });
+  if (!res.ok) throw upstreamError('Antigravity image', res.status, await res.text().catch(() => ''));
+  const { parts, failure } = antigravityImageParts(await res.text());
+  return pickGeminiImagePart(parts, 'Antigravity', failure);
+}

package/src/runtime/media/adapters/gemini-image.mjs

@@ -44,26 +44,35 @@ async function post(model, key, body, signal, fetchFn) {
   });
 }
 
-export async function generateImage({ model, prompt, options = {}, references = [], signal }, {
-  fetchFn = fetch, resolveKey = resolveGeminiKey,
-} = {}) {
-  const key = resolveKey();
-  const res = await post(model, key, geminiImageRequestBody(prompt, options, references), signal, fetchFn);
-  if (!res.ok) throw upstreamError('Gemini image', res.status, await res.text().catch(() => ''));
-  const data = await res.json();
-  const parts = data?.candidates?.[0]?.content?.parts || [];
+/**
+ * First inline image among a candidate's parts. A text-only answer is the
+ * model's refusal and surfaces as such; it is never retried.
+ */
+export function pickGeminiImagePart(parts, label, failure = null) {
   const image = parts.find((part) => part?.inlineData?.data);
   if (!image) {
-    const refusal = parts.find((part) => typeof part?.text === 'string')?.text || '';
+    const refusal = failure
+      || parts.find((part) => typeof part?.text === 'string' && part.text.trim())?.text
+      || '';
     throw mediaError(
-      `Gemini returned no image data${refusal ? `: ${refusal.slice(0, 200)}` : ''}`,
+      `${label} returned no image data${refusal ? `: ${String(refusal).slice(0, 200)}` : ''}`,
       'MEDIA_EMPTY_RESULT',
       502,
     );
   }
   return {
-    bytes: decodeBase64Media(image.inlineData.data, 'Gemini image'),
+    bytes: decodeBase64Media(image.inlineData.data, `${label} image`),
     mime: image.inlineData.mimeType || 'image/png',
     revisedPrompt: null,
   };
 }
+
+export async function generateImage({ model, prompt, options = {}, references = [], signal }, {
+  fetchFn = fetch, resolveKey = resolveGeminiKey,
+} = {}) {
+  const key = resolveKey();
+  const res = await post(model, key, geminiImageRequestBody(prompt, options, references), signal, fetchFn);
+  if (!res.ok) throw upstreamError('Gemini image', res.status, await res.text().catch(() => ''));
+  const data = await res.json();
+  return pickGeminiImagePart(data?.candidates?.[0]?.content?.parts || [], 'Gemini');
+}

package/src/runtime/media/auth.mjs

@@ -39,6 +39,18 @@ export async function resolveCodexAuth() {
   return await provider.ensureAuth();
 }
 
+/**
+ * Antigravity bearer + Cloud project. The chat provider's token store owns the
+ * refresh; the client version is warmed so discovery and generation present the
+ * same hub identity the gateway version-gates on.
+ */
+export async function resolveAntigravityAuth() {
+  const tokens = await import('../agent/orchestrator/providers/antigravity-oauth-tokens.mjs');
+  await tokens.ensureAntigravityVersion();
+  const current = await tokens.ensureAccessToken();
+  return { token: current.access_token, projectId: current.project_id };
+}
+
 export function resolveGeminiKey() {
   const key = getAgentApiKey('gemini');
   if (!key) {

package/src/runtime/media/catalog.mjs

@@ -6,7 +6,7 @@
  */
 import { createHash } from 'node:crypto';
 import { makeModelCache } from '../agent/orchestrator/providers/model-cache.mjs';
-import { resolveGeminiKey, resolveXaiAuth } from './auth.mjs';
+import { resolveAntigravityAuth, resolveGeminiKey, resolveXaiAuth } from './auth.mjs';
 import { catalogHttpError, staleCatalog } from './catalog-errors.mjs';
 
 const TTL_MS = 24 * 60 * 60_000;
@@ -29,6 +29,12 @@ function imageToolSupported(row, id) {
   return major >= 5 && !/(?:^|-)(?:codex|nano|pro|chat|audio|realtime|search)(?:-|$)/i.test(id);
 }
 
+// Antigravity serves the same Nano Banana family through the Cloud Code
+// Assist gateway; the ids and labels follow the Gemini API catalog.
+function googleLane(lane) {
+  return lane === 'gemini' || lane === 'antigravity-oauth';
+}
+
 function kindFor(lane, row, id) {
   if (row.deprecated === true || row.disabled === true) return null;
   if (lane === 'openai-oauth') return imageToolSupported(row, id) ? 'image' : null;
@@ -40,9 +46,11 @@ function kindFor(lane, row, id) {
       && !/^grok-imagine-video-1\.5(?:-|$)/.test(id)) return 'video';
     return null;
   }
-  if (lane === 'gemini') {
+  if (googleLane(lane)) {
     if (/^gemini-.*(?:^|-)image(?:-|$)/.test(id)
       && methodsAllow(row, 'generateContent')) return 'image';
+  }
+  if (lane === 'gemini') {
     if (/^gemini-omni-(?:[\d.]+-)?flash(?:-|$)/.test(id)) return 'video';
     if (/^veo-3(?:\.[\d]+)?-.*generate(?:-|$)/.test(id)
       && methodsAllow(row, 'predictLongRunning')) return 'video';
@@ -55,6 +63,13 @@ function version(id) {
     || id.match(/(?:image|video|omni)-(\d+(?:\.\d+)*)/))?.[1] || '0';
 }
 
+function isPreferredMediaModel(lane, kind, id) {
+  if (lane === 'openai-oauth') return !/(?:^|-)mini(?:-|$)/.test(id);
+  if (lane === 'gemini' && kind === 'video') return /^gemini-omni-/.test(id);
+  if (googleLane(lane) && kind === 'image') return !/-lite-|preview|experimental/.test(id);
+  return true;
+}
+
 function compareModels(a, b) {
   return Number(/preview|experimental/.test(a.id)) - Number(/preview|experimental/.test(b.id))
     || (Number(b.created) || 0) - (Number(a.created) || 0)
@@ -69,7 +84,7 @@ export function mediaModelLabel(lane, row, id) {
     label = id.replace(/^grok-imagine-image/, 'Grok Imagine Image')
       .replace(/^grok-imagine-video/, 'Grok Imagine Video')
       .replace(/-quality$/, ' Quality').replace(/-(\d)/, ' $1');
-  } else if (lane === 'gemini') {
+  } else if (googleLane(lane)) {
     const names = {
       'gemini-2.5-flash-image': 'Nano Banana · Gemini 2.5 Flash Image',
       'gemini-3.1-flash-image': 'Nano Banana 2 · Gemini 3.1 Flash Image',
@@ -109,10 +124,7 @@ export function projectMediaModels(lane, rows) {
   for (const kind of ['image', 'video']) {
     result[kind].sort(compareModels);
     // Defaults follow a current mainline/Omni model, never a dated hardcoded id.
-    const preferred = result[kind].findIndex((row) => lane === 'openai-oauth'
-      ? !/(?:^|-)mini(?:-|$)/.test(row.id)
-      : lane === 'gemini' && kind === 'video' ? /^gemini-omni-/.test(row.id)
-        : lane === 'gemini' && kind === 'image' ? !/-lite-|preview|experimental/.test(row.id) : true);
+    const preferred = result[kind].findIndex((row) => isPreferredMediaModel(lane, kind, row.id));
     if (preferred > 0) result[kind].unshift(...result[kind].splice(preferred, 1));
     result[kind] = result[kind].map(({ created, ...row }) => row);
   }
@@ -151,10 +163,13 @@ async function providerSource(lane) {
   }
   const auth = lane === 'gemini'
     ? { token: resolveGeminiKey() }
-    : await resolveXaiAuth(lane);
+    : lane === 'antigravity-oauth'
+      ? await resolveAntigravityAuth()
+      : await resolveXaiAuth(lane);
   // API-key and OAuth catalogs must not leak availability across credentials.
-  // Persist only a one-way scope hash, never a key or a bearer.
-  const scope = createHash('sha256').update(auth.token).digest('hex').slice(0, 24);
+  // Persist only a one-way scope hash, never a key or a bearer. Antigravity
+  // bearers rotate hourly; the Cloud project identifies that account instead.
+  const scope = createHash('sha256').update(auth.projectId || auth.token).digest('hex').slice(0, 24);
   return {
     key: `${lane}-${scope}`, revision,
     fetchModels: () => fetchMediaModelRows({ lane, auth }),
@@ -173,6 +188,11 @@ export async function fetchMediaModelRows({ lane, auth, fetchFn = fetch }) {
       return { ok: true, json: async () => data };
     });
   }
+  if (lane === 'antigravity-oauth') {
+    const { fetchAvailableModels } = await import('../agent/orchestrator/providers/antigravity-oauth-catalog.mjs');
+    const models = await fetchAvailableModels({ accessToken: auth.token, projectId: auth.projectId, fetchFn, signal });
+    return Object.entries(models).map(([id, row]) => ({ ...(row && typeof row === 'object' ? row : {}), id }));
+  }
   const { getLlmDispatcher } = await import('../shared/llm/http-agent.mjs');
   const response = await fetchFn(`${auth.baseURL}/models`, {
     headers: { Authorization: `Bearer ${auth.token}` },

package/src/runtime/media/jobs.mjs

@@ -58,6 +58,10 @@ async function runAdapter({ lane, kind, model, requestModel, prompt, options, re
     const adapter = await import('./adapters/codex-image.mjs');
     return await adapter.generateImage({ model: requestModel || model, prompt, options, references, signal });
   }
+  if (lane.id === 'antigravity-oauth') {
+    const adapter = await import('./adapters/antigravity-image.mjs');
+    return await adapter.generateImage({ model, prompt, options, references, signal });
+  }
   if (lane.id === 'gemini') {
     if (kind === 'video') {
       const adapter = await import('./adapters/gemini-video.mjs');

package/src/runtime/media/lanes.mjs

@@ -11,6 +11,7 @@ import { hasAgentApiKey } from '../shared/provider-api-key.mjs';
 // Credential probes are file-level checks: the catalog must not drag the whole
 // provider graph in just to render lane availability.
 import {
+  hasAntigravityOAuthCredentials,
   hasGrokOAuthCredentials,
   hasOpenAIOAuthCredentials,
 } from '../agent/orchestrator/providers/oauth-credential-probes.mjs';
@@ -23,40 +24,37 @@ export const MEDIA_KINDS = Object.freeze(['image', 'video']);
 // resolution, Gemini/Codex take pixel sizes. The UI renders whatever the lane
 // declares instead of inventing a cross-provider size model.
 const GROK_ASPECTS = Object.freeze(['auto', '1:1', '16:9', '9:16', '4:3', '3:4', '3:2', '2:3']);
+const GROK_IMAGE = Object.freeze({
+  controls: Object.freeze({ aspectRatio: GROK_ASPECTS, resolution: Object.freeze(['1k', '2k']), maxReferences: 5 }),
+});
+const GROK_VIDEO = Object.freeze({
+  controls: Object.freeze({
+    aspectRatio: GROK_ASPECTS,
+    resolution: Object.freeze(['480p', '720p', '1080p']),
+    durationRange: Object.freeze([1, 15]),
+    // 1 ref = image-to-video, 2-7 = reference-to-video.
+    maxReferences: 7,
+  }),
+});
+const GEMINI_IMAGE_CONTROLS = Object.freeze({
+  aspectRatio: Object.freeze(['auto', '1:1', '16:9', '9:16', '4:3', '3:4']),
+  maxReferences: 3,
+});
 
 const LANES = Object.freeze([
   Object.freeze({
     id: 'grok-oauth',
     label: 'Grok Imagine',
     auth: Object.freeze({ type: 'oauth', provider: 'grok-oauth' }),
-    image: Object.freeze({
-      controls: Object.freeze({ aspectRatio: GROK_ASPECTS, resolution: Object.freeze(['1k', '2k']), maxReferences: 5 }),
-    }),
-    video: Object.freeze({
-      controls: Object.freeze({
-        aspectRatio: GROK_ASPECTS,
-        resolution: Object.freeze(['480p', '720p', '1080p']),
-        durationRange: Object.freeze([1, 15]),
-        // 1 ref = image-to-video, 2-7 = reference-to-video.
-        maxReferences: 7,
-      }),
-    }),
+    image: GROK_IMAGE,
+    video: GROK_VIDEO,
   }),
   Object.freeze({
     id: 'xai',
     label: 'Grok Imagine',
     auth: Object.freeze({ type: 'api-key', provider: 'xai' }),
-    image: Object.freeze({
-      controls: Object.freeze({ aspectRatio: GROK_ASPECTS, resolution: Object.freeze(['1k', '2k']), maxReferences: 5 }),
-    }),
-    video: Object.freeze({
-      controls: Object.freeze({
-        aspectRatio: GROK_ASPECTS,
-        resolution: Object.freeze(['480p', '720p', '1080p']),
-        durationRange: Object.freeze([1, 15]),
-        maxReferences: 7,
-      }),
-    }),
+    image: GROK_IMAGE,
+    video: GROK_VIDEO,
   }),
   Object.freeze({
     id: 'openai-oauth',
@@ -73,11 +71,8 @@ const LANES = Object.freeze([
     label: 'Google Gemini',
     auth: Object.freeze({ type: 'api-key', provider: 'gemini' }),
     image: Object.freeze({
-      controls: Object.freeze({
-        aspectRatio: Object.freeze(['auto', '1:1', '16:9', '9:16', '4:3', '3:4']),
-        // Reference caps the image edit path at 3 inline references.
-        maxReferences: 3,
-      }),
+      // Reference caps the image edit path at 3 inline references.
+      controls: GEMINI_IMAGE_CONTROLS,
     }),
     video: Object.freeze({
       controls: Object.freeze({
@@ -90,19 +85,33 @@ const LANES = Object.freeze([
       }),
     }),
   }),
+  Object.freeze({
+    id: 'antigravity-oauth',
+    label: 'Google Antigravity',
+    auth: Object.freeze({ type: 'oauth', provider: 'antigravity-oauth' }),
+    // The gateway lists Nano Banana image models only; no video generation
+    // model is exposed, so the lane never advertises a video kind.
+    image: Object.freeze({
+      controls: GEMINI_IMAGE_CONTROLS,
+    }),
+  }),
 ]);
 
 const LANE_BY_ID = new Map(LANES.map((lane) => [lane.id, lane]));
 
+const OAUTH_PROBES = Object.freeze({
+  'grok-oauth': hasGrokOAuthCredentials,
+  'openai-oauth': hasOpenAIOAuthCredentials,
+  'antigravity-oauth': hasAntigravityOAuthCredentials,
+});
+
 function laneAuthenticated(lane) {
   try {
     if (lane.auth.type === 'api-key') return hasAgentApiKey(lane.auth.provider);
-    if (lane.auth.provider === 'grok-oauth') return hasGrokOAuthCredentials();
-    if (lane.auth.provider === 'openai-oauth') return hasOpenAIOAuthCredentials();
+    return OAUTH_PROBES[lane.auth.provider]?.() === true;
   } catch {
     return false;
   }
-  return false;
 }
 
 function laneKindView(lane, kind, models) {

package/src/runtime/memory/index.mjs

@@ -41,11 +41,7 @@ import {
   getMetaValue,
   setMetaValue,
   mergeMetaValue,
-  cleanMemoryText,
 } from './lib/memory.mjs'
-import {
-  firstTextContent,
-} from './lib/session-ingest.mjs';
 import { configureEmbedding, getEmbeddingDims, getEmbeddingDtype, getEmbeddingModelId, getKnownDimsForCurrentModel, primeEmbeddingDims, shutdownEmbeddingProvider, warmupEmbeddingProvider } from './lib/embedding-provider.mjs'
 import { startLlmWorker, stopLlmWorker } from './lib/llm-worker-host.mjs'
 import { runCycle1, runCycle2, runCycle3, parseInterval, flushEmbeddingDirty, flushRawEmbeddings } from './lib/memory-cycle.mjs'
@@ -196,8 +192,6 @@ const _transcriptIngest = createTranscriptIngest({
   persistMeta: (json) => setMetaValue(db, TRANSCRIPT_OFFSETS_KEY, json),
   projectsRoot: () => path.join(mixdogHome(), 'projects'),
   resolveProjectId,
-  firstTextContent,
-  cleanMemoryText,
   log: __mixdogMemoryLog,
 })
 const {
@@ -615,8 +609,7 @@ export async function appendEntry(data = {}) {
   await init()
   const role = String(data.role ?? 'user')
   const content = String(data.content ?? '')
-  const cleaned = cleanMemoryText(content)
-  if (!cleaned || !cleaned.trim()) return { error: content ? 'empty after clean' : 'content required' }
+  if (!content.trim()) return { error: 'content required' }
   const sourceRef = String(data.sourceRef ?? `manual:${Date.now()}-${process.pid}`)
   const sessionId = data.sessionId ?? null
   const tsMs = parseTsToMs(data.ts ?? Date.now())
@@ -626,7 +619,7 @@ export async function appendEntry(data = {}) {
     VALUES ($1, $2, $3, $4, $5, $6)
     ON CONFLICT DO NOTHING
     RETURNING id
-  `, [tsMs, role, cleaned, sourceRef, sessionId, projectId])
+  `, [tsMs, role, content, sourceRef, sessionId, projectId])
   const insertedId = result.rows[0]?.id ?? null
   return {
     ok: true,