neoagent 2.3.1-beta.66 → 2.3.1-beta.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.3.1-beta.66",
+  "version": "2.3.1-beta.67",
   "description": "Proactive personal AI agent with no limits",
   "license": "MIT",
   "main": "server/index.js",
@@ -54,6 +54,9 @@
     "@anthropic-ai/sdk": "^0.39.0",
     "@google/generative-ai": "^0.24.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
+    "@remotion/cli": "^4.0.459",
+    "@slidev/cli": "^52.15.2",
+    "@slidev/theme-default": "^0.25.0",
     "baileys": "^6.7.21",
     "bcrypt": "^6.0.0",
     "better-sqlite3": "^11.8.1",
@@ -73,11 +76,13 @@
     "nodemailer": "^8.0.5",
     "openai": "^4.85.4",
     "otplib": "^13.4.0",
+    "playwright-chromium": "^1.59.1",
     "proper-lockfile": "^4.1.2",
     "puppeteer-core": "^24.40.0",
     "puppeteer-extra": "^3.3.6",
     "puppeteer-extra-plugin-stealth": "^2.11.2",
     "qrcode": "^1.5.4",
+    "remotion": "^4.0.459",
     "sharp": "^0.34.5",
     "socket.io": "^4.8.1",
     "telegraf": "^4.16.3",

package/runtime/paths.js

@@ -1,6 +1,8 @@
 const fs = require('fs');
+const crypto = require('crypto');
 const os = require('os');
 const path = require('path');
+const { parseEnv } = require('./env');
 
 const APP_DIR = path.resolve(__dirname, '..');
 const HOME_DIR = os.homedir();
@@ -95,6 +97,96 @@ function migrateLegacyRuntime(logger = () => {}) {
   return changed;
 }
 
+function readEnvFileRaw(envFile = ENV_FILE) {
+  try {
+    return fs.readFileSync(envFile, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function upsertEnvValue(envFile, key, value) {
+  const raw = readEnvFileRaw(envFile);
+  const lines = raw ? raw.split('\n') : [];
+  let replaced = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith(`${key}=`)) {
+      lines[i] = `${key}=${value}`;
+      replaced = true;
+      break;
+    }
+  }
+
+  if (!replaced) {
+    lines.push(`${key}=${value}`);
+  }
+
+  const output = lines.filter((line, idx, arr) => idx !== arr.length - 1 || line !== '').join('\n') + '\n';
+  fs.mkdirSync(path.dirname(envFile), { recursive: true });
+  fs.writeFileSync(envFile, output, { mode: 0o600 });
+}
+
+function generateSecret(bytes = 32) {
+  return crypto.randomBytes(bytes).toString('hex');
+}
+
+function isPlaceholderValue(value, placeholders) {
+  const secret = String(value || '').trim();
+  return !secret || placeholders.has(secret);
+}
+
+function isValidVmGuestToken(value) {
+  const secret = String(value || '').trim();
+  if (!secret || secret.length < 32) return false;
+  if (/^(change|replace|set|your|example|sample|placeholder|token|secret)[-_a-z0-9]*$/i.test(secret)) return false;
+  if (/change-this-guest-token-before-prod/i.test(secret)) return false;
+  if (/^(.)\1+$/.test(secret)) return false;
+  return true;
+}
+
+function ensureSecureRuntimeEnv({ envFile = ENV_FILE, env = process.env, logger = console } = {}) {
+  const raw = readEnvFileRaw(envFile);
+  const parsed = parseEnv(raw);
+  const changes = [];
+  const sessionPlaceholders = new Set([
+    'neoagent-dev-secret-change-me',
+    'change-this-to-a-random-secret-in-production',
+    'change-me-to-something-random',
+  ]);
+
+  let sessionSecret = String(env.SESSION_SECRET || parsed.get('SESSION_SECRET') || '').trim();
+  if (isPlaceholderValue(sessionSecret, sessionPlaceholders)) {
+    sessionSecret = generateSecret(32);
+    env.SESSION_SECRET = sessionSecret;
+    upsertEnvValue(envFile, 'SESSION_SECRET', sessionSecret);
+    changes.push('SESSION_SECRET');
+  }
+
+  let guestToken = String(env.NEOAGENT_VM_GUEST_TOKEN || parsed.get('NEOAGENT_VM_GUEST_TOKEN') || '').trim();
+  if (!isValidVmGuestToken(guestToken)) {
+    guestToken = generateSecret(32);
+    env.NEOAGENT_VM_GUEST_TOKEN = guestToken;
+    upsertEnvValue(envFile, 'NEOAGENT_VM_GUEST_TOKEN', guestToken);
+    changes.push('NEOAGENT_VM_GUEST_TOKEN');
+  }
+
+  if (changes.length > 0 && logger) {
+    const message = `Initialized secure runtime secrets: ${changes.join(', ')}`;
+    if (typeof logger.info === 'function') {
+      logger.info(message);
+    } else if (typeof logger.log === 'function') {
+      logger.log(message);
+    }
+  }
+
+  return {
+    changes,
+    sessionSecret: env.SESSION_SECRET || null,
+    guestToken: env.NEOAGENT_VM_GUEST_TOKEN || null,
+  };
+}
+
 module.exports = {
   APP_DIR,
   HOME_DIR,
@@ -109,5 +201,6 @@ module.exports = {
   LEGACY_DATA_DIR,
   LEGACY_AGENT_DATA_DIR,
   ensureRuntimeDirs,
+  ensureSecureRuntimeEnv,
   migrateLegacyRuntime
 };

package/runtime/paths.test.js

@@ -0,0 +1,29 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {
+  ensureSecureRuntimeEnv,
+} = require('./paths');
+
+test('ensureSecureRuntimeEnv generates runtime secrets when missing', () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'neoagent-runtime-'));
+  const envFile = path.join(tempDir, '.env');
+  const env = {};
+
+  const result = ensureSecureRuntimeEnv({
+    envFile,
+    env,
+    logger: null,
+  });
+
+  const content = fs.readFileSync(envFile, 'utf8');
+  assert.match(content, /^SESSION_SECRET=/m);
+  assert.match(content, /^NEOAGENT_VM_GUEST_TOKEN=/m);
+  assert.equal(result.changes.includes('SESSION_SECRET'), true);
+  assert.equal(result.changes.includes('NEOAGENT_VM_GUEST_TOKEN'), true);
+  assert.ok(String(env.SESSION_SECRET || '').length >= 64);
+  assert.ok(String(env.NEOAGENT_VM_GUEST_TOKEN || '').length >= 64);
+});

package/server/index.js

@@ -3,6 +3,7 @@
 const {
   ENV_FILE,
   LEGACY_ENV_FILE,
+  ensureSecureRuntimeEnv,
   migrateLegacyRuntime,
   ensureRuntimeDirs
 } = require('../runtime/paths');
@@ -11,6 +12,7 @@ const dotenv = require('dotenv');
 
 migrateLegacyRuntime();
 ensureRuntimeDirs();
+ensureSecureRuntimeEnv({ logger: console });
 dotenv.config({ path: LEGACY_ENV_FILE });
 dotenv.config({ path: ENV_FILE, override: true });
 
@@ -19,10 +21,6 @@ const { createServer } = require('http');
 
 const db = require('./db/database');
 const { setupConsoleInterceptor } = require('./utils/logger');
-const {
-  configuredSessionSecret,
-  isInsecureSessionSecret,
-} = require('./services/account/session_secret');
 const { validateOrigin } = require('./config/origins');
 const {
   applyHttpMiddleware,
@@ -87,16 +85,6 @@ function logStartupConfig() {
 
 logStartupConfig();
 
-if (!configuredSessionSecret()) {
-  console.warn(
-    'WARNING: SESSION_SECRET not set — using a process-local random fallback. Set it in .env before exposing this server.'
-  );
-} else if (isInsecureSessionSecret()) {
-  console.warn(
-    'WARNING: SESSION_SECRET uses a known placeholder value. Replace it with a random secret before exposing this server.'
-  );
-}
-
 const app = express();
 app.disable('x-powered-by');
 const httpServer = createServer(app);

package/server/public/.last_build_id

@@ -1 +1 @@
-03e50077364c472b1caef378bca9ddc5
+d4a028d4f0ac72510e406325f227aae2

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"42d3d75a56efe1a2e9902f52dc8006099c45d9
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "167614730" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "889725162" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/public/main.dart.js

@@ -127230,7 +127230,7 @@ r===$&&A.b()
 o.push(A.id(p,A.iS(!1,new A.a3(B.tE,A.dZ(new A.cU(B.h8,new A.a5p(r,p),p),p,p),p),!1,B.I,!0),p,p,0,0,0,p))}r=!1
 if(!s.ay)if(!s.ch){r=s.e
 r===$&&A.b()
-r=B.b.A("mp05guq4-d8088a9").length!==0&&r.b}if(r){r=s.d
+r=B.b.A("mp0we32e-3c36f1d").length!==0&&r.b}if(r){r=s.d
 r===$&&A.b()
 r=r.V&&!r.a0?84:0
 q=s.e
@@ -131894,7 +131894,7 @@ $S:324}
 A.Y0.prototype={}
 A.R0.prototype={
 mJ(a){var s=this
-if(B.b.A("mp05guq4-d8088a9").length===0||s.a!=null)return
+if(B.b.A("mp0we32e-3c36f1d").length===0||s.a!=null)return
 s.zY()
 s.a=A.pN(B.Pr,new A.b3g(s))},
 zY(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f
@@ -131912,7 +131912,7 @@ if(!t.f.b(k)){s=1
 break}i=J.Z(k,"buildId")
 h=i==null?null:B.b.A(J.r(i))
 j=h==null?"":h
-if(J.bi(j)===0||J.c(j,"mp05guq4-d8088a9")){s=1
+if(J.bi(j)===0||J.c(j,"mp0we32e-3c36f1d")){s=1
 break}n.b=!0
 n.J()
 p=2
@@ -131929,7 +131929,7 @@ case 2:return A.i(o.at(-1),r)}})
 return A.k($async$zY,r)},
 v_(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f,e,d,c,b,a,a0,a1
 var $async$v_=A.h(function(a2,a3){if(a2===1){o.push(a3)
-s=p}for(;;)switch(s){case 0:if(B.b.A("mp05guq4-d8088a9").length===0||n.c){s=1
+s=p}for(;;)switch(s){case 0:if(B.b.A("mp0we32e-3c36f1d").length===0||n.c){s=1
 break}n.c=!0
 n.J()
 p=4

package/server/services/ai/deliverables/workflows.js

@@ -43,6 +43,7 @@ function createWorkflow(config) {
         supportingCapabilities: request.supportingCapabilities,
         preferredTools: [...this.preferredTools],
         expectedOutputs: [...this.expectedOutputs],
+        summaryHints: [...this.summaryHints],
         validationRules: [
           `Produce deliverable artifacts of type "${config.type}" before finishing.`,
           'Mention output files or artifact links explicitly in the final response when available.',
@@ -110,10 +111,15 @@ const WORKFLOWS = [
   createWorkflow({
     type: 'slides',
     displayName: 'Slides',
-    preferredTools: ['write_file', 'edit_file', 'execute_command', 'browser_screenshot', 'generate_image'],
+    preferredTools: ['generate_slide_deck', 'write_file', 'edit_file', 'execute_command', 'browser_screenshot', 'generate_image'],
     expectedOutputs: ['presentation deck', 'exported slide file', 'visual proof'],
     expectedArtifactKinds: ['slides', 'document', 'image'],
     expectedExtensions: ['.ppt', '.pptx', '.pdf', '.html', '.png', '.jpg', '.jpeg'],
+    summaryHints: [
+      'Prefer generate_slide_deck for final deck creation and export.',
+      'Use 5-12 slides with clear titles and concise body copy.',
+      'Request pdf or pdf+pptx exports when the user wants a finished shareable deck.',
+    ],
   }),
   createWorkflow({
     type: 'document',
@@ -161,10 +167,15 @@ const WORKFLOWS = [
   createWorkflow({
     type: 'video',
     displayName: 'Video',
-    preferredTools: ['execute_command', 'write_file', 'edit_file'],
+    preferredTools: ['generate_video_with_remotion', 'execute_command', 'write_file', 'edit_file'],
     expectedOutputs: ['rendered video asset'],
     expectedArtifactKinds: ['video'],
     expectedExtensions: ['.mp4', '.mov', '.m4v', '.webm'],
+    summaryHints: [
+      'Prefer generate_video_with_remotion for the final rendered asset.',
+      'Use 3-10 scenes with explicit duration_seconds and concise on-screen text.',
+      'Attach local assets by absolute image_path or audio_path when available.',
+    ],
   }),
 ];
 
@@ -184,6 +195,7 @@ function buildDeliverableWorkflowGuidance(plan) {
     plan.requestedOutputs?.length ? `Requested outputs: ${plan.requestedOutputs.join(', ')}` : '',
     plan.preferredTools?.length ? `Preferred tools/capabilities: ${plan.preferredTools.join(', ')}` : '',
     plan.expectedOutputs?.length ? `Expected artifacts: ${plan.expectedOutputs.join(', ')}` : '',
+    plan.summaryHints?.length ? `Execution guidance: ${plan.summaryHints.join(' ')}` : '',
     'Before finishing, ensure the final deliverable exists, validate it, and summarize the produced artifacts clearly.',
   ].filter(Boolean).join('\n');
 }

package/server/services/ai/integrated_tools/index.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const { generateSlideDeck } = require('./slidev');
+const { generateVideoWithRemotion } = require('./remotion');
+
+function getIntegratedToolDefinitions() {
+  return [
+    {
+      name: 'generate_slide_deck',
+      description: 'Generate a polished presentation using Slidev and export finished artifacts. Prefer this for decks instead of raw file-writing. Best practice: pass a clear title and a complete slides array, and request export_formats ["pdf"] or ["pdf","pptx"] for a shareable final result.',
+      parameters: {
+        type: 'object',
+        properties: {
+          title: { type: 'string', description: 'Deck title.' },
+          subtitle: { type: 'string', description: 'Optional deck subtitle or framing line.' },
+          theme: { type: 'string', description: 'Slidev theme name. Defaults to "default".' },
+          deck_markdown: { type: 'string', description: 'Optional full Slidev markdown deck. Use this when you want exact Slidev syntax control.' },
+          slides: {
+            type: 'array',
+            description: 'Structured slide definitions. Use this for most decks if you do not need custom Slidev markdown.',
+            items: {
+              type: 'object',
+              properties: {
+                title: { type: 'string', description: 'Slide title.' },
+                body: { type: 'string', description: 'Short narrative paragraph or statement.' },
+                bullets: { type: 'array', items: { type: 'string' }, description: 'Bullet list for the slide.' },
+                notes: { type: 'string', description: 'Presenter notes.' },
+                image_url: { type: 'string', description: 'Optional remote image URL to embed.' },
+                image_path: { type: 'string', description: 'Optional absolute local image path to embed.' },
+                layout: { type: 'string', description: 'Optional Slidev layout, for example cover, section, statement, quote, or two-cols.' },
+                className: { type: 'string', description: 'Optional Slidev class value.' },
+              },
+            },
+          },
+          export_formats: {
+            type: 'array',
+            items: { type: 'string', enum: ['pdf', 'pptx', 'png'] },
+            description: 'Finished output formats. Defaults to ["pdf"].',
+          },
+          filename_base: { type: 'string', description: 'Optional output filename base.' },
+        },
+        required: ['title'],
+      },
+    },
+    {
+      name: 'generate_video_with_remotion',
+      description: 'Generate a finished MP4 video using Remotion. Prefer this for explainers, launch videos, reels, and narrated visual summaries. Best practice: pass 3-10 scenes with explicit duration_seconds, concise on-screen text, and optional image_path or image_url assets.',
+      parameters: {
+        type: 'object',
+        properties: {
+          title: { type: 'string', description: 'Video title or opening headline.' },
+          subtitle: { type: 'string', description: 'Optional supporting line.' },
+          style: { type: 'string', description: 'High-level visual style direction.' },
+          aspect_ratio: { type: 'string', enum: ['16:9', '9:16', '1:1', '4:5'], description: 'Video canvas aspect ratio. Defaults to 16:9.' },
+          fps: { type: 'number', description: 'Frames per second. Defaults to 30.' },
+          audio_path: { type: 'string', description: 'Optional absolute local path to a soundtrack or voiceover file.' },
+          scenes: {
+            type: 'array',
+            description: 'Scene list in playback order.',
+            items: {
+              type: 'object',
+              properties: {
+                title: { type: 'string', description: 'Scene headline.' },
+                body: { type: 'string', description: 'Supporting sentence or paragraph.' },
+                bullets: { type: 'array', items: { type: 'string' }, description: 'Optional bullets to show in the scene.' },
+                duration_seconds: { type: 'number', description: 'Scene duration in seconds.' },
+                image_url: { type: 'string', description: 'Optional remote image URL.' },
+                image_path: { type: 'string', description: 'Optional absolute local image path.' },
+                accent_color: { type: 'string', description: 'Optional accent color, for example #7dd3fc.' },
+                background_color: { type: 'string', description: 'Optional scene background color.' },
+                align: { type: 'string', enum: ['left', 'center', 'right'], description: 'Text alignment.' },
+              },
+              required: ['title'],
+            },
+          },
+          filename_base: { type: 'string', description: 'Optional output filename base.' },
+        },
+        required: ['title', 'scenes'],
+      },
+    },
+  ];
+}
+
+async function executeIntegratedTool(toolName, args, context = {}) {
+  switch (String(toolName || '').trim()) {
+    case 'generate_slide_deck':
+      return generateSlideDeck(args, context);
+    case 'generate_video_with_remotion':
+      return generateVideoWithRemotion(args, context);
+    default:
+      return null;
+  }
+}
+
+module.exports = {
+  executeIntegratedTool,
+  getIntegratedToolDefinitions,
+};

package/server/services/ai/integrated_tools/remotion.js

@@ -0,0 +1,365 @@
+'use strict';
+
+const path = require('path');
+const {
+  copyAssetIntoJob,
+  createArtifactDescriptor,
+  createJobDir,
+  ensureDir,
+  normalizeFilenameBase,
+  promoteArtifactDescriptor,
+  resolveRepoBinary,
+  runCheckedCommand,
+  shellEscape,
+  writeJsonFile,
+  writeTextFile,
+} = require('./shared');
+
+const REMOTION_BIN = resolveRepoBinary('remotion');
+const ASPECT_RATIOS = {
+  '16:9': { width: 1920, height: 1080 },
+  '9:16': { width: 1080, height: 1920 },
+  '1:1': { width: 1080, height: 1080 },
+  '4:5': { width: 1080, height: 1350 },
+};
+
+function normalizeScene(scene = {}) {
+  const durationSeconds = Math.max(1.5, Number(scene.duration_seconds ?? scene.durationSeconds) || 3);
+  return {
+    title: String(scene.title || '').trim(),
+    body: String(scene.body || '').trim(),
+    bullets: Array.isArray(scene.bullets)
+      ? scene.bullets.map((item) => String(item || '').trim()).filter(Boolean).slice(0, 5)
+      : [],
+    durationSeconds,
+    accentColor: String(scene.accent_color || scene.accentColor || '#7dd3fc').trim() || '#7dd3fc',
+    backgroundColor: String(scene.background_color || scene.backgroundColor || '#08111f').trim() || '#08111f',
+    align: ['left', 'center', 'right'].includes(String(scene.align || '').trim())
+      ? String(scene.align).trim()
+      : 'left',
+    imagePath: String(scene.image_path || '').trim(),
+    imageUrl: String(scene.image_url || '').trim(),
+  };
+}
+
+function normalizeProps(args, jobDir) {
+  const assetsDir = ensureDir(path.join(jobDir, 'public', 'assets'));
+  const scenes = (Array.isArray(args.scenes) ? args.scenes : [])
+    .map(normalizeScene)
+    .filter((scene) => scene.title || scene.body || scene.bullets.length > 0);
+  if (scenes.length === 0) {
+    throw new Error('generate_video_with_remotion requires a non-empty scenes array.');
+  }
+
+  const preparedScenes = scenes.map((scene, index) => {
+    let imageSrc = scene.imageUrl || '';
+    if (!imageSrc && scene.imagePath) {
+      const asset = copyAssetIntoJob(scene.imagePath, assetsDir, `scene-${index + 1}`);
+      imageSrc = `/assets/${asset.relativePath}`;
+    }
+    return {
+      ...scene,
+      imageSrc,
+    };
+  });
+
+  let audioSrc = '';
+  if (args.audio_path) {
+    const asset = copyAssetIntoJob(args.audio_path, assetsDir, 'soundtrack');
+    audioSrc = `/assets/${asset.relativePath}`;
+  }
+
+  return {
+    title: String(args.title || 'NeoAgent video').trim(),
+    subtitle: String(args.subtitle || '').trim(),
+    style: String(args.style || 'editorial cinematic').trim(),
+    fps: Math.max(12, Math.min(60, Number(args.fps) || 30)),
+    aspectRatio: ASPECT_RATIOS[String(args.aspect_ratio || '').trim()] ? String(args.aspect_ratio).trim() : '16:9',
+    scenes: preparedScenes,
+    audioSrc,
+  };
+}
+
+function buildRootFile() {
+  return `const React = require('react');
+const {registerRoot, Composition} = require('remotion');
+const props = require('./props.json');
+const {NeoAgentVideo} = require('./VideoComposition');
+
+const sizes = {
+  '16:9': {width: 1920, height: 1080},
+  '9:16': {width: 1080, height: 1920},
+  '1:1': {width: 1080, height: 1080},
+  '4:5': {width: 1080, height: 1350},
+};
+
+const fps = Number(props.fps) || 30;
+const sceneFrames = (props.scenes || []).map((scene) => Math.max(1, Math.round((Number(scene.durationSeconds) || 3) * fps)));
+const durationInFrames = sceneFrames.reduce((sum, next) => sum + next, 0);
+const size = sizes[props.aspectRatio] || sizes['16:9'];
+
+const RemotionRoot = () => (
+  React.createElement(
+    React.Fragment,
+    null,
+    React.createElement(Composition, {
+      id: 'NeoAgentVideo',
+      component: NeoAgentVideo,
+      durationInFrames,
+      fps,
+      width: size.width,
+      height: size.height,
+      defaultProps: props,
+    }),
+  )
+);
+
+registerRoot(RemotionRoot);
+`;
+}
+
+function buildCompositionFile() {
+  return `const React = require('react');
+const {AbsoluteFill, Audio, Img, Sequence, interpolate, spring, useCurrentFrame, useVideoConfig} = require('remotion');
+
+const FONT_STACK = 'Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif';
+
+const shellStyle = {
+  position: 'relative',
+  overflow: 'hidden',
+  fontFamily: FONT_STACK,
+  color: '#f8fafc',
+  padding: 72,
+};
+
+const backdropStyle = {
+  position: 'absolute',
+  inset: 0,
+  background: 'radial-gradient(circle at top left, rgba(125,211,252,0.28), transparent 34%), radial-gradient(circle at bottom right, rgba(168,85,247,0.18), transparent 40%)',
+};
+
+const cardStyle = {
+  position: 'relative',
+  marginTop: 40,
+  borderRadius: 36,
+  padding: '40px 44px',
+  border: '1px solid rgba(255,255,255,0.14)',
+  background: 'rgba(7, 14, 25, 0.68)',
+  boxShadow: '0 28px 90px rgba(0,0,0,0.28)',
+  backdropFilter: 'blur(18px)',
+};
+
+const SceneView = ({scene}) => {
+  const frame = useCurrentFrame();
+  const {fps, durationInFrames} = useVideoConfig();
+  const entrance = spring({frame, fps, config: {damping: 18, mass: 0.9}});
+  const exitOpacity = interpolate(frame, [Math.max(0, durationInFrames - 18), durationInFrames], [1, 0], {
+    extrapolateLeft: 'clamp',
+    extrapolateRight: 'clamp',
+  });
+  const translateY = interpolate(entrance, [0, 1], [34, 0]);
+  const textAlign = scene.align || 'left';
+
+  return (
+    React.createElement(AbsoluteFill, {
+      style: {
+        ...shellStyle,
+        justifyContent: 'center',
+        background: scene.backgroundColor || '#08111f',
+        opacity: exitOpacity,
+      },
+    },
+      React.createElement('div', {style: backdropStyle}),
+      scene.imageSrc
+        ? React.createElement(Img, {
+            src: scene.imageSrc,
+            style: {
+              position: 'absolute',
+              inset: 0,
+              width: '100%',
+              height: '100%',
+              objectFit: 'cover',
+              opacity: 0.18,
+            },
+          })
+        : null,
+      React.createElement('div', {
+        style: {
+          ...cardStyle,
+          transform: \`translateY(\${translateY}px)\`,
+          maxWidth: scene.imageSrc ? '62%' : '100%',
+        },
+      },
+        React.createElement('div', {
+          style: {
+            width: 110,
+            height: 8,
+            borderRadius: 999,
+            background: scene.accentColor || '#7dd3fc',
+            marginBottom: 24,
+          },
+        }),
+        React.createElement('h1', {
+          style: {
+            margin: 0,
+            fontSize: 76,
+            lineHeight: 1.02,
+            letterSpacing: '-0.06em',
+            textAlign,
+          },
+        }, scene.title || 'Scene'),
+        scene.body
+          ? React.createElement('p', {
+              style: {
+                margin: '20px 0 0 0',
+                maxWidth: 900,
+                fontSize: 32,
+                lineHeight: 1.35,
+                color: 'rgba(226,232,240,0.92)',
+                textAlign,
+              },
+            }, scene.body)
+          : null,
+        scene.bullets && scene.bullets.length > 0
+          ? React.createElement('ul', {
+              style: {
+                margin: '28px 0 0 0',
+                paddingLeft: textAlign === 'center' ? 24 : 34,
+                fontSize: 28,
+                lineHeight: 1.45,
+                color: 'rgba(226,232,240,0.88)',
+              },
+            }, scene.bullets.map((bullet, index) => React.createElement('li', {
+              key: String(index),
+              style: {marginBottom: 12},
+            }, bullet)))
+          : null,
+      ),
+      scene.imageSrc
+        ? React.createElement('div', {
+            style: {
+              position: 'absolute',
+              right: 72,
+              bottom: 72,
+              top: 72,
+              width: '30%',
+              borderRadius: 32,
+              overflow: 'hidden',
+              border: '1px solid rgba(255,255,255,0.16)',
+              boxShadow: '0 22px 70px rgba(0,0,0,0.28)',
+              transform: \`translateY(\${translateY * 0.7}px)\`,
+            },
+          },
+            React.createElement(Img, {
+              src: scene.imageSrc,
+              style: {
+                width: '100%',
+                height: '100%',
+                objectFit: 'cover',
+              },
+            }),
+          )
+        : null,
+    )
+  );
+};
+
+const NeoAgentVideo = (props) => {
+  const fps = Number(props.fps) || 30;
+  const scenes = Array.isArray(props.scenes) ? props.scenes : [];
+  let cursor = 0;
+
+  return (
+    React.createElement(AbsoluteFill, {style: {backgroundColor: '#020617'}},
+      props.audioSrc ? React.createElement(Audio, {src: props.audioSrc}) : null,
+      scenes.map((scene, index) => {
+        const durationInFrames = Math.max(1, Math.round((Number(scene.durationSeconds) || 3) * fps));
+        const startFrom = cursor;
+        cursor += durationInFrames;
+        return React.createElement(Sequence, {
+          key: String(index),
+          from: startFrom,
+          durationInFrames,
+        }, React.createElement(SceneView, {scene}));
+      }),
+    )
+  );
+};
+
+exports.NeoAgentVideo = NeoAgentVideo;
+`;
+}
+
+async function generateVideoWithRemotion(args, context = {}) {
+  if (!context.cliExecutor || typeof context.cliExecutor.execute !== 'function') {
+    throw new Error('CLI executor is unavailable for Remotion rendering.');
+  }
+  const filenameBase = normalizeFilenameBase(args.filename_base || args.title || 'video', 'video');
+  const jobDir = createJobDir('remotion', filenameBase);
+  const entryPath = path.join(jobDir, 'index.js');
+  const compositionPath = path.join(jobDir, 'VideoComposition.js');
+  const propsPath = path.join(jobDir, 'props.json');
+  const outputPath = path.join(jobDir, `${filenameBase}.mp4`);
+  const props = normalizeProps(args, jobDir);
+  const size = ASPECT_RATIOS[props.aspectRatio] || ASPECT_RATIOS['16:9'];
+  const durationInFrames = props.scenes.reduce((sum, scene) => (
+    sum + Math.max(1, Math.round(scene.durationSeconds * props.fps))
+  ), 0);
+
+  writeTextFile(entryPath, buildRootFile());
+  writeTextFile(compositionPath, buildCompositionFile());
+  writeJsonFile(propsPath, props);
+
+  const command = [
+    shellEscape(REMOTION_BIN),
+    'render',
+    shellEscape(entryPath),
+    shellEscape('NeoAgentVideo'),
+    shellEscape(outputPath),
+    '--props',
+    shellEscape(propsPath),
+    '--codec',
+    shellEscape('h264'),
+    '--fps',
+    shellEscape(String(props.fps)),
+    '--width',
+    shellEscape(String(size.width)),
+    '--height',
+    shellEscape(String(size.height)),
+    '--duration',
+    shellEscape(String(durationInFrames)),
+    '--overwrite',
+  ].join(' ');
+
+  const result = await runCheckedCommand(context.cliExecutor, command, {
+    cwd: jobDir,
+    timeout: 20 * 60 * 1000,
+    errorPrefix: 'Remotion render failed.',
+  });
+
+  const videoDescriptor = createArtifactDescriptor(outputPath, {
+    kind: 'video',
+    label: path.basename(outputPath),
+    mimeType: 'video/mp4',
+  });
+  const promotedVideo = promoteArtifactDescriptor(videoDescriptor, context.artifactStore, context.userId);
+
+  return {
+    success: true,
+    tool: 'generate_video_with_remotion',
+    title: props.title,
+    artifacts: [promotedVideo],
+    message: 'Generated rendered video.',
+    render: {
+      aspectRatio: props.aspectRatio,
+      fps: props.fps,
+      durationInFrames,
+      sceneCount: props.scenes.length,
+      durationMs: result.durationMs,
+    },
+  };
+}
+
+module.exports = {
+  generateVideoWithRemotion,
+};

package/server/services/ai/integrated_tools/shared.js

@@ -0,0 +1,199 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { APP_DIR, DATA_DIR } = require('../../../../runtime/paths');
+
+const TOOLING_ROOT = path.join(DATA_DIR, 'integrated-tools');
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+  return dirPath;
+}
+
+function ensureRepoNodeModulesLink(targetDir) {
+  ensureDir(targetDir);
+  const sourceNodeModules = path.join(APP_DIR, 'node_modules');
+  const targetNodeModules = path.join(targetDir, 'node_modules');
+  if (fs.existsSync(targetNodeModules)) {
+    return targetNodeModules;
+  }
+  fs.symlinkSync(sourceNodeModules, targetNodeModules, 'junction');
+  return targetNodeModules;
+}
+
+function shellEscape(value) {
+  const text = String(value ?? '');
+  if (!text.length) return "''";
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+
+function normalizeFilenameBase(value, fallback = 'artifact') {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return normalized || fallback;
+}
+
+function createJobDir(toolName, filenameBase) {
+  const prefix = normalizeFilenameBase(toolName, 'tool');
+  const suffix = normalizeFilenameBase(filenameBase, 'output');
+  const jobId = `${Date.now()}-${crypto.randomBytes(4).toString('hex')}-${suffix}`;
+  return ensureDir(path.join(TOOLING_ROOT, prefix, jobId));
+}
+
+function resolveRepoBinary(...segments) {
+  const parts = [...segments];
+  if (process.platform === 'win32' && parts.length > 0 && !parts[parts.length - 1].endsWith('.cmd')) {
+    parts[parts.length - 1] = `${parts[parts.length - 1]}.cmd`;
+  }
+  return path.join(APP_DIR, 'node_modules', '.bin', ...parts);
+}
+
+function assertExistingFile(filePath, label = 'file') {
+  const absolutePath = path.resolve(String(filePath || ''));
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`${label} does not exist: ${absolutePath}`);
+  }
+  const stat = fs.statSync(absolutePath);
+  if (!stat.isFile()) {
+    throw new Error(`${label} is not a file: ${absolutePath}`);
+  }
+  return absolutePath;
+}
+
+function writeTextFile(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, String(content || ''), 'utf8');
+  return filePath;
+}
+
+function writeJsonFile(filePath, payload) {
+  writeTextFile(filePath, `${JSON.stringify(payload, null, 2)}\n`);
+  return filePath;
+}
+
+function copyAssetIntoJob(sourcePath, targetDir, preferredName = 'asset') {
+  const absolutePath = assertExistingFile(sourcePath, 'asset');
+  ensureDir(targetDir);
+  const extension = path.extname(absolutePath).toLowerCase();
+  const basename = normalizeFilenameBase(path.basename(absolutePath, extension), preferredName);
+  const filename = `${basename}-${crypto.randomBytes(3).toString('hex')}${extension}`;
+  const targetPath = path.join(targetDir, filename);
+  fs.copyFileSync(absolutePath, targetPath);
+  return {
+    sourcePath: absolutePath,
+    targetPath,
+    relativePath: filename,
+  };
+}
+
+async function runCheckedCommand(executor, command, options = {}) {
+  if (!executor || typeof executor.execute !== 'function') {
+    throw new Error('CLI executor is unavailable for integrated tools.');
+  }
+  const result = await executor.execute(command, {
+    cwd: options.cwd,
+    timeout: options.timeout,
+    env: options.env,
+  });
+  if (result.exitCode !== 0) {
+    const stderr = String(result.stderr || '').trim();
+    const stdout = String(result.stdout || '').trim();
+    const details = stderr || stdout || `Command failed: ${command}`;
+    throw new Error(
+      options.errorPrefix
+        ? `${options.errorPrefix} ${details}`.trim()
+        : details
+    );
+  }
+  return result;
+}
+
+function inferArtifactExtension(filePath) {
+  return path.extname(String(filePath || '')).toLowerCase().replace(/^\./, '') || 'bin';
+}
+
+function inferContentType(filePath) {
+  const extension = path.extname(String(filePath || '')).toLowerCase();
+  switch (extension) {
+    case '.pdf': return 'application/pdf';
+    case '.ppt': return 'application/vnd.ms-powerpoint';
+    case '.pptx': return 'application/vnd.openxmlformats-officedocument.presentationml.presentation';
+    case '.md': return 'text/markdown';
+    case '.png': return 'image/png';
+    case '.jpg':
+    case '.jpeg': return 'image/jpeg';
+    case '.svg': return 'image/svg+xml';
+    case '.mp4': return 'video/mp4';
+    case '.mov': return 'video/quicktime';
+    case '.webm': return 'video/webm';
+    default: return 'application/octet-stream';
+  }
+}
+
+function inferArtifactKind(filePath) {
+  const extension = path.extname(String(filePath || '')).toLowerCase();
+  if (['.ppt', '.pptx'].includes(extension)) return 'slides';
+  if (['.pdf', '.md'].includes(extension)) return 'document';
+  if (['.png', '.jpg', '.jpeg', '.svg'].includes(extension)) return 'image';
+  if (['.mp4', '.mov', '.webm'].includes(extension)) return 'video';
+  return 'artifact';
+}
+
+function createArtifactDescriptor(filePath, options = {}) {
+  const absolutePath = assertExistingFile(filePath, 'output');
+  const stat = fs.statSync(absolutePath);
+  return {
+    kind: options.kind || inferArtifactKind(absolutePath),
+    label: options.label || path.basename(absolutePath),
+    path: absolutePath,
+    mimeType: options.mimeType || inferContentType(absolutePath),
+    size: stat.size,
+  };
+}
+
+function promoteArtifactDescriptor(descriptor, artifactStore, userId) {
+  if (!artifactStore || userId == null || !descriptor?.path) {
+    return descriptor;
+  }
+  const extension = inferArtifactExtension(descriptor.path);
+  const allocation = artifactStore.allocateFile(userId, {
+    kind: descriptor.kind || inferArtifactKind(descriptor.path),
+    extension,
+    contentType: descriptor.mimeType || inferContentType(descriptor.path),
+    filenameBase: normalizeFilenameBase(descriptor.label || descriptor.kind || 'artifact', 'artifact'),
+    originalFilename: path.basename(descriptor.path),
+    metadata: {
+      sourceTool: 'integrated-media',
+      originalPath: descriptor.path,
+    },
+  });
+  fs.copyFileSync(descriptor.path, allocation.storagePath);
+  const finalized = artifactStore.finalizeFile(allocation.artifactId, allocation.storagePath);
+  return {
+    kind: descriptor.kind || inferArtifactKind(descriptor.path),
+    label: descriptor.label || path.basename(descriptor.path),
+    url: finalized.url,
+    mimeType: descriptor.mimeType || inferContentType(descriptor.path),
+    size: finalized.byteSize,
+  };
+}
+
+module.exports = {
+  copyAssetIntoJob,
+  createArtifactDescriptor,
+  createJobDir,
+  ensureDir,
+  ensureRepoNodeModulesLink,
+  normalizeFilenameBase,
+  promoteArtifactDescriptor,
+  resolveRepoBinary,
+  runCheckedCommand,
+  shellEscape,
+  writeJsonFile,
+  writeTextFile,
+};

package/server/services/ai/integrated_tools/slidev.js

@@ -0,0 +1,205 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const {
+  copyAssetIntoJob,
+  createArtifactDescriptor,
+  createJobDir,
+  ensureDir,
+  ensureRepoNodeModulesLink,
+  normalizeFilenameBase,
+  promoteArtifactDescriptor,
+  resolveRepoBinary,
+  runCheckedCommand,
+  shellEscape,
+  writeTextFile,
+} = require('./shared');
+
+const SLIDEV_BIN = resolveRepoBinary('slidev');
+const DEFAULT_EXPORT_FORMATS = ['pdf'];
+const ALLOWED_EXPORT_FORMATS = new Set(['pdf', 'pptx', 'png']);
+const ALLOWED_LAYOUTS = new Set(['cover', 'intro', 'statement', 'quote', 'section', 'two-cols', 'default']);
+
+function normalizeArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function normalizeExportFormats(value) {
+  const formats = normalizeArray(value)
+    .map((item) => String(item || '').trim().toLowerCase())
+    .filter((item) => ALLOWED_EXPORT_FORMATS.has(item));
+  return formats.length > 0 ? [...new Set(formats)] : [...DEFAULT_EXPORT_FORMATS];
+}
+
+function buildFrontmatter(args = {}) {
+  const lines = [
+    '---',
+    `theme: ${String(args.theme || 'default').trim() || 'default'}`,
+  ];
+  if (args.title) lines.push(`title: ${JSON.stringify(String(args.title).trim())}`);
+  if (args.subtitle) lines.push(`info: ${JSON.stringify(String(args.subtitle).trim())}`);
+  lines.push('layout: cover');
+  lines.push('transition: fade-out');
+  lines.push('mdc: true');
+  lines.push('---');
+  return lines.join('\n');
+}
+
+function materializeSlideAsset(value, assetsDir) {
+  if (!value) return '';
+  const text = String(value).trim();
+  if (!text) return '';
+  if (/^https?:\/\//i.test(text)) {
+    return text;
+  }
+  const asset = copyAssetIntoJob(text, assetsDir, 'slide-asset');
+  return `./assets/${asset.relativePath}`;
+}
+
+function buildStructuredDeckMarkdown(args, jobDir) {
+  const slides = normalizeArray(args.slides);
+  if (slides.length === 0) {
+    throw new Error('generate_slide_deck requires a non-empty slides array or deck_markdown.');
+  }
+  const assetsDir = ensureDir(path.join(jobDir, 'assets'));
+  const sections = [buildFrontmatter(args)];
+  const coverTitle = String(args.title || 'Presentation').trim();
+  const coverSubtitle = String(args.subtitle || '').trim();
+  sections.push(`# ${coverTitle}${coverSubtitle ? `\n\n${coverSubtitle}` : ''}`);
+
+  for (const slide of slides) {
+    const title = String(slide?.title || '').trim();
+    const layout = ALLOWED_LAYOUTS.has(String(slide?.layout || '').trim()) ? String(slide.layout).trim() : 'default';
+    const body = String(slide?.body || '').trim();
+    const notes = String(slide?.notes || '').trim();
+    const bullets = normalizeArray(slide?.bullets)
+      .map((item) => String(item || '').trim())
+      .filter(Boolean);
+    const imageRef = materializeSlideAsset(slide?.image_path || slide?.image_url, assetsDir);
+    const slideLines = ['---'];
+    if (layout !== 'default') slideLines.push(`layout: ${layout}`);
+    if (slide?.className) slideLines.push(`class: ${JSON.stringify(String(slide.className).trim())}`);
+    slideLines.push('---');
+    if (title) slideLines.push(`# ${title}`);
+    if (body) slideLines.push('', body);
+    if (bullets.length > 0) {
+      if (!body) slideLines.push('');
+      slideLines.push(...bullets.map((item) => `- ${item}`));
+    }
+    if (imageRef) {
+      slideLines.push('', `![](${imageRef})`);
+    }
+    if (notes) {
+      slideLines.push('', `<!--\n${notes}\n-->`);
+    }
+    sections.push(slideLines.join('\n'));
+  }
+
+  return `${sections.join('\n\n')}\n`;
+}
+
+function buildDeckMarkdown(args, jobDir) {
+  const rawMarkdown = String(args.deck_markdown || '').trim();
+  if (rawMarkdown) {
+    if (rawMarkdown.startsWith('---')) {
+      return `${rawMarkdown}\n`;
+    }
+    return `${buildFrontmatter(args)}\n\n${rawMarkdown}\n`;
+  }
+  return buildStructuredDeckMarkdown(args, jobDir);
+}
+
+function resolveExportPath(jobDir, filenameBase, format) {
+  if (format === 'png') {
+    return path.join(jobDir, `${filenameBase}-png`);
+  }
+  return path.join(jobDir, `${filenameBase}.${format}`);
+}
+
+function collectPngArtifacts(outputDir) {
+  if (!fs.existsSync(outputDir)) return [];
+  return fs.readdirSync(outputDir)
+    .filter((entry) => entry.toLowerCase().endsWith('.png'))
+    .sort()
+    .map((entry) => createArtifactDescriptor(path.join(outputDir, entry), {
+      kind: 'image',
+      label: entry,
+      mimeType: 'image/png',
+    }));
+}
+
+async function generateSlideDeck(args, context = {}) {
+  if (!fs.existsSync(SLIDEV_BIN)) {
+    throw new Error('Slidev CLI is not installed.');
+  }
+  const filenameBase = normalizeFilenameBase(args.filename_base || args.title || 'slide-deck', 'slide-deck');
+  const jobDir = createJobDir('slidev', filenameBase);
+  ensureRepoNodeModulesLink(jobDir);
+  const markdownPath = path.join(jobDir, `${filenameBase}.md`);
+  const exportFormats = normalizeExportFormats(args.export_formats);
+  const deckMarkdown = buildDeckMarkdown(args, jobDir);
+  writeTextFile(markdownPath, deckMarkdown);
+
+  const executor = context.cliExecutor;
+  const commandOutputs = [];
+  for (const format of exportFormats) {
+    const outputPath = resolveExportPath(jobDir, filenameBase, format);
+    const command = [
+      shellEscape(SLIDEV_BIN),
+      'export',
+      shellEscape(markdownPath),
+      '--format',
+      shellEscape(format),
+      '--output',
+      shellEscape(outputPath),
+    ].join(' ');
+    const result = await runCheckedCommand(executor, command, {
+      cwd: jobDir,
+      timeout: 15 * 60 * 1000,
+      errorPrefix: `Slidev export failed for ${format}.`,
+    });
+    commandOutputs.push({ format, result });
+  }
+
+  const descriptors = [
+    createArtifactDescriptor(markdownPath, {
+      kind: 'document',
+      label: path.basename(markdownPath),
+      mimeType: 'text/markdown',
+    }),
+  ];
+
+  for (const format of exportFormats) {
+    const outputPath = resolveExportPath(jobDir, filenameBase, format);
+    if (format === 'png') {
+      descriptors.push(...collectPngArtifacts(outputPath));
+      continue;
+    }
+    descriptors.push(createArtifactDescriptor(outputPath, {
+      kind: format === 'pptx' ? 'slides' : 'document',
+      label: path.basename(outputPath),
+    }));
+  }
+
+  const promotedArtifacts = descriptors.map((descriptor) => (
+    promoteArtifactDescriptor(descriptor, context.artifactStore, context.userId)
+  ));
+
+  return {
+    success: true,
+    tool: 'generate_slide_deck',
+    title: String(args.title || '').trim() || null,
+    exportFormats,
+    artifacts: promotedArtifacts,
+    message: `Generated slide deck with ${exportFormats.join(', ')} output.`,
+    logs: commandOutputs.map((item) => ({
+      format: item.format,
+      durationMs: item.result.durationMs,
+    })),
+  };
+}
+
+module.exports = {
+  generateSlideDeck,
+};

package/server/services/ai/tools.js

@@ -9,6 +9,10 @@ const {
     normalizeOutgoingMessageForPlatform,
 } = require('../messaging/formatting_guides');
 const { INTERIM_KINDS, normalizeInterimKind } = require('./interim');
+const {
+    executeIntegratedTool,
+    getIntegratedToolDefinitions,
+} = require('./integrated_tools');
 
 function compactText(text, maxChars = 120) {
     const str = String(text || '').replace(/\s+/g, ' ').trim();
@@ -1167,6 +1171,7 @@ function getAvailableTools(app, options = {}) {
                 required: ['prompt']
             }
         },
+        ...getIntegratedToolDefinitions(),
         {
             name: 'generate_table',
             description: 'Format data into a markdown table. The resulting markdown will be returned to you. You MUST include it in your next message to the user so they can see it.',
@@ -1391,6 +1396,7 @@ async function executeTool(toolName, args, context, engine) {
     const taskRuntime = () => app?.locals?.taskRuntime || engine.taskRuntime;
     const rec = () => app?.locals?.recordingManager || null;
     const widgets = () => app?.locals?.widgetService || null;
+    const artifactStore = app?.locals?.artifactStore || null;
 
     const integrationManager = integrations();
     if (integrationManager) {
@@ -1415,6 +1421,16 @@ async function executeTool(toolName, args, context, engine) {
         }
     }
 
+    const integratedToolResult = await executeIntegratedTool(toolName, args, {
+        userId,
+        agentId,
+        cliExecutor: app?.locals?.cliExecutor || engine.cliExecutor || null,
+        artifactStore,
+    });
+    if (integratedToolResult !== null) {
+        return integratedToolResult;
+    }
+
     switch (toolName) {
         case 'execute_command': {
             const runtimeManager = runtime();

package/server/services/manager.js

@@ -25,7 +25,7 @@ const { DesktopCompanionRegistry } = require('./desktop/registry');
 const { DesktopProvider } = require('./desktop/provider');
 const { ScreenRecorder } = require('./desktop/screenRecorder');
 const { WearableService } = require('./wearable/service');
-const { assertRuntimeValidation, getRuntimeValidation } = require('./runtime/validation');
+const { getRuntimeValidation } = require('./runtime/validation');
 const {
   getErrorMessage,
   runBackgroundTask,
@@ -487,8 +487,11 @@ async function startServices(app, io) {
     const browserController = createBrowserController(app, artifactStore);
     const androidController = createAndroidController(app, artifactStore);
     const runtimeManager = createRuntimeManager(app, cliExecutor);
-    registerLocal(app, 'runtimeValidation', getRuntimeValidation(runtimeManager));
-    assertRuntimeValidation(runtimeManager);
+    const runtimeValidation = getRuntimeValidation(runtimeManager);
+    registerLocal(app, 'runtimeValidation', runtimeValidation);
+    if (!runtimeValidation.ready) {
+      console.warn('[Services] Runtime validation is degraded:', runtimeValidation.issues.join(' '));
+    }
     const skillRunner = await createSkillRunner(app, cliExecutor, runtimeManager);
     const agentEngine = createAgentEngine(app, io, {
       cliExecutor,