@lightcone-ai/daemon 0.14.0 → 0.14.2

package/src/chat-bridge.js

@@ -2,9 +2,21 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
-import { readFileSync } from 'fs';
+import { createReadStream, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
 import { createHash, randomUUID } from 'crypto';
 import path, { extname } from 'path';
+import { homedir } from 'os';
+import {
+  concatVideos,
+  muxAudioToVideo,
+  probeDurationMs,
+  transcodeForPlatform,
+} from './_vendor/video/composer/index.js';
+import {
+  VIDEO_EXT,
+  VIDEO_MIME,
+  writeLocalFileToWorkspace,
+} from './workspace-file-upload.js';
 import { isLeaseInvalidated, clearInvalidatedLease } from './governance-state.js';
 import { classifyLeaseWindow } from './lease-window.js';
 
@@ -41,14 +53,9 @@ const BUNDLE_EVENT_FLUSH_MS = Number(process.env.GOVERNANCE_BUNDLE_FLUSH_MS ?? 2
 // Current active workspaceId for memory isolation (defaults to spawn-time WORKSPACE_ID)
 let currentWorkspaceId = WORKSPACE_ID;
 
-const WORKSPACE_BINARY_MIME = {
-  '.png': 'image/png',
-  '.jpg': 'image/jpeg',
-  '.jpeg': 'image/jpeg',
-  '.webp': 'image/webp',
-  '.gif': 'image/gif',
-  '.pdf': 'application/pdf',
-};
+const VOICEOVER_LOCAL_DIR = path.join(WORKSPACE_DIR, 'artifacts', 'audio');
+const VIDEO_COMPOSE_LOCAL_DIR = path.join(WORKSPACE_DIR, 'artifacts', 'video');
+const DEFAULT_OUTRO_PATH = path.join(homedir(), '.lightcone', 'assets', 'outros', 'default.mp4');
 
 function dataUrlSummary(content) {
   if (typeof content !== 'string' || !content.startsWith('data:')) return null;
@@ -73,6 +80,27 @@ function formatBytes(bytes) {
   return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
 }
 
+function normalizeVoiceFormat(value) {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (!normalized) return 'mp3';
+  if (['mp3', 'wav', 'flac'].includes(normalized)) return normalized;
+  return 'mp3';
+}
+
+function inferAudioExtension(url, format = 'mp3') {
+  const normalizedFormat = normalizeVoiceFormat(format);
+  if (typeof url === 'string' && url.trim()) {
+    try {
+      const pathname = new URL(url).pathname;
+      const ext = extname(pathname).toLowerCase();
+      if (ext && ['.mp3', '.wav', '.flac'].includes(ext)) return ext;
+    } catch {
+      // noop
+    }
+  }
+  return `.${normalizedFormat}`;
+}
+
 function isInsideDir(filePath, dir) {
   const rel = path.relative(dir, filePath);
   return rel === '' || (!!rel && !rel.startsWith('..') && !path.isAbsolute(rel));
@@ -88,6 +116,58 @@ function resolveLocalWorkspaceFile(filePath) {
   throw new Error(`Local file must be inside the agent workspace or workspace shared artifacts/notes/tmp directories. Got: ${filePath}`);
 }
 
+function normalizeComposePath(filePath, label) {
+  const normalized = String(filePath ?? '').trim();
+  if (!normalized) throw new Error(`${label} is required.`);
+  return path.resolve(WORKSPACE_DIR, normalized);
+}
+
+function normalizeComposeTarget(value) {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (!normalized) return 'short_video_cn';
+  if (['short_video_cn', 'douyin', 'xhs'].includes(normalized)) return normalized;
+  throw new Error(`Unsupported compose target: ${value}`);
+}
+
+function normalizeComposeAudioSegments(audioSegments) {
+  if (!Array.isArray(audioSegments) || audioSegments.length === 0) {
+    throw new Error('audio_segments must be a non-empty array.');
+  }
+
+  return audioSegments.map((segment, index) => {
+    if (!segment || typeof segment !== 'object' || Array.isArray(segment)) {
+      throw new Error(`audio_segments[${index}] must be an object.`);
+    }
+    const audioPath = normalizeComposePath(
+      segment.audio_path ?? segment.audioPath,
+      `audio_segments[${index}].audio_path`
+    );
+    const startMsRaw = segment.start_ms ?? segment.startMs;
+    const startMs = startMsRaw == null ? null : Number(startMsRaw);
+    if (startMsRaw != null && (!Number.isFinite(startMs) || startMs < 0)) {
+      throw new Error(`audio_segments[${index}].start_ms must be a non-negative number.`);
+    }
+    const phase = String(segment.phase ?? segment.phase_id ?? segment.phaseId ?? '').trim();
+    if (startMs == null && !phase) {
+      throw new Error(`audio_segments[${index}] requires start_ms, or provide phase with events_log.`);
+    }
+
+    const normalized = { audio_path: audioPath };
+    if (startMs != null) normalized.start_ms = Math.floor(startMs);
+    if (phase) normalized.phase = phase;
+    return {
+      ...normalized,
+    };
+  });
+}
+
+function cleanupLocalFiles(paths = []) {
+  for (const filePath of paths) {
+    if (!filePath) continue;
+    try { rmSync(filePath, { force: true }); } catch { /* noop */ }
+  }
+}
+
 const DEFAULT_TOOL_CLASSIFICATION = {
   check_messages: 'local',
   list_memory: 'local',
@@ -115,6 +195,8 @@ const DEFAULT_TOOL_CLASSIFICATION = {
   update_goal_field: 'mandatory',
   supersede_goal_field: 'mandatory',
   request_credential_auth: 'mandatory',
+  generate_voiceover: 'mandatory',
+  compose_video: 'mandatory',
   register_data_source: 'mandatory',
   bind_workspace_scenario: 'mandatory',
   create_workspace: 'mandatory',
@@ -248,6 +330,7 @@ function inferToolForApi(method, apiPath, body) {
   if (method === 'POST' && cleanPath === '/goal-fields/update') return 'update_goal_field';
   if (method === 'POST' && cleanPath === '/goal-fields/supersede') return 'supersede_goal_field';
   if (method === 'POST' && cleanPath === '/credential-auth/request') return 'request_credential_auth';
+  if (method === 'POST' && cleanPath === '/tts/voiceover') return 'generate_voiceover';
   if (method === 'POST' && cleanPath === '/api/data-sources') return 'register_data_source';
   if (method === 'POST' && cleanPath === '/orchestrate/decision') return 'write_governance_decision';
   if (method === 'POST' && cleanPath === '/orchestrate/correction') return 'write_governance_correction';
@@ -420,6 +503,32 @@ async function directApi(method, apiPath, body) {
   return res.json();
 }
 
+async function directApiVideoUpload(apiPath, {
+  localPath,
+  filename,
+  contentType = VIDEO_MIME,
+}) {
+  const url = `${SERVER_URL}/internal/agent/${AGENT_ID}${apiPath}`;
+  const headers = {
+    'Authorization': `Bearer ${MACHINE_API_KEY}`,
+    'Content-Type': contentType,
+  };
+  if (filename) headers['X-File-Name'] = filename;
+
+  const res = await fetch(url, {
+    method: 'POST',
+    headers,
+    body: createReadStream(localPath),
+    duplex: 'half',
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`API POST ${apiPath} → ${res.status}: ${text}`);
+  }
+  return res.json();
+}
+
 async function callGovernance(payload, { retry = true } = {}) {
   const attempts = retry ? 2 : 1;
   let lastError = null;
@@ -507,6 +616,61 @@ async function governanceRoundTrip({ method, apiPath, body, toolName, classifica
   return directApi(method, apiPath, nextBody);
 }
 
+async function runMandatoryLocalTool({ toolName, toolInput = {}, executor }) {
+  const classification = TOOL_CLASSIFICATION[toolName] ?? 'mandatory';
+  const traceId = randomUUID();
+  enqueueBundleEvent('tool_call_started', {
+    trace_id: traceId,
+    tool_name: toolName,
+    tool_classification: classification,
+    method: 'LOCAL',
+    api_path: '/local-tool',
+  });
+
+  try {
+    await ensureGovernanceContext();
+    const governancePayload = {
+      spawn_bundle_id: governanceContext.spawnBundleId,
+      policy_version: governanceContext.policyVersion,
+      tool_name: toolName,
+      tool_input: toolInput,
+      tool_classification: classification,
+      agent_id: AGENT_ID,
+      idempotency_key: randomUUID(),
+      lease_id: governanceContext.lease?.lease_id ?? null,
+    };
+    const governance = await callGovernance(governancePayload, { retry: true });
+    if (governance.policy_lease) applyPolicyLease(governance.policy_lease);
+    if (governance.verdict === 'reject' || governance.verdict === 'defer_human') {
+      throw governanceError(governanceReasonCode(governance.reason));
+    }
+
+    const checkedInput = (governance.verdict === 'modify' && governance.modified_input && typeof governance.modified_input === 'object')
+      ? { ...toolInput, ...governance.modified_input }
+      : toolInput;
+    const result = await executor(checkedInput);
+    if (CACHE_INVALIDATION_TOOLS.has(toolName)) {
+      governanceContext.cache.clear();
+    }
+
+    enqueueBundleEvent('tool_call_succeeded', {
+      trace_id: traceId,
+      tool_name: toolName,
+      tool_classification: classification,
+      source: 'governance_roundtrip',
+    });
+    return result;
+  } catch (error) {
+    enqueueBundleEvent('tool_call_failed', {
+      trace_id: traceId,
+      tool_name: toolName,
+      tool_classification: classification,
+      reason: error?.code ?? error?.message ?? 'unknown_error',
+    });
+    throw error;
+  }
+}
+
 function renewCacheInBackground({ method, apiPath, body, toolName, cacheKey }) {
   if (governanceContext.renewalInFlight.has(cacheKey)) return;
   governanceContext.renewalInFlight.add(cacheKey);
@@ -924,12 +1088,54 @@ server.tool('write_workspace_file', 'Write a local file directly to the shared w
 }, async ({ file_path, path }) => {
   if (!currentWorkspaceId) return { content: [{ type: 'text', text: 'No workspace context.' }] };
   const localPath = resolveLocalWorkspaceFile(file_path);
-  const ext = extname(path || localPath).toLowerCase();
-  const mime = WORKSPACE_BINARY_MIME[ext] ?? 'application/octet-stream';
-  const buf = readFileSync(localPath);
-  const content = `data:${mime};base64,${buf.toString('base64')}`;
-  await api('PUT', `/workspace-memory?path=${encodeURIComponent(path)}&workspaceId=${encodeURIComponent(currentWorkspaceId)}`, { content });
-  return { content: [{ type: 'text', text: `Saved local file to workspace: ${path} (${mime}, ${formatBytes(buf.length)})` }] };
+  const result = await writeLocalFileToWorkspace({
+    localPath,
+    workspacePath: path,
+    workspaceId: currentWorkspaceId,
+    readFileSyncFn: readFileSync,
+    uploadWorkspaceMemory: async ({ workspacePath, workspaceId, content }) => {
+      await api('PUT', `/workspace-memory?path=${encodeURIComponent(workspacePath)}&workspaceId=${encodeURIComponent(workspaceId)}`, { content });
+    },
+    uploadVideo: async ({
+      localPath: videoLocalPath,
+      workspacePath,
+      workspaceId,
+      filename,
+      mime,
+    }) => {
+      const uploadResult = await runMandatoryLocalTool({
+        toolName: 'write_workspace_file',
+        toolInput: {
+          file_path,
+          path: workspacePath,
+          upload_mode: 'upload_video',
+        },
+        executor: async () => directApiVideoUpload(
+          `/upload-video?workspaceId=${encodeURIComponent(workspaceId)}&filename=${encodeURIComponent(filename)}&path=${encodeURIComponent(workspacePath)}`,
+          {
+            localPath: videoLocalPath,
+            filename,
+            contentType: mime,
+          }
+        ),
+      });
+      return {
+        mode: 'upload-video',
+        mime: VIDEO_MIME,
+        bytes: Number(uploadResult?.sizeBytes) || 0,
+      };
+    },
+  });
+
+  const finalMime = result?.mime ?? (extname(path || localPath).toLowerCase() === VIDEO_EXT ? VIDEO_MIME : 'application/octet-stream');
+  const finalBytes = Number.isFinite(result?.bytes) ? result.bytes : 0;
+  const sizeText = finalBytes > 0 ? formatBytes(finalBytes) : 'unknown size';
+  return {
+    content: [{
+      type: 'text',
+      text: `Saved local file to workspace: ${path} (${finalMime}, ${sizeText})`,
+    }],
+  };
 });
 
 // ── skill_list ───────────────────────────────────────────────────────────────
@@ -1120,6 +1326,183 @@ server.tool('request_credential_auth',
   }
 );
 
+// ── generate_voiceover ─────────────────────────────────────────────────────────
+server.tool('generate_voiceover',
+  'Generate a TTS voiceover using an authorized tts_provider credential and return a local audio file path.',
+  {
+    workspace_id: z.string().optional().describe('Target workspace id. Defaults to current workspace context.'),
+    text: z.string().describe('Text content to synthesize.'),
+    voice_preset: z.string().optional().describe('Platform-neutral voice preset id, e.g. "warm_female_zh_01".'),
+    speed: z.number().optional().describe('Speech speed. Typical range is 0.5 to 2.0.'),
+    format: z.enum(['mp3', 'wav', 'flac']).optional().describe('Audio format. Defaults to mp3.'),
+    credential_id: z.string().optional().describe('Optional explicit credential id. If omitted, uses latest granted tts_provider credential.'),
+  },
+  async ({ workspace_id, text, voice_preset, speed, format, credential_id }) => {
+    const targetWorkspaceId = (workspace_id ?? currentWorkspaceId ?? WORKSPACE_ID ?? '').trim();
+    if (!targetWorkspaceId) {
+      return { isError: true, content: [{ type: 'text', text: 'workspace_id is required (no current workspace context).' }] };
+    }
+
+    const normalizedText = String(text ?? '').trim();
+    if (!normalizedText) {
+      return { isError: true, content: [{ type: 'text', text: 'text is required for generate_voiceover.' }] };
+    }
+
+    const normalizedSpeed = speed == null ? 1 : Number(speed);
+    if (!Number.isFinite(normalizedSpeed)) {
+      return { isError: true, content: [{ type: 'text', text: 'speed must be numeric.' }] };
+    }
+
+    const normalizedFormat = normalizeVoiceFormat(format);
+    const payload = {
+      workspace_id: targetWorkspaceId,
+      text: normalizedText,
+      speed: normalizedSpeed,
+      format: normalizedFormat,
+    };
+    if (voice_preset) payload.voice_preset = String(voice_preset).trim();
+    if (credential_id) payload.credential_id = String(credential_id).trim();
+
+    const data = await api('POST', '/tts/voiceover', payload);
+    const remoteAudioUrl = String(data.audio_url ?? '').trim();
+    if (!remoteAudioUrl) {
+      return { isError: true, content: [{ type: 'text', text: 'Voiceover API did not return audio_url.' }] };
+    }
+
+    const downloadRes = await fetch(remoteAudioUrl, {
+      method: 'GET',
+      headers: { 'Authorization': `Bearer ${MACHINE_API_KEY}` },
+    });
+    if (!downloadRes.ok) {
+      return {
+        isError: true,
+        content: [{ type: 'text', text: `Failed to download synthesized audio (${downloadRes.status})` }],
+      };
+    }
+
+    const fileBuffer = Buffer.from(await downloadRes.arrayBuffer());
+    mkdirSync(VOICEOVER_LOCAL_DIR, { recursive: true });
+    const audioExt = inferAudioExtension(remoteAudioUrl, data.format ?? normalizedFormat);
+    const localFileName = `voiceover-${Date.now()}-${randomUUID().slice(0, 8)}${audioExt}`;
+    const localAudioPath = path.join(VOICEOVER_LOCAL_DIR, localFileName);
+    writeFileSync(localAudioPath, fileBuffer);
+
+    return {
+      content: [{
+        type: 'text',
+        text:
+          `Voiceover generated.\n` +
+          `workspace_id=${data.workspace_id ?? targetWorkspaceId}\n` +
+          `local_audio_path=${localAudioPath}\n` +
+          `duration_ms=${data.duration_ms ?? 'unknown'}\n` +
+          `sample_rate=${data.sample_rate ?? 'unknown'}\n` +
+          `format=${data.format ?? normalizedFormat}\n` +
+          `size=${formatBytes(fileBuffer.length)}`,
+      }],
+    };
+  }
+);
+
+// ── compose_video ───────────────────────────────────────────────────────────────
+server.tool('compose_video',
+  'Compose a final short video by muxing audio onto a base video, optionally concatenating an outro, and transcoding to platform spec.',
+  {
+    video_path: z.string().describe('Base silent video path. Relative paths resolve from the current workspace.'),
+    audio_segments: z.array(z.object({
+      audio_path: z.string().describe('Audio file path for one narration segment.'),
+      start_ms: z.union([z.number(), z.string()]).optional().describe('Segment start offset in milliseconds.'),
+      phase: z.string().optional().describe('Optional phase id. Used with events_log to derive start time.'),
+    })).describe('Ordered or unordered narration audio segments.'),
+    events_log: z.array(z.any()).optional().describe('Optional recorder event log. Used to resolve segment start time by phase.'),
+    outro_path: z.string().optional().describe('Optional outro mp4 path. If omitted, uses ~/.lightcone/assets/outros/default.mp4 when present.'),
+    target: z.enum(['short_video_cn', 'douyin', 'xhs']).optional().describe('Transcode target profile. Defaults to short_video_cn.'),
+  },
+  async ({ video_path, audio_segments, events_log, outro_path, target }) => {
+    const composeInput = { video_path, audio_segments, events_log, outro_path, target };
+    try {
+      const result = await runMandatoryLocalTool({
+        toolName: 'compose_video',
+        toolInput: composeInput,
+        executor: async (checkedInput) => {
+          const videoPath = normalizeComposePath(checkedInput.video_path, 'video_path');
+          const audioSegments = normalizeComposeAudioSegments(checkedInput.audio_segments);
+          const eventsLog = Array.isArray(checkedInput.events_log) ? checkedInput.events_log : [];
+          const targetProfile = normalizeComposeTarget(checkedInput.target);
+          const requestedOutroPath = String(checkedInput.outro_path ?? '').trim();
+
+          let resolvedOutroPath = null;
+          if (requestedOutroPath) {
+            resolvedOutroPath = path.resolve(WORKSPACE_DIR, requestedOutroPath);
+            if (!existsSync(resolvedOutroPath)) {
+              throw new Error(`outro_path not found: ${resolvedOutroPath}`);
+            }
+          } else if (existsSync(DEFAULT_OUTRO_PATH)) {
+            resolvedOutroPath = DEFAULT_OUTRO_PATH;
+          }
+
+          mkdirSync(VIDEO_COMPOSE_LOCAL_DIR, { recursive: true });
+          const runId = `${Date.now()}-${randomUUID().slice(0, 8)}`;
+          const muxedPath = path.join(VIDEO_COMPOSE_LOCAL_DIR, `compose-${runId}.muxed.mp4`);
+          const concatPath = path.join(VIDEO_COMPOSE_LOCAL_DIR, `compose-${runId}.concat.mp4`);
+          const finalPath = path.join(VIDEO_COMPOSE_LOCAL_DIR, `compose-${runId}.final.mp4`);
+          const intermediates = [muxedPath, concatPath];
+
+          try {
+            await muxAudioToVideo({
+              video_path: videoPath,
+              audio_segments: audioSegments,
+              events_log: eventsLog,
+              output: muxedPath,
+            });
+
+            let composedPath = muxedPath;
+            if (resolvedOutroPath) {
+              await concatVideos({
+                inputs: [muxedPath, resolvedOutroPath],
+                output: concatPath,
+              });
+              composedPath = concatPath;
+            }
+
+            await transcodeForPlatform({
+              input: composedPath,
+              output: finalPath,
+              target: targetProfile,
+            });
+
+            const durationMs = await probeDurationMs(finalPath);
+            cleanupLocalFiles(intermediates);
+            return {
+              finalVideoPath: finalPath,
+              durationMs,
+              outroPath: resolvedOutroPath,
+              target: targetProfile,
+            };
+          } catch (error) {
+            cleanupLocalFiles([...intermediates, finalPath]);
+            throw error;
+          }
+        },
+      });
+
+      const outroText = result.outroPath ? result.outroPath : 'skipped';
+      return {
+        content: [{
+          type: 'text',
+          text:
+            `Video composed.\n` +
+            `final_video_path=${result.finalVideoPath}\n` +
+            `duration_ms=${result.durationMs}\n` +
+            `target=${result.target}\n` +
+            `outro=${outroText}`,
+        }],
+      };
+    } catch (error) {
+      return { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] };
+    }
+  }
+);
+
 // ── register_data_source ───────────────────────────────────────────────────────
 server.tool('register_data_source',
   'Register a workspace data source without binding credential yet. Returns a one-time secure auth URL (10-minute expiry) that should be sent to the user via IM.',
@@ -1197,6 +1580,15 @@ server.tool('execute_approved_action',
     try {
       const data = await api('POST', `/actions/${action_id}/execute`, {});
       if (data.error) return { isError: true, content: [{ type: 'text', text: `Failed: ${data.error}` }] };
+      if (data?.execution?.mode === 'user_daemon_job') {
+        return { content: [{ type: 'text', text:
+          `Action approved. Publish has been routed to a user-side daemon job.\n` +
+          `actionType=${data.actionType} platform=${data.platform}\n` +
+          `publish_job_id=${data.execution.publish_job_id} target_machine_id=${data.execution.target_machine_id}\n` +
+          `status=${data.execution.status}\n` +
+          `Do not call publish_content for this action_id again; wait for the daemon job result.`
+        }]};
+      }
       return { content: [{ type: 'text', text:
         `Action approved. Now call the appropriate platform tool with approval_action_id="${action_id}" to actually perform the operation.\n` +
         `actionType=${data.actionType} platform=${data.platform}\n` +

package/src/drivers/claude.js

@@ -5,7 +5,7 @@ const t = (name) => `mcp__chat__${name}`;
 // stable so server-built and daemon-built system prompts can both target it.
 export const WORKSPACE_CONTEXT_PLACEHOLDER = '__WORKSPACE_CONTEXT_BLOCK__';
 
-const BASE_PROMPT = (displayName, name, description, agentId, feishuBotName) => `\
+const BASE_PROMPT = (displayName, name, description, agentId, feishuBotName, workspaceDir = '', workspaceSharedDir = '') => `\
 You are "${displayName || name}", an AI agent in lightcone — a collaborative platform for human-AI collaboration.
 ${feishuBotName ? `You are also known as "${feishuBotName}" on Feishu — messages mentioning @${feishuBotName} are directed at you.\n` : ''}\
 
@@ -13,6 +13,13 @@ ${feishuBotName ? `You are also known as "${feishuBotName}" on Feishu — messag
 
 Your workspace and MEMORY.md persist across turns, so you can recover context when resumed. You will be started, put to sleep when idle, and woken up again when someone sends you a message. Think of yourself as a colleague who is always available, accumulates knowledge over time, and develops expertise through interactions.
 
+## Runtime paths
+
+- Personal workspace absolute path: ${workspaceDir || '(not provided)'}
+- Shared workspace absolute path: ${workspaceSharedDir || '(not provided)'}
+
+Treat these as authoritative. Do not invent substitute roots such as /home/agent/workspace unless they exactly match the paths above.
+
 ${WORKSPACE_CONTEXT_PLACEHOLDER}
 
 ## Communication — MCP tools ONLY
@@ -350,9 +357,9 @@ export function buildSystemPrompt(config, agentId, skills) {
   if (typeof config?.systemPrompt === 'string' && config.systemPrompt.trim()) {
     return config.systemPrompt;
   }
-  const { name, displayName, description, feishuBotName, rolePrompt } = config;
+  const { name, displayName, description, feishuBotName, rolePrompt, workspaceDir, workspaceSharedDir } = config;
 
-  const base = BASE_PROMPT(displayName, name, description, agentId, feishuBotName);
+  const base = BASE_PROMPT(displayName, name, description, agentId, feishuBotName, workspaceDir, workspaceSharedDir);
 
   const roleSection = rolePrompt
     ? `\n\n## Your role in this workspace\n\n${rolePrompt}`

package/src/mcp-config.js

@@ -69,6 +69,7 @@ function baseEnvForServer(serverKey, { serverUrl, authToken, agentId, workspaceI
     || serverKey === 'compliance-check'
     || serverKey === 'portfolio-read'
     || serverKey === 'portfolio-analysis'
+    || serverKey === 'video-narration-planner'
   ) {
     return {
       SERVER_URL: serverUrl,