@clipit-ai/cli 0.2.3 → 0.2.6

package/bin/clipit.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { createHash, randomBytes } from 'node:crypto';
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { createReadStream } from 'node:fs';
 import { Transform } from 'node:stream';
@@ -9,7 +9,7 @@ import path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 
-const VERSION = '0.2.3';
+const VERSION = '0.2.6';
 const DEFAULT_BASE_URL = 'https://clipit.dev';
 const DEFAULT_SCOPES = [
   'clippy_agent',
@@ -23,6 +23,7 @@ const DEFAULT_SCOPES = [
   'broll_generation',
   'audio_generation',
   'video_alteration',
+  'social_publishing',
 ];
 
 const GET_RETRY_DELAYS_MS = [500, 2000];
@@ -30,6 +31,25 @@ const RETRY_AFTER_CAP_MS = 10_000;
 const RETRYABLE_GET_STATUSES = new Set([429, 502, 503, 504]);
 const RECENT_LIMIT = 20;
 const REMOTION_ESTIMATED_USD_PER_VIDEO_SECOND = 0.0015;
+const BYTES_PER_GB = 1024 * 1024 * 1024;
+const VIDEO_UPLOAD_PART_CONCURRENCY = readPositiveIntegerEnv('CLIPIT_CLI_UPLOAD_CONCURRENCY', 4, 100);
+const VIDEO_UPLOAD_PART_ATTEMPTS = 3;
+const VIDEO_UPLOAD_PART_SIGN_BATCH = 100;
+const VIDEO_UPLOAD_STALL_TIMEOUT_MS = readPositiveIntegerEnv(
+  'CLIPIT_CLI_UPLOAD_STALL_TIMEOUT_MS',
+  60_000,
+  10 * 60_000,
+);
+const VIDEO_UPLOAD_RETRY_BASE_MS = readPositiveIntegerEnv(
+  'CLIPIT_CLI_UPLOAD_RETRY_BASE_MS',
+  1_000,
+  10_000,
+);
+const API_REQUEST_TIMEOUT_MS = readPositiveIntegerEnv(
+  'CLIPIT_CLI_REQUEST_TIMEOUT_MS',
+  60_000,
+  5 * 60_000,
+);
 const MAX_CREDITS_ESTIMATE_MAP = Object.freeze({
   'exports start': [{ operationType: 'lambda_render', provider: 'aws_lambda', modelId: 'remotion-4.0', metrics: 'remotion-render' }],
   'thumbnails generate': [{ operationType: 'thumbnail_generation', provider: 'replicate', modelId: 'openai/gpt-image-2', metrics: 'one-generation' }],
@@ -38,12 +58,151 @@ const MAX_CREDITS_ESTIMATE_MAP = Object.freeze({
     { operationType: 'image_generation', provider: 'replicate', modelId: 'openai/gpt-image-2', metrics: 'broll-images' },
     { operationType: 'video_generation', provider: 'replicate', modelId: 'alibaba/happyhorse-1.0', metrics: 'broll-video' },
   ],
+  'clips create': [{ operationType: 'clip', provider: 'deepgram', metrics: 'clip-create' }],
   'clips render': [{ operationType: 'lambda_render', provider: 'aws_lambda', modelId: 'remotion-4.0', metrics: 'remotion-render' }],
+  'videos upload': [{ operationType: 'video_storage', provider: 'railway_s3', metrics: 'video-upload-storage' }],
   'videos import-url': [{ operationType: null, provider: null, metrics: 'url-import' }],
+  'videos transcribe': [{ operationType: 'transcription', provider: 'deepgram', modelId: 'nova-3', metrics: 'transcription-video' }],
+  'videos suggest-clips': [{ operationType: 'ai_chat', provider: 'openrouter', modelId: 'x-ai/grok-4.20-beta', metrics: 'suggest-clips' }],
   'social post': [{ operationType: 'social_post', provider: 'zernio', metrics: 'social-platforms' }],
   'social schedule': [{ operationType: 'social_post', provider: 'zernio', metrics: 'social-platforms' }],
 });
 
+const REMOTION_RUN_ESTIMATE = MAX_CREDITS_ESTIMATE_MAP['clips render'];
+
+const RUN_MAX_CREDITS_ESTIMATE_MAP = Object.freeze({
+  planBRoll: MAX_CREDITS_ESTIMATE_MAP['broll plan'],
+  createThumbnail: MAX_CREDITS_ESTIMATE_MAP['thumbnails generate'],
+  generateThumbnails: MAX_CREDITS_ESTIMATE_MAP['thumbnails generate'],
+  generateImage: [{ operationType: 'image_generation', provider: 'replicate', modelId: 'openai/gpt-image-2', metrics: 'one-generation' }],
+  generateBRoll: MAX_CREDITS_ESTIMATE_MAP['broll generate'],
+  generateVoiceover: [{ operationType: 'tts_generation', provider: 'replicate', modelId: 'google/gemini-3.1-flash-tts', metrics: 'tts-provider-cost' }],
+  generateMusicBed: [{ operationType: 'music_generation', provider: 'replicate', modelId: 'minimax/music-2.5', metrics: 'one-generation' }],
+  generateVideoAlter: [{ operationType: 'video_alter_generation', provider: 'replicate', modelId: 'kwaivgi/kling-v3-omni-video', metrics: 'video-alter-provider-cost' }],
+  generatePlatformCaption: [{ operationType: 'ai_chat', provider: 'openrouter', modelId: 'anthropic/claude-opus-4.7', metrics: 'platform-caption' }],
+  applyHookToFront: REMOTION_RUN_ESTIMATE,
+  addLibraryAssetToClip: REMOTION_RUN_ESTIMATE,
+  renderClipWithRemotion: REMOTION_RUN_ESTIMATE,
+  updateClipBounds: REMOTION_RUN_ESTIMATE,
+  setCropPosition: REMOTION_RUN_ESTIMATE,
+  applyRemotionCaptionPreset: REMOTION_RUN_ESTIMATE,
+  setCaptionAnimation: REMOTION_RUN_ESTIMATE,
+  setClipAspectRatio: REMOTION_RUN_ESTIMATE,
+  setCropLayout: REMOTION_RUN_ESTIMATE,
+  setTimedCropLayouts: REMOTION_RUN_ESTIMATE,
+  applyCropPreset: REMOTION_RUN_ESTIMATE,
+  setWatermark: REMOTION_RUN_ESTIMATE,
+  applyTextOverlayToClip: REMOTION_RUN_ESTIMATE,
+  applyBRoll: REMOTION_RUN_ESTIMATE,
+  removeBRoll: REMOTION_RUN_ESTIMATE,
+});
+
+const RUN_CONFIRMATION_LABELS = Object.freeze({
+  renderClipWithRemotion: 'Rendering a clip',
+});
+
+const RUN_METERED_CONFIRMATION_EXEMPTIONS = new Set([
+  'planBRoll',
+  'planVideoAlter',
+  'planVoiceover',
+  'planMusicBed',
+]);
+
+const CLIP_IDS_CONTEXT_TOOLS = new Set([
+  'runDeliveryReadinessQA',
+  'runBlueprintExportQA',
+]);
+
+const BILLING_PROVIDER_PREFERENCES = new Set(['x402_direct', 'stripe_mpp', 'stripe_x402']);
+
+const LOCAL_MCP_BILLING_TOOLS = Object.freeze([
+  {
+    name: 'getPaymentCapabilities',
+    description: 'Discover ClipIt machine-payment capabilities, agent connection paths, safety policy, and direct x402, Stripe x402, or Stripe MPP rail readiness.',
+    costBand: 'free',
+    skill: 'billing',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'getBillingCatalog',
+    description: 'List ClipIt catalog products, prices, credit amounts, and enabled machine-payment rails.',
+    costBand: 'free',
+    skill: 'billing',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'createPaymentAttempt',
+    description: 'Create an API-key-owned machine-payment attempt and return the direct x402, Stripe x402, or Stripe MPP payment URL. This prepares a payment but does not sign a wallet transaction or supply a Stripe SPT credential.',
+    costBand: 'free',
+    skill: 'billing',
+    requiresConfirmation: true,
+    confirmation: {
+      required: true,
+      riskLevel: 'costly',
+      reason: 'Creates a payable billing attempt. Continue only after the human approved the product, amount, rail, and budget policy.',
+      actionLabel: 'create machine-payment attempt',
+      allowAutonomous: false,
+    },
+    inputSchema: {
+      type: 'object',
+      properties: {
+        productKey: { type: 'string' },
+        providerPreference: { type: 'string', enum: ['x402_direct', 'stripe_mpp', 'stripe_x402'] },
+        idempotencyKey: { type: 'string' },
+      },
+      required: ['productKey'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'getPaymentAttempt',
+    description: 'Get the status of an API-key-owned machine-payment attempt.',
+    costBand: 'free',
+    skill: 'billing',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        attemptId: { type: 'string' },
+      },
+      required: ['attemptId'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'getPaymentReceipt',
+    description: 'Get the receipt and fulfillment records for an API-key-owned machine-payment attempt.',
+    costBand: 'free',
+    skill: 'billing',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        attemptId: { type: 'string' },
+      },
+      required: ['attemptId'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'getBillingSubscription',
+    description: 'Get the effective ClipIt billing access source for the API key owner.',
+    costBand: 'free',
+    skill: 'billing',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+]);
+
 const EXIT = {
   OK: 0,
   USAGE: 2,
@@ -61,6 +220,17 @@ const KNOWN_AGENT_TARGETS = ['codex', 'claude', 'hermes', 'generic'];
 const TRUSTED_HOSTS = new Set(['clipit.dev', 'www.clipit.dev', 'localhost', '127.0.0.1', '::1', '[::1]']);
 const AGENT_SKILL_META_FILENAME = 'SKILL.meta.json';
 
+function readPositiveIntegerEnv(name, fallback, maximum = Number.MAX_SAFE_INTEGER) {
+  const parsed = Number(process.env[name]);
+  return Number.isFinite(parsed) && parsed > 0
+    ? Math.min(maximum, Math.max(1, Math.floor(parsed)))
+    : fallback;
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\"'\"'")}'`;
+}
+
 function configDir() {
   if (process.env.CLIPIT_CONFIG_DIR) return process.env.CLIPIT_CONFIG_DIR;
   if (process.platform === 'win32' && process.env.APPDATA) return path.join(process.env.APPDATA, 'ClipIt');
@@ -93,6 +263,7 @@ function legacyProfile(config) {
     baseUrl: config.baseUrl,
     apiKey: config.apiKey,
     keyInfo: config.keyInfo,
+    scope: config.scope,
     loginSource: config.loginSource,
     activeContext: config.activeContext,
     recent: config.recent,
@@ -106,6 +277,14 @@ function profileData(config, options) {
   return name === 'default' ? { ...legacyProfile(config), ...fromProfiles } : fromProfiles;
 }
 
+function profileIsAuthoritative(config, options) {
+  return Boolean(
+    options.profile
+    || process.env.CLIPIT_PROFILE
+    || (config.currentProfile && config.currentProfile !== 'default'),
+  );
+}
+
 function updateProfile(config, options, updates) {
   const name = profileName(config, options);
   const profiles = { ...(config.profiles || {}) };
@@ -146,6 +325,32 @@ function appendRecentEntries(config, options, entries) {
   return entries.reduce((nextConfig, entry) => appendRecentEntry(nextConfig, options, entry.type, entry.id), config);
 }
 
+function withProfileActiveContext(config, options, activeContext) {
+  const name = profileName(config, options);
+  const profiles = { ...(config.profiles || {}) };
+  profiles[name] = {
+    ...profileData(config, options),
+    activeContext,
+  };
+
+  const next = {
+    ...config,
+    profiles,
+  };
+
+  if (name === 'default') {
+    next.activeContext = activeContext;
+  }
+
+  return next;
+}
+
+async function persistActiveContext(config, options, activeContext, recent = []) {
+  let next = updateProfile(config, options, { activeContext: compactObject({ ...activeContext }) });
+  next = appendRecentEntries(next, options, recent);
+  await writeConfig(next);
+}
+
 function removeProfileFields(config, options, fields) {
   const name = profileName(config, options);
   const profiles = { ...(config.profiles || {}) };
@@ -201,21 +406,26 @@ function wantJson(options) {
 function redact(value) {
   if (typeof value !== 'string') return value;
   return value
+    .replace(/https?:\/\/(?=[^\s"'<>]*[?&](?:X-Amz-|Signature=|token=|key=))[^\s"'<>]+/gi, '[signed-url-redacted]')
+    .replace(/https?:\/\/replicate\.delivery\/[^\s"'<>]+/gi, '[generated-media-url-redacted]')
+    .replace(/https?:\/\/stream\.replicate\.com\/v1\/files\/[^\s"'<>]+/gi, '[generated-media-url-redacted]')
+    .replace(/(^|[\s"'=:(,])\/objects\/[^\s"'<>),]+/g, '$1[object-url-redacted]')
     .replace(/clipper_[a-f0-9]{24,}/gi, 'clipper_[redacted]')
     .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/g, 'Bearer [redacted]')
-    .replace(/([?&](?:X-Amz-Signature|Signature|token|key)=)[^&\s]+/gi, '$1[redacted]');
+    .replace(/([?&](?:X-Amz-[A-Za-z-]+|Signature|token|key)=)[^&\s]+/gi, '$1[redacted]');
 }
 
 function output(data, options) {
+  const safeData = redactDeep(data);
   if (wantJson(options)) {
-    console.log(JSON.stringify(data, null, 2));
+    console.log(JSON.stringify(safeData, null, 2));
     return;
   }
-  if (typeof data === 'string') {
-    console.log(data);
+  if (typeof safeData === 'string') {
+    console.log(safeData);
     return;
   }
-  console.log(JSON.stringify(data, null, 2));
+  console.log(JSON.stringify(safeData, null, 2));
 }
 
 function redactDeep(value) {
@@ -227,6 +437,10 @@ function redactDeep(value) {
   return value;
 }
 
+function hashText(value) {
+  return createHash('sha256').update(String(value)).digest('hex');
+}
+
 function usage() {
   return [
     'ClipIt CLI',
@@ -240,19 +454,22 @@ function usage() {
     '  clipit auth status [--json]',
     '  clipit auth set-key --stdin',
     '  clipit auth profiles',
+    '  clipit auth use <profile>',
     '  clipit context use [--video-id id] [--clip-id id] [--project-id id] [--sequence-id id]',
     '  clipit context show|clear|build [--json]',
     '  clipit skills list [--json]',
     '  clipit tools list [--skill clip] [--json]',
     '  clipit tools describe <functionName>',
-    '  clipit ask "<prompt>" [--video-id id] [--clip-id id] [--conversation-id id] [--quick] [--stream] [--json]',
+    '  clipit ask "<prompt>" [--video-id id] [--clip-id id] [--conversation-id id] [--quick] [--auto-confirm-costly] [--stream] [--json]',
     '  clipit workflow status|wait <jobId> [--stream] [--json]',
     '  clipit workflow approve <jobId> --approval-id id [--decision approved|cheaper|cancelled]',
+    '  clipit mcp [stdio]',
     '  clipit run <functionName> [--params @file.json] [--clip-id id] [--video-id id] [--confirm] [--max-credits n]',
-    '  clipit videos list|get|upload|import-url|transcribe|transcript|suggest-clips|delete ...',
-    '  clipit clips list|get|create|update|render|download|delete ...',
+    '  clipit videos list|get|upload|abort-upload|import-url|transcribe|transcript|suggest-clips|delete ...',
+    '  clipit clips list|get|delivery-state|create|update|render|download|delete ...',
     '  clipit jobs get|wait <jobId>',
     '  clipit credits balance|usage|estimate ...',
+    '  clipit billing capabilities|catalog|create-attempt|attempt|receipt|subscription ...',
     '  clipit analytics overview|top-clips|post ...',
     '  clipit exports start|list|get|wait|download|cancel ...',
     '  clipit assets list|upload|delete ...',
@@ -268,12 +485,36 @@ function usage() {
 
 function getBaseUrl(config, options) {
   const profile = profileData(config, options);
-  return String(options['base-url'] || process.env.CLIPPER_BASE_URL || profile.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+  const selected = profileIsAuthoritative(config, options);
+  return String(
+    options['base-url']
+    || (selected ? profile.baseUrl : process.env.CLIPPER_BASE_URL)
+    || profile.baseUrl
+    || (!selected ? process.env.CLIPPER_BASE_URL : undefined)
+    || DEFAULT_BASE_URL,
+  ).replace(/\/+$/, '');
 }
 
-function getApiKey(config, options) {
+function resolveApiCredential(config, options) {
   const profile = profileData(config, options);
-  return process.env.CLIPPER_API_KEY || options['api-key'] || profile.apiKey || null;
+  if (typeof options['api-key'] === 'string' && options['api-key'].trim()) {
+    return { apiKey: options['api-key'].trim(), source: 'argument' };
+  }
+  if (profileIsAuthoritative(config, options)) {
+    return profile.apiKey
+      ? { apiKey: profile.apiKey, source: 'profile' }
+      : { apiKey: null, source: 'missing' };
+  }
+  if (process.env.CLIPPER_API_KEY) {
+    return { apiKey: process.env.CLIPPER_API_KEY, source: 'environment' };
+  }
+  return profile.apiKey
+    ? { apiKey: profile.apiKey, source: 'profile' }
+    : { apiKey: null, source: 'missing' };
+}
+
+function getApiKey(config, options) {
+  return resolveApiCredential(config, options).apiKey;
 }
 
 async function readStdin() {
@@ -282,6 +523,97 @@ async function readStdin() {
   return Buffer.concat(chunks).toString('utf8');
 }
 
+async function readSecretLine(input = process.stdin, promptOutput = process.stderr) {
+  if (!input.isTTY || typeof input.setRawMode !== 'function') {
+    return new Promise((resolve, reject) => {
+      let value = '';
+      let settled = false;
+      const cleanup = () => {
+        input.off('data', onData);
+        input.off('end', onEnd);
+        input.off('error', onError);
+      };
+      const finish = (result) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        input.pause?.();
+        resolve(result);
+      };
+      const onData = (chunk) => {
+        value += Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk);
+        const newline = value.search(/[\r\n]/);
+        if (newline !== -1) finish(value.slice(0, newline));
+      };
+      const onEnd = () => finish(value);
+      const onError = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(error);
+      };
+      input.on('data', onData);
+      input.once('end', onEnd);
+      input.once('error', onError);
+      input.resume?.();
+    });
+  }
+
+  return new Promise((resolve, reject) => {
+    let value = '';
+    let settled = false;
+    const wasRaw = Boolean(input.isRaw);
+    const wasPaused = input.isPaused?.() ?? false;
+    const cleanup = () => {
+      input.off('data', onData);
+      input.off('end', onEnd);
+      input.off('error', onError);
+      input.setRawMode(wasRaw);
+      if (wasPaused) input.pause?.();
+      promptOutput.write('\n');
+    };
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(value);
+    };
+    const onData = (chunk) => {
+      for (const character of (Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk))) {
+        if (character === '\u0003') {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          reject(Object.assign(new Error('API key entry cancelled.'), { exitCode: 130 }));
+          return;
+        }
+        if (character === '\r' || character === '\n' || character === '\u0004') {
+          finish();
+          return;
+        }
+        if (character === '\u007f' || character === '\b') {
+          value = value.slice(0, -1);
+          continue;
+        }
+        if (character >= ' ') value += character;
+      }
+    };
+    const onEnd = () => finish();
+    const onError = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    promptOutput.write('API key: ');
+    input.setRawMode(true);
+    input.on('data', onData);
+    input.once('end', onEnd);
+    input.once('error', onError);
+    input.resume?.();
+  });
+}
+
 function boolOption(value) {
   return value === true || value === 'true' || value === '1' || value === 'yes';
 }
@@ -398,39 +730,67 @@ async function apiFetch(config, options, method, endpoint, body, extra = {}) {
   };
   const isFormData = typeof FormData !== 'undefined' && body instanceof FormData;
   if (body !== undefined && !isFormData && !extra.rawBody) headers['Content-Type'] = 'application/json';
-  const apiKey = extra.noAuth ? null : getApiKey(config, options);
+  const apiKey = extra.noAuth
+    ? null
+    : extra.authApiKey !== undefined
+      ? extra.authApiKey
+      : getApiKey(config, options);
   if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
 
   let response;
+  let responseTimeout;
   for (let attempt = 0; attempt <= GET_RETRY_DELAYS_MS.length; attempt++) {
+    const controller = new AbortController();
+    const timeoutMs = Math.min(
+      readPositiveIntegerEnv('CLIPIT_CLI_REQUEST_TIMEOUT_MS', API_REQUEST_TIMEOUT_MS, 5 * 60_000),
+      5 * 60_000,
+    );
+    const timeout = setTimeout(() => {
+      controller.abort(new Error(`ClipIt API request timed out after ${timeoutMs} ms`));
+    }, timeoutMs);
+    timeout.unref?.();
     try {
       const request = {
         method: methodName,
         headers,
         body: body === undefined ? undefined : extra.rawBody ? body : isFormData ? body : JSON.stringify(body),
+        signal: controller.signal,
       };
       if (extra.rawBody && body !== undefined) {
         request.duplex = 'half';
       }
       response = await fetch(`${baseUrl}${endpoint}`, request);
     } catch (error) {
+      clearTimeout(timeout);
       if (canRetry && attempt < GET_RETRY_DELAYS_MS.length) {
         await sleep(GET_RETRY_DELAYS_MS[attempt]);
         continue;
       }
-      throw Object.assign(new Error(`Network error: ${error.message}`), { exitCode: EXIT.NETWORK });
+      const reason = controller.signal.aborted && controller.signal.reason instanceof Error
+        ? controller.signal.reason
+        : error;
+      throw Object.assign(new Error(`Network error: ${reason.message}`), { exitCode: EXIT.NETWORK });
     }
 
     if (canRetry && RETRYABLE_GET_STATUSES.has(response.status) && attempt < GET_RETRY_DELAYS_MS.length) {
       await response.arrayBuffer().catch(() => undefined);
+      clearTimeout(timeout);
       await sleep(retryDelayMs(response, attempt));
       continue;
     }
+    responseTimeout = timeout;
     break;
   }
 
   const requestId = response.headers.get('x-request-id') || response.headers.get('X-Request-Id') || undefined;
-  const text = await response.text();
+  let text;
+  try {
+    text = await response.text();
+  } catch (error) {
+    throw Object.assign(new Error(`Network error: ${error.message}`), { exitCode: EXIT.NETWORK });
+  } finally {
+    if (responseTimeout) clearTimeout(responseTimeout);
+  }
   let data = null;
   if (text.trim()) {
     try {
@@ -455,6 +815,13 @@ async function apiFetch(config, options, method, endpoint, body, extra = {}) {
       requestId,
     });
   }
+  if (extra.includeResponseMetadata) {
+    return {
+      data,
+      status: response.status,
+      headers: Object.fromEntries(response.headers.entries()),
+    };
+  }
   return data;
 }
 
@@ -486,7 +853,11 @@ function maxCreditsLimit(options) {
 }
 
 function clipCostLabel(value) {
-  return `${Number(value).toFixed(2).replace(/\.00$/, '')} $CLIP`;
+  const amount = Number(value);
+  if (!Number.isFinite(amount)) return `${value} $CLIP`;
+  if (amount === 0) return '0 $CLIP';
+  const fixed = amount.toFixed(Math.abs(amount) < 0.01 ? 5 : 2).replace(/\.?0+$/, '');
+  return `${fixed} $CLIP`;
 }
 
 const SPEND_LIMIT_EXCEEDED_MESSAGE = 'Spend limit exceeded for this API key \u2014 raise the key\'s spend limit in ClipIt Settings or use a different key.';
@@ -518,6 +889,20 @@ function warnIfEstimateUnaffordable(estimates) {
   }
 }
 
+function summarizeRunEstimates(estimates) {
+  if (!Array.isArray(estimates) || !estimates.length) return null;
+  const estimatedCostClip = estimates.reduce((sum, estimate) => {
+    const value = Number(estimate?.estimatedCostClip ?? 0);
+    return sum + (Number.isFinite(value) ? value : 0);
+  }, 0);
+  return {
+    estimatedCostClip,
+    estimatedCostLabel: clipCostLabel(estimatedCostClip),
+    affordable: estimates.every((estimate) => estimate?.affordable !== false),
+    estimates,
+  };
+}
+
 function throwSpendLimitExceeded(commandKey, spendLimitViolation, estimates) {
   throw Object.assign(new Error(SPEND_LIMIT_EXCEEDED_MESSAGE), {
     exitCode: EXIT.CREDITS,
@@ -548,11 +933,52 @@ function remotionProviderCostUsd(durationSeconds, quality) {
   return Math.max(0, durationSeconds * REMOTION_ESTIMATED_USD_PER_VIDEO_SECOND * qualityMultiplier(quality));
 }
 
+function normalizeCreditEstimateRequest(request) {
+  if (
+    request.operationType === 'lambda_render'
+    && (request.provider === 'aws_lambda' || request.provider === 'remotion')
+    && request.metrics
+    && typeof request.metrics.videoSeconds === 'number'
+    && typeof request.metrics.providerCostUsd !== 'number'
+  ) {
+    return {
+      ...request,
+      metrics: {
+        ...request.metrics,
+        providerCostUsd: remotionProviderCostUsd(request.metrics.videoSeconds, 'high'),
+      },
+    };
+  }
+
+  return request;
+}
+
 function brollVideoProviderCostUsd(durationSeconds, resolution) {
   const perSecondUsd = resolution === '1080p' ? 0.28 : 0.14;
   return Math.max(0, durationSeconds * perSecondUsd);
 }
 
+function brollImageProviderCostUsd(quality) {
+  if (quality === 'low') return 0.012;
+  if (quality === 'medium') return 0.047;
+  return 0.128;
+}
+
+function ttsProviderCostUsd(text, prompt) {
+  const textBytes = Buffer.byteLength(String(text || ''), 'utf8');
+  const promptBytes = Buffer.byteLength(String(prompt || 'Say the following.'), 'utf8');
+  const estimatedInputTokens = Math.ceil((textBytes + promptBytes) / 4);
+  const estimatedOutputTokens = Math.ceil(textBytes / 3);
+  return (estimatedInputTokens / 1_000_000) * 2 + (estimatedOutputTokens / 1_000) * 0.04;
+}
+
+function videoAlterProviderCostUsd(durationSeconds, mode) {
+  const perSecond = mode === 'pro'
+    ? Number(process.env.KLING_OMNI_PRO_COST_PER_SECOND_USD ?? '0.56')
+    : Number(process.env.KLING_OMNI_STANDARD_COST_PER_SECOND_USD ?? '0.28');
+  return Math.max(0, durationSeconds * (Number.isFinite(perSecond) ? perSecond : 0.28));
+}
+
 function durationFromClip(clip, body = {}) {
   const bodyStart = Number(body.startTime);
   const bodyEnd = Number(body.endTime);
@@ -571,15 +997,6 @@ async function fetchClipForEstimate(config, options, clipId) {
   return apiFetch(config, options, 'GET', `/api/v1/clips/${encodeURIComponent(clipId)}`);
 }
 
-function progressTransform(progress) {
-  return new Transform({
-    transform(chunk, encoding, callback) {
-      progress.track(chunk);
-      callback(null, chunk);
-    },
-  });
-}
-
 async function buildMaxCreditsEstimateRequest(config, options, spec, context = {}) {
   if (spec.metrics === 'url-import') {
     const youtube = isYoutubeUrl(requiredString(context.url, 'URL'));
@@ -594,17 +1011,57 @@ async function buildMaxCreditsEstimateRequest(config, options, spec, context = {
     return { ...spec, metrics: { generationCount: 1 } };
   }
 
+  if (spec.metrics === 'tts-provider-cost') {
+    const text = requiredString(context.body?.text, 'text');
+    return { ...spec, metrics: { providerCostUsd: ttsProviderCostUsd(text, context.body?.prompt) } };
+  }
+
   if (spec.metrics === 'broll-plan') {
     return { ...spec, metrics: { inputTokens: 4000, outputTokens: 1000 } };
   }
 
+  if (spec.metrics === 'platform-caption') {
+    return { ...spec, metrics: { inputTokens: 1500, outputTokens: 600, totalTokens: 2100 } };
+  }
+
+  if (spec.metrics === 'suggest-clips') {
+    return { ...spec, metrics: { inputTokens: 40000, outputTokens: 10000, totalTokens: 50000 } };
+  }
+
+  if (spec.metrics === 'clip-create') {
+    const audioSeconds = durationFromClip(context.body, context.body);
+    if (!Number.isFinite(audioSeconds) || audioSeconds <= 0) return null;
+    return { ...spec, metrics: { audioSeconds } };
+  }
+
+  if (spec.metrics === 'transcription-video') {
+    const videoId = requiredString(context.videoId, 'Video id');
+    const video = context.video || await apiFetch(config, options, 'GET', `/api/v1/videos/${encodeURIComponent(videoId)}`);
+    const audioSeconds = Number(video?.durationSeconds ?? video?.duration);
+    if (!Number.isFinite(audioSeconds) || audioSeconds <= 0) return null;
+    return { ...spec, metrics: { audioSeconds } };
+  }
+
+  if (spec.metrics === 'video-upload-storage') {
+    const bytes = Number(context.bytes);
+    if (!Number.isFinite(bytes) || bytes <= 0) return null;
+    return { ...spec, metrics: { generationCount: bytes / BYTES_PER_GB } };
+  }
+
   if (spec.metrics === 'broll-images') {
     const mode = context.body?.mode || 'single_image';
-    return { ...spec, metrics: { generationCount: mode === 'start_end_frame' ? 3 : 1 } };
+    const generationCount = mode === 'start_end_frame' ? 3 : 1;
+    return {
+      ...spec,
+      metrics: {
+        generationCount,
+        providerCostUsd: brollImageProviderCostUsd(context.body?.imageQuality) * generationCount,
+      },
+    };
   }
 
   if (spec.metrics === 'broll-video') {
-    const durationSeconds = Number(context.body?.durationSeconds ?? 6);
+    const durationSeconds = Number(context.body?.durationSeconds ?? context.body?.duration ?? 6);
     const resolution = context.body?.resolution || '720p';
     if (!Number.isFinite(durationSeconds) || durationSeconds <= 0) return null;
     return {
@@ -616,6 +1073,21 @@ async function buildMaxCreditsEstimateRequest(config, options, spec, context = {
     };
   }
 
+  if (spec.metrics === 'video-alter-provider-cost') {
+    const durationSeconds = Number(
+      context.body?.duration
+        ?? (Number(context.body?.sourceEnd) - Number(context.body?.sourceStart)),
+    );
+    if (!Number.isFinite(durationSeconds) || durationSeconds < 3 || durationSeconds > 10) return null;
+    return {
+      ...spec,
+      metrics: {
+        videoSeconds: durationSeconds,
+        providerCostUsd: videoAlterProviderCostUsd(durationSeconds, context.body?.mode),
+      },
+    };
+  }
+
   if (spec.metrics === 'social-platforms') {
     const platforms = Array.isArray(context.body?.platforms) ? context.body.platforms : [];
     if (!platforms.length) return null;
@@ -640,8 +1112,70 @@ async function buildMaxCreditsEstimateRequest(config, options, spec, context = {
   return null;
 }
 
+async function buildStaticRunEstimates(config, options, functionName, parameters, payload) {
+  const specs = RUN_MAX_CREDITS_ESTIMATE_MAP[functionName];
+  if (!specs) return null;
+
+  const body = parameters && typeof parameters === 'object' && !Array.isArray(parameters) ? parameters : {};
+  const requests = [];
+  for (const spec of specs) {
+    const request = await buildMaxCreditsEstimateRequest(config, options, spec, {
+      body,
+      clipId: payload?.clipId || body.clipId,
+      videoId: payload?.videoId || body.videoId,
+    });
+    if (!request) return null;
+    requests.push(compactObject({
+      operationType: request.operationType,
+      provider: request.provider,
+      modelId: request.modelId,
+      metrics: request.metrics,
+    }));
+  }
+
+  const estimates = [];
+  for (const request of requests) {
+    const estimate = await apiFetch(config, options, 'POST', '/api/v1/credits/estimate', request);
+    estimates.push({
+      operationType: request.operationType,
+      provider: request.provider,
+      modelId: request.modelId,
+      estimatedCostClip: Number(estimate?.estimatedCostClip ?? 0),
+      affordable: estimate?.affordable,
+      spendLimitViolation: estimate?.spendLimitViolation ?? null,
+    });
+  }
+
+  return estimates;
+}
+
+function currentInvocationWantsJson() {
+  return process.argv.some((arg) => arg === '--json' || arg === '--json=true');
+}
+
 function printEstimateUnavailable(commandKey) {
-  console.error(`estimate unavailable for ${commandKey}; --confirm is required.`);
+  if (!currentInvocationWantsJson()) {
+    console.error(`estimate unavailable for ${commandKey}; --confirm is required.`);
+  }
+}
+
+function throwMaxCreditsEstimateUnavailable(commandKey) {
+  if (!currentInvocationWantsJson()) {
+    console.error(`estimate unavailable for ${commandKey}; --max-credits cannot be enforced.`);
+  }
+  throw Object.assign(
+    new Error(`Cannot enforce --max-credits for ${commandKey} because no cost estimate is available.`),
+    { exitCode: EXIT.CONFIRMATION },
+  );
+}
+
+function estimatedClipCostFromData(data) {
+  if (!data || typeof data !== 'object') return null;
+  for (const key of ['estimatedCostClip', 'totalEstimatedCostClip', 'costClip', 'totalCostClip']) {
+    const value = Number(data[key]);
+    if (Number.isFinite(value)) return value;
+  }
+  return null;
 }
 
 async function enforceMaxCredits(config, options, commandKey, context = {}) {
@@ -705,20 +1239,119 @@ async function enforceMaxCredits(config, options, commandKey, context = {}) {
   }
 }
 
-async function enforceRunMaxCredits(config, options, functionName) {
-  if (maxCreditsLimit(options) === null) return;
+async function enforceRunMaxCredits(config, options, functionName, parameters = {}, payload = {}) {
+  const limit = maxCreditsLimit(options);
+  const needsConfirmationPreflight = !boolOption(options.confirm);
+  if (limit === null && !needsConfirmationPreflight) return null;
+
   const catalog = await apiFetch(config, options, 'GET', '/api/v1/agent/tools');
   const tools = Array.isArray(catalog?.tools) ? catalog.tools : Array.isArray(catalog) ? catalog : [];
   const tool = tools.find((item) => item.name === functionName);
   const runEstimate = tool?.estimate ?? tool?.confirmation?.estimate ?? tool?.confirmation?.costEstimate ?? null;
+  const isMetered = Boolean(tool?.costBand && tool.costBand !== 'free');
+  const isMeteredExempt = RUN_METERED_CONFIRMATION_EXEMPTIONS.has(functionName);
+
+  let staticEstimates = null;
+  if (!runEstimate && (limit !== null || needsConfirmationPreflight)) {
+    staticEstimates = await buildStaticRunEstimates(config, options, functionName, parameters, payload);
+  }
+
+  if (limit === null) {
+    const estimates = staticEstimates || (runEstimate ? [runEstimate] : null);
+    const estimateSummary = summarizeRunEstimates(estimates);
+    if (estimateSummary && (tool?.confirmation?.required || (isMetered && !isMeteredExempt))) {
+      warnIfEstimateUnaffordable(estimates);
+      throw Object.assign(
+        new Error(`Estimated cost ${estimateSummary.estimatedCostLabel} for run ${functionName}; --confirm is required.`),
+        {
+          exitCode: EXIT.CONFIRMATION,
+          data: {
+            command: `run ${functionName}`,
+            estimate: estimateSummary,
+          },
+        },
+      );
+    }
+    if (tool?.confirmation?.required) {
+      if (isMetered) printEstimateUnavailable(`run ${functionName}`);
+      requireConfirm(options, `Running confirmation-gated tool ${functionName}`);
+      return;
+    }
+    if (isMetered && !isMeteredExempt) {
+      printEstimateUnavailable(`run ${functionName}`);
+      requireConfirm(options, `Running metered tool ${functionName}`);
+      return;
+    }
+    return null;
+  }
+
+  if (staticEstimates) {
+    const spendLimitViolation = staticEstimates.find((estimate) => estimate.spendLimitViolation)?.spendLimitViolation;
+    if (spendLimitViolation) throwSpendLimitExceeded(`run ${functionName}`, spendLimitViolation, staticEstimates);
+    warnIfEstimateUnaffordable(staticEstimates);
+
+    const estimatedCostClip = staticEstimates.reduce((sum, estimate) => sum + estimate.estimatedCostClip, 0);
+    if (estimatedCostClip > limit) {
+      throw Object.assign(
+        new Error(`Estimated cost ${clipCostLabel(estimatedCostClip)} exceeds --max-credits ${clipCostLabel(limit)} for run ${functionName}.`),
+        {
+          exitCode: EXIT.CONFIRMATION,
+          data: {
+            command: `run ${functionName}`,
+            maxCredits: limit,
+            estimatedCostClip,
+            estimates: staticEstimates,
+          },
+        },
+      );
+    }
+    if (tool?.confirmation?.required || (isMetered && !isMeteredExempt)) {
+      requireConfirm(
+        options,
+        tool?.confirmation?.required ? `Running confirmation-gated tool ${functionName}` : `Running metered tool ${functionName}`,
+      );
+    }
+    return summarizeRunEstimates(staticEstimates);
+  }
+
   const spendLimitViolation = spendLimitViolationFromData(runEstimate) ?? spendLimitViolationFromData(tool?.confirmation);
   if (spendLimitViolation) throwSpendLimitExceeded(`run ${functionName}`, spendLimitViolation, runEstimate ? [runEstimate] : []);
   if (runEstimate?.affordable === false || tool?.confirmation?.affordable === false) {
     console.error('Warning: estimated cost exceeds your current balance.');
   }
-  if (!tool?.confirmation?.required) return;
-  printEstimateUnavailable(`run ${functionName}`);
-  requireConfirm(options, `Running confirmation-gated tool ${functionName}`);
+  if (!runEstimate && isMetered && !isMeteredExempt) {
+    throwMaxCreditsEstimateUnavailable(`run ${functionName}`);
+  }
+  if (!runEstimate && tool?.confirmation?.required) {
+    throwMaxCreditsEstimateUnavailable(`run ${functionName}`);
+  }
+  if (runEstimate) {
+    const estimatedCostClip = estimatedClipCostFromData(runEstimate);
+    if (estimatedCostClip === null) {
+      throwMaxCreditsEstimateUnavailable(`run ${functionName}`);
+    }
+    if (estimatedCostClip > limit) {
+      throw Object.assign(
+        new Error(`Estimated cost ${clipCostLabel(estimatedCostClip)} exceeds --max-credits ${clipCostLabel(limit)} for run ${functionName}.`),
+        {
+          exitCode: EXIT.CONFIRMATION,
+          data: {
+            command: `run ${functionName}`,
+            maxCredits: limit,
+            estimatedCostClip,
+            estimates: [runEstimate],
+          },
+        },
+      );
+    }
+  }
+  if (tool?.confirmation?.required || (isMetered && !isMeteredExempt)) {
+    requireConfirm(
+      options,
+      tool?.confirmation?.required ? `Running confirmation-gated tool ${functionName}` : `Running metered tool ${functionName}`,
+    );
+  }
+  return runEstimate ? summarizeRunEstimates([runEstimate]) : null;
 }
 
 async function login(config, options) {
@@ -836,7 +1469,7 @@ async function setKey(config, options) {
   if (!options.stdin) {
     throw Object.assign(new Error('Use --stdin to avoid shell history leaks.'), { exitCode: EXIT.USAGE });
   }
-  const apiKey = (await readStdin()).trim();
+  const apiKey = (await readSecretLine()).trim();
   if (!apiKey) {
     throw Object.assign(new Error('No API key received on stdin.'), { exitCode: EXIT.USAGE });
   }
@@ -845,17 +1478,50 @@ async function setKey(config, options) {
     apiKey,
     loginSource: 'manual',
   });
-  const me = await apiFetch(nextConfig, options, 'GET', '/api/v1/agent/me');
-  await writeConfig(updateProfile(nextConfig, options, { keyInfo: me.apiKey }));
-  output({ success: true, message: 'API key stored', profile: profileName(config, options), account: me.user, apiKey: me.apiKey }, options);
+  const me = await apiFetch(nextConfig, options, 'GET', '/api/v1/agent/me', undefined, { authApiKey: apiKey });
+  await writeConfig(updateProfile(nextConfig, options, { keyInfo: me.apiKey, scope: me.scope ?? null }));
+  output({
+    success: true,
+    message: 'API key stored',
+    profile: profileName(config, options),
+    account: me.user,
+    apiKey: me.apiKey,
+    scope: me.scope ?? null,
+  }, options);
 }
 
 async function logout(config, options) {
-  const next = removeProfileFields(config, options, ['apiKey', 'keyInfo', 'loginSource']);
+  const next = removeProfileFields(config, options, ['apiKey', 'keyInfo', 'scope', 'loginSource']);
   await writeConfig(next);
   output({ success: true, message: 'Local ClipIt CLI credentials removed', profile: profileName(config, options) }, options);
 }
 
+async function useProfile(config, options, requestedName) {
+  const name = String(requestedName || '').trim();
+  if (!name) {
+    throw Object.assign(new Error('Profile name is required.'), { exitCode: EXIT.USAGE });
+  }
+  if (process.env.CLIPIT_PROFILE && process.env.CLIPIT_PROFILE !== name) {
+    throw Object.assign(
+      new Error(`CLIPIT_PROFILE is set to ${process.env.CLIPIT_PROFILE}; unset it or select that profile explicitly.`),
+      { exitCode: EXIT.USAGE },
+    );
+  }
+  const selectedOptions = { ...options, profile: name };
+  const profile = profileData(config, selectedOptions);
+  if (!profile.apiKey) {
+    throw Object.assign(new Error(`Profile ${name} does not have a stored credential.`), { exitCode: EXIT.AUTH });
+  }
+  const next = { ...config, currentProfile: name, updatedAt: new Date().toISOString() };
+  await writeConfig(next);
+  output({
+    success: true,
+    currentProfile: name,
+    keyName: profile.keyInfo?.keyName ?? null,
+    scope: profile.scope ?? null,
+  }, options);
+}
+
 async function listProfiles(config, options) {
   const profiles = config.profiles || {};
   const names = [...new Set(['default', ...Object.keys(profiles)])];
@@ -871,6 +1537,7 @@ async function listProfiles(config, options) {
         hasCredential: Boolean(data.apiKey),
         loginSource: data.loginSource || null,
         keyName: data.keyInfo?.keyName || null,
+        scope: data.scope || null,
         updatedAt: data.updatedAt || null,
       };
     }),
@@ -878,6 +1545,7 @@ async function listProfiles(config, options) {
 }
 
 async function doctor(config, options) {
+  const credential = resolveApiCredential(config, options);
   const checks = {
     version: VERSION,
     node: process.version,
@@ -885,8 +1553,8 @@ async function doctor(config, options) {
     configPath: configPath(),
     profile: profileName(config, options),
     baseUrl: getBaseUrl(config, options),
-    hasCredential: Boolean(getApiKey(config, options)),
-    credentialSource: process.env.CLIPPER_API_KEY ? 'env' : getApiKey(config, options) ? 'config' : 'missing',
+    hasCredential: Boolean(credential.apiKey),
+    credentialSource: credential.source,
     auth: null,
   };
   try {
@@ -967,7 +1635,7 @@ async function contextCommand(config, options, action) {
   }
 
   if (action === 'use') {
-    const activeContext = await buildContext({ ...config, activeContext: {} }, options);
+    const activeContext = await buildContext(withProfileActiveContext(config, options, {}), options);
     let next = updateProfile(config, options, { activeContext });
     next = appendRecentEntries(next, options, [
       { type: 'video', id: activeContext.videoId },
@@ -988,6 +1656,51 @@ async function contextCommand(config, options, action) {
   throw Object.assign(new Error(`Unknown context command: ${action || ''}`), { exitCode: EXIT.USAGE });
 }
 
+function applyContextToAgentPayload(payload, parameters, context) {
+  const canMutateParameters = parameters && typeof parameters === 'object' && !Array.isArray(parameters);
+  const hadExplicitVideoId = canMutateParameters && parameters.videoId !== undefined;
+  for (const field of ['videoId', 'clipId', 'projectId', 'sequenceId']) {
+    if (context[field] && !payload[field]) {
+      payload[field] = context[field];
+      if (canMutateParameters && parameters[field] === undefined) {
+        parameters[field] = context[field];
+      }
+    }
+  }
+  if (canMutateParameters
+    && CLIP_IDS_CONTEXT_TOOLS.has(payload.functionName)
+    && parameters.clipIds === undefined
+    && !hadExplicitVideoId) {
+    const selectedClipIds = Array.isArray(context.selectedClipIds)
+      ? context.selectedClipIds.filter(Boolean).map(String)
+      : [];
+    const clipId = parameters.clipId || (selectedClipIds.length ? null : context.clipId);
+    if (clipId) parameters.clipIds = [String(clipId)];
+    else if (selectedClipIds.length) parameters.clipIds = selectedClipIds;
+  }
+  if (context.selectedClipIds) payload.selectedClipIds = context.selectedClipIds;
+  if (context.playheadPosition !== undefined) payload.playheadPosition = context.playheadPosition;
+  if (Object.keys(context).length) payload.context = context.context || context;
+}
+
+function normalizeAgentExecuteResult(result) {
+  if (!result || typeof result !== 'object' || Array.isArray(result)) return result;
+  const nested = result.result;
+  if (!nested || typeof nested !== 'object' || Array.isArray(nested) || nested.requiresConfirmation !== true) {
+    return result;
+  }
+
+  return compactObject({
+    ...result,
+    requiresConfirmation: true,
+    confirmationTool: result.confirmationTool ?? nested.confirmationTool ?? nested.functionName,
+    confirmationParams: result.confirmationParams ?? nested.confirmationParams ?? nested.parameters,
+    confirmation: result.confirmation ?? nested.confirmation,
+    estimate: result.estimate ?? nested.estimate,
+    preview: result.preview ?? nested.preview,
+  });
+}
+
 async function runTool(config, options, functionName) {
   if (!functionName) throw Object.assign(new Error('Function name is required.'), { exitCode: EXIT.USAGE });
   const parameters = await readJsonOption(options.params || options['params-json']);
@@ -1003,23 +1716,29 @@ async function runTool(config, options, functionName) {
     ['project-id', 'projectId'],
     ['sequence-id', 'sequenceId'],
   ]) {
-    if (options[flag]) payload[field] = String(options[flag]);
+    if (options[flag]) {
+      const value = String(options[flag]);
+      payload[field] = value;
+      if (parameters && typeof parameters === 'object' && !Array.isArray(parameters) && parameters[field] === undefined) {
+        parameters[field] = value;
+      }
+    }
   }
-  if (context.videoId && !payload.videoId) payload.videoId = context.videoId;
-  if (context.clipId && !payload.clipId) payload.clipId = context.clipId;
-  if (context.projectId && !payload.projectId) payload.projectId = context.projectId;
-  if (context.sequenceId && !payload.sequenceId) payload.sequenceId = context.sequenceId;
-  if (context.selectedClipIds) payload.selectedClipIds = context.selectedClipIds;
-  if (context.playheadPosition !== undefined) payload.playheadPosition = context.playheadPosition;
-  if (Object.keys(context).length) payload.context = context.context || context;
-  await enforceRunMaxCredits(config, options, functionName);
-  const result = await apiFetch(config, options, 'POST', '/api/v1/agent/execute', payload);
-  if (result?.requiresConfirmation && !payload.confirmed) {
-    output(result, options);
+  applyContextToAgentPayload(payload, parameters, context);
+  if (RUN_CONFIRMATION_LABELS[functionName]) {
+    confirmPaid(options, RUN_CONFIRMATION_LABELS[functionName]);
+  }
+  const estimate = await enforceRunMaxCredits(config, options, functionName, parameters, payload);
+  const result = normalizeAgentExecuteResult(await apiFetch(config, options, 'POST', '/api/v1/agent/execute', payload));
+  const outputResult = estimate && result && typeof result === 'object' && !Array.isArray(result) && result.estimate === undefined
+    ? { ...result, estimate }
+    : result;
+  if (result?.requiresConfirmation && !payload.confirmed && !RUN_METERED_CONFIRMATION_EXEMPTIONS.has(functionName)) {
+    output(outputResult, options);
     process.exitCode = EXIT.CONFIRMATION;
     return;
   }
-  output(result, options);
+  output(outputResult, options);
 }
 
 function workflowEndpoint(jobId) {
@@ -1141,17 +1860,40 @@ async function pollWorkflow(config, options, jobId) {
   }
 }
 
+function promptNamesNewSourceUrl(userMessage) {
+  const urls = userMessage.match(/https?:\/\/[^\s<>"'`]+/gi) || [];
+  if (urls.length !== 1) return false;
+  const messageWithoutUrls = userMessage
+    .replace(/https?:\/\/[^\s<>"'`]+/gi, ' ')
+    .replace(/[^a-z0-9]+/gi, ' ')
+    .trim()
+    .toLowerCase();
+  const isUrlOnly = messageWithoutUrls.length === 0;
+  const hasStrongSourceIntent = /\b(import|process|source|transcrib\w*|download|extract)\b/.test(messageWithoutUrls)
+    || /\b(clip|clips|video)\b.*\b(from|using|this|that)\b/.test(messageWithoutUrls)
+    || /\b(use|using)\b.*\b(link|url|source|video|this|that)\b/.test(messageWithoutUrls);
+  const isReferenceOnly = /\b(reference|inspiration|example|style)\b/.test(messageWithoutUrls)
+    && !/\b(import|process|source|transcrib\w*|clip|clips|extract)\b/.test(messageWithoutUrls);
+  return isUrlOnly || (hasStrongSourceIntent && !isReferenceOnly);
+}
+
 async function askWorkflow(config, options, promptParts) {
   const userMessage = promptParts.filter((part) => part !== undefined).join(' ').trim();
   if (!userMessage) throw Object.assign(new Error('Prompt is required.'), { exitCode: EXIT.USAGE });
 
   const context = await buildContext(config, options);
+  if (promptNamesNewSourceUrl(userMessage)) {
+    if (!options['video-id']) delete context.videoId;
+    if (!options['clip-id']) delete context.clipId;
+    if (!options['selected-clip-ids']) delete context.selectedClipIds;
+  }
   const payload = { userMessage };
   for (const field of ['videoId', 'clipId', 'projectId', 'sequenceId']) {
     if (context[field]) payload[field] = context[field];
   }
   if (options['conversation-id']) payload.conversationId = String(options['conversation-id']);
   if (options.quick !== undefined) payload.quickMode = boolOption(options.quick);
+  if (options['auto-confirm-costly'] !== undefined) payload.autoConfirmCostlyTools = boolOption(options['auto-confirm-costly']);
 
   const accepted = await apiFetch(config, options, 'POST', '/api/v1/agent/orchestrate', payload);
   if (boolOption(options['no-wait'])) {
@@ -1199,12 +1941,13 @@ async function workflow(config, options, action, args) {
     }
 
     const redactedAccepted = redactDeep(accepted);
-    if (wantJson(options)) {
+    if (boolOption(options['no-wait'])) {
       output(redactedAccepted, options);
-    } else {
+      return;
+    }
+    if (!wantJson(options)) {
       console.log(`Continuation workflow queued: ${redactedAccepted.jobId}`);
     }
-    if (boolOption(options['no-wait'])) return;
     await pollWorkflow(config, options, accepted.jobId);
     return;
   }
@@ -1222,16 +1965,19 @@ function mimeForPath(filePath) {
   if (ext === '.webm') return 'video/webm';
   if (ext === '.mkv') return 'video/x-matroska';
   if (ext === '.m4v') return 'video/x-m4v';
+  if (ext === '.avi') return 'video/x-msvideo';
+  if (ext === '.wmv' || ext === '.asf') return 'video/x-ms-asf';
+  if (ext === '.flv') return 'video/x-flv';
+  if (ext === '.mpeg' || ext === '.mpg') return 'video/mpeg';
+  if (ext === '.ts' || ext === '.m2ts') return 'video/mp2t';
+  if (ext === '.mxf') return 'video/mxf';
+  if (ext === '.ogv') return 'video/ogg';
   if (ext === '.mp3') return 'audio/mpeg';
   if (ext === '.m4a') return 'audio/mp4';
   if (ext === '.wav') return 'audio/wav';
   return 'video/mp4';
 }
 
-function multipartFilename(value) {
-  return String(value).replace(/["\r\n]/g, '_');
-}
-
 function shouldReportUploadProgress(options) {
   return Boolean(process.stderr.isTTY) && !wantJson(options);
 }
@@ -1268,46 +2014,457 @@ function createUploadProgress(options, totalBytes) {
   };
 }
 
-async function* multipartFileBody(filePath, filename, contentType, boundary, progress) {
-  yield Buffer.from(
-    `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${multipartFilename(filename)}"\r\nContent-Type: ${contentType}\r\n\r\n`,
-  );
-  for await (const chunk of createReadStream(filePath)) {
-    progress?.track(chunk);
-    yield chunk;
-  }
-  yield Buffer.from(`\r\n--${boundary}--\r\n`);
+const VIDEO_UPLOAD_RESUME_MAX_AGE_MS = 25 * 60 * 60 * 1000;
+
+function videoUploadResumeDirectory() {
+  return path.join(configDir(), 'video-upload-resumes');
 }
 
-async function uploadVideo(config, options, filePath) {
-  if (!filePath) throw Object.assign(new Error('Video file path is required.'), { exitCode: EXIT.USAGE });
-  const resolved = path.resolve(filePath);
-  const stat = await fs.stat(resolved);
-  if (!stat.isFile()) {
-    throw Object.assign(new Error(`Upload path is not a file: ${resolved}`), { exitCode: EXIT.USAGE });
+function videoUploadResumePath(idempotencyKey) {
+  const digest = createHash('sha256').update(String(idempotencyKey)).digest('hex');
+  return path.join(videoUploadResumeDirectory(), `${digest}.json`);
+}
+
+async function readVideoUploadResumes() {
+  const resumes = {};
+  await fs.mkdir(videoUploadResumeDirectory(), { recursive: true, mode: 0o700 });
+  const files = await fs.readdir(videoUploadResumeDirectory()).catch(() => []);
+  for (const file of files) {
+    if (!file.endsWith('.json')) continue;
+    const recordPath = path.join(videoUploadResumeDirectory(), file);
+    try {
+      const value = JSON.parse(await fs.readFile(recordPath, 'utf8'));
+      const updatedAt = Date.parse(value?.updatedAt);
+      if (
+        !value
+        || typeof value !== 'object'
+        || Array.isArray(value)
+        || typeof value.idempotencyKey !== 'string'
+        || !Number.isFinite(updatedAt)
+        || Date.now() - updatedAt > VIDEO_UPLOAD_RESUME_MAX_AGE_MS
+      ) {
+        await fs.rm(recordPath, { force: true });
+        continue;
+      }
+      resumes[value.idempotencyKey] = value;
+    } catch {
+      await fs.rm(recordPath, { force: true }).catch(() => undefined);
+    }
   }
-  const filename = options.filename || path.basename(resolved);
-  const contentType = mimeForPath(resolved);
-  const boundary = `clipit-cli-${randomBytes(12).toString('hex')}`;
-  const headerLength = Buffer.byteLength(
-    `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${multipartFilename(filename)}"\r\nContent-Type: ${contentType}\r\n\r\n`,
-  );
-  const footerLength = Buffer.byteLength(`\r\n--${boundary}--\r\n`);
-  const progress = createUploadProgress(options, stat.size);
-  const body = multipartFileBody(resolved, filename, contentType, boundary, progress);
+
+  const legacyPath = path.join(configDir(), 'video-upload-resume.json');
   try {
-    output(await apiFetch(config, options, 'POST', '/api/v1/videos', body, {
-      rawBody: true,
-      headers: {
-        'Content-Type': `multipart/form-data; boundary=${boundary}`,
-        'Content-Length': String(headerLength + stat.size + footerLength),
+    const legacy = JSON.parse(await fs.readFile(legacyPath, 'utf8'));
+    if (legacy && typeof legacy === 'object' && !Array.isArray(legacy)) {
+      for (const [idempotencyKey, value] of Object.entries(legacy)) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) continue;
+        await saveVideoUploadResume(idempotencyKey, value);
+        resumes[idempotencyKey] = { ...value, idempotencyKey };
+      }
+    }
+    await fs.rm(legacyPath, { force: true });
+  } catch {}
+
+  return resumes;
+}
+
+async function saveVideoUploadResume(idempotencyKey, value) {
+  await fs.mkdir(videoUploadResumeDirectory(), { recursive: true, mode: 0o700 });
+  const destination = videoUploadResumePath(idempotencyKey);
+  const temporary = `${destination}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`;
+  await fs.writeFile(
+    temporary,
+    `${JSON.stringify({ ...value, idempotencyKey }, null, 2)}\n`,
+    { mode: 0o600 },
+  );
+  await fs.rename(temporary, destination);
+}
+
+async function removeVideoUploadResume(idempotencyKey) {
+  await fs.rm(videoUploadResumePath(idempotencyKey), { force: true });
+}
+
+async function removeVideoUploadResumeByIntent(intentId) {
+  const resumes = await readVideoUploadResumes();
+  await Promise.all(Object.entries(resumes).map(async ([key, value]) => {
+    if (value?.intentId === intentId) await removeVideoUploadResume(key);
+  }));
+}
+
+function defaultVideoUploadIdempotencyKey(resolved, stat, filename, contentType) {
+  const fingerprint = createHash('sha256').update(JSON.stringify({
+    path: resolved,
+    size: stat.size,
+    mtimeMs: stat.mtimeMs,
+    ctimeMs: stat.ctimeMs,
+    filename,
+    contentType,
+  })).digest('hex');
+  return `cli-video:${fingerprint}`;
+}
+
+function createMultipartUploadProgress(options, totalBytes, completedParts) {
+  if (!shouldReportUploadProgress(options) || totalBytes <= 0) {
+    return { updatePart() {}, completePart() {}, resetPart() {}, finish() {} };
+  }
+  const completed = new Map(completedParts.map((part) => [part.partNumber, part.sizeBytes]));
+  const inFlight = new Map();
+  let lastPrintedAt = 0;
+
+  const print = (force = false) => {
+    const now = Date.now();
+    if (!force && now - lastPrintedAt < 500) return;
+    lastPrintedAt = now;
+    const uploaded = Math.min(
+      totalBytes,
+      [...completed.values(), ...inFlight.values()].reduce((sum, value) => sum + value, 0),
+    );
+    const percent = Math.min(100, Math.round((uploaded / totalBytes) * 100));
+    process.stderr.write(`\ruploaded ${formatMb(uploaded)} / ${formatMb(totalBytes)} MB (${percent}%)`);
+  };
+
+  return {
+    updatePart(partNumber, bytes) {
+      inFlight.set(partNumber, bytes);
+      print(false);
+    },
+    completePart(partNumber, bytes) {
+      inFlight.delete(partNumber);
+      completed.set(partNumber, bytes);
+      print(false);
+    },
+    resetPart(partNumber) {
+      inFlight.delete(partNumber);
+      print(false);
+    },
+    finish() {
+      print(true);
+      process.stderr.write('\n');
+    },
+  };
+}
+
+function createUploadActivityWatchdog(controller, onTimeout) {
+  let timer;
+  const arm = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      const error = Object.assign(
+        new Error(`Storage upload made no progress for ${VIDEO_UPLOAD_STALL_TIMEOUT_MS} ms`),
+        { code: 'UPLOAD_STALLED' },
+      );
+      controller.abort(error);
+      onTimeout?.();
+    }, VIDEO_UPLOAD_STALL_TIMEOUT_MS);
+    timer.unref?.();
+  };
+  arm();
+  return {
+    activity: arm,
+    stop() {
+      if (timer) clearTimeout(timer);
+      timer = undefined;
+    },
+  };
+}
+
+async function putSignedVideoPart(part, filePath, start, size, progress) {
+  for (let attempt = 0; attempt < VIDEO_UPLOAD_PART_ATTEMPTS; attempt += 1) {
+    let transferred = 0;
+    const controller = new AbortController();
+    let source;
+    let tracker;
+    const watchdog = createUploadActivityWatchdog(controller, () => {
+      source?.destroy();
+      tracker?.destroy();
+    });
+    tracker = new Transform({
+      transform(chunk, encoding, callback) {
+        transferred += Buffer.byteLength(chunk);
+        watchdog.activity();
+        progress.updatePart(part.partNumber, transferred);
+        callback(null, chunk);
       },
-    }), options);
+    });
+    try {
+      source = createReadStream(filePath, { start, end: start + size - 1 });
+      const response = await fetch(part.url, {
+        method: 'PUT',
+        headers: { 'Content-Length': String(size) },
+        body: source.pipe(tracker),
+        duplex: 'half',
+        signal: controller.signal,
+      });
+      if (!response.ok) {
+        const text = await response.text().catch(() => '');
+        throw new Error(`Part ${part.partNumber} failed: ${response.status} ${redact(text || response.statusText)}`);
+      }
+      progress.completePart(part.partNumber, size);
+      return;
+    } catch (error) {
+      progress.resetPart(part.partNumber);
+      const reason = controller.signal.aborted && controller.signal.reason instanceof Error
+        ? controller.signal.reason
+        : error;
+      if (attempt === VIDEO_UPLOAD_PART_ATTEMPTS - 1) throw reason;
+      await sleep(VIDEO_UPLOAD_RETRY_BASE_MS * (2 ** attempt));
+    } finally {
+      watchdog.stop();
+      source?.destroy();
+      tracker?.destroy();
+    }
+  }
+}
+
+async function uploadVideoMultipart(config, options, resolved, initialized, totalBytes) {
+  const status = await apiFetch(
+    config,
+    options,
+    'GET',
+    `/api/v1/videos/uploads/${encodeURIComponent(initialized.intentId)}`,
+  );
+  const uploadedParts = Array.isArray(status.uploadedParts) ? status.uploadedParts : [];
+  const uploadedNumbers = new Set(uploadedParts.map((part) => Number(part.partNumber)));
+  const missing = Array.from({ length: Number(initialized.partCount) }, (_, index) => index + 1)
+    .filter((partNumber) => !uploadedNumbers.has(partNumber));
+  const progress = createMultipartUploadProgress(options, totalBytes, uploadedParts);
+
+  try {
+    for (let offset = 0; offset < missing.length; offset += VIDEO_UPLOAD_PART_SIGN_BATCH) {
+      const partNumbers = missing.slice(offset, offset + VIDEO_UPLOAD_PART_SIGN_BATCH);
+      const signed = await apiFetch(
+        config,
+        options,
+        'POST',
+        `/api/v1/videos/uploads/${encodeURIComponent(initialized.intentId)}/parts`,
+        { partNumbers },
+      );
+      const queue = [...(signed.signedPartUrls || [])];
+      const signedNumbers = new Set(queue.map((part) => Number(part?.partNumber)));
+      if (
+        queue.length !== partNumbers.length
+        || signedNumbers.size !== partNumbers.length
+        || partNumbers.some((partNumber) => !signedNumbers.has(partNumber))
+        || queue.some((part) => typeof part?.url !== 'string' || !part.url)
+      ) {
+        throw new Error('Server returned an incomplete multipart signing batch.');
+      }
+      let cursor = 0;
+      const worker = async () => {
+        while (cursor < queue.length) {
+          const part = queue[cursor++];
+          const start = (part.partNumber - 1) * initialized.partSizeBytes;
+          const size = Math.min(initialized.partSizeBytes, totalBytes - start);
+          if (size !== Number(part.expectedSizeBytes)) {
+            throw new Error(`Server returned an invalid size for upload part ${part.partNumber}.`);
+          }
+          await putSignedVideoPart(part, resolved, start, size, progress);
+        }
+      };
+      const workerCount = Math.min(VIDEO_UPLOAD_PART_CONCURRENCY, queue.length);
+      await Promise.all(Array.from({ length: workerCount }, () => worker()));
+    }
   } finally {
     progress.finish();
   }
 }
 
+async function uploadVideo(config, options, filePath) {
+  if (!filePath) throw Object.assign(new Error('Video file path is required.'), { exitCode: EXIT.USAGE });
+  const resolved = path.resolve(filePath);
+  const stat = await fs.stat(resolved);
+  if (!stat.isFile()) {
+    throw Object.assign(new Error(`Upload path is not a file: ${resolved}`), { exitCode: EXIT.USAGE });
+  }
+  const filename = String(options.filename || path.basename(resolved));
+  const contentType = mimeForPath(resolved);
+  const title = options.title === undefined || options.title === null
+    ? null
+    : String(options.title);
+  const idempotencyKey = String(
+    options['idempotency-key']
+      || defaultVideoUploadIdempotencyKey(resolved, stat, filename, contentType),
+  );
+  const uploadIdentity = {
+    filePath: resolved,
+    filename,
+    title,
+    profile: profileName(config, options),
+    baseUrl: getBaseUrl(config, options),
+    allowCustomHost: allowCustomHost(options),
+    contentType,
+    size: stat.size,
+    mtimeMs: stat.mtimeMs,
+  };
+  const resumes = await readVideoUploadResumes();
+  const existingResume = resumes[idempotencyKey];
+  if (existingResume && typeof existingResume === 'object') {
+    const mismatchedFields = Object.entries(uploadIdentity)
+      .filter(([key, value]) => {
+        const existingValue = existingResume[key];
+        if (key === 'title') return (existingValue ?? null) !== value;
+        return existingValue !== value;
+      })
+      .map(([key]) => key);
+    if (mismatchedFields.length > 0) {
+      const abortArgs = existingResume.intentId
+        ? ['videos', 'abort-upload', String(existingResume.intentId), '--profile', String(existingResume.profile || uploadIdentity.profile), '--base-url', String(existingResume.baseUrl || uploadIdentity.baseUrl), '--confirm']
+        : null;
+      if (abortArgs && existingResume.allowCustomHost === true) abortArgs.push('--allow-custom-host');
+      throw Object.assign(
+        new Error('The file or upload identity changed since this resumable upload began. Abort the prior upload and retry with a new idempotency key.'),
+        {
+          exitCode: EXIT.USAGE,
+          data: {
+            idempotencyKey,
+            uploadIntentId: existingResume.intentId,
+            mismatchedFields,
+            abortArgs,
+            abortCommand: abortArgs ? `clipit ${abortArgs.map(shellQuote).join(' ')}` : undefined,
+          },
+        },
+      );
+    }
+  }
+  await enforceMaxCredits(config, options, 'videos upload', { bytes: stat.size });
+  confirmPaid(options, 'Uploading a video');
+  await saveVideoUploadResume(idempotencyKey, {
+    ...uploadIdentity,
+    intentId: existingResume?.intentId,
+    jobId: existingResume?.jobId,
+    updatedAt: new Date().toISOString(),
+  });
+
+  let initialized;
+  try {
+    initialized = await apiFetch(config, options, 'POST', '/api/v1/videos/uploads', {
+      filename,
+      contentType,
+      size: stat.size,
+      title: title ?? undefined,
+      idempotencyKey,
+    });
+    if (!initialized?.intentId || !initialized?.jobId) {
+      throw Object.assign(new Error('Video upload initialization returned an unexpected response.'), {
+        exitCode: EXIT.SERVER,
+        data: initialized,
+      });
+    }
+    if (!initialized.readyForUpload) {
+      await removeVideoUploadResume(idempotencyKey);
+      if (initialized.videoId) {
+        await persistActiveContext(
+          config,
+          options,
+          { videoId: initialized.videoId },
+          [{ type: 'video', id: initialized.videoId }],
+        );
+      }
+      output(initialized, options);
+      return;
+    }
+
+    await saveVideoUploadResume(idempotencyKey, {
+      ...uploadIdentity,
+      intentId: initialized.intentId,
+      jobId: initialized.jobId,
+      updatedAt: new Date().toISOString(),
+    });
+
+    if (initialized.transport === 'single') {
+      if (!initialized.uploadUrl || Number(initialized.expectedSizeBytes) !== stat.size) {
+        throw new Error('Direct upload initialization returned invalid transfer metadata.');
+      }
+      await putSignedUpload(
+        initialized.uploadUrl,
+        resolved,
+        contentType,
+        stat.size,
+        options,
+        initialized.requiredHeaders,
+      );
+    } else if (initialized.transport === 'multipart') {
+      if (
+        !Number.isInteger(initialized.partCount)
+        || !Number.isInteger(initialized.partSizeBytes)
+        || Number(initialized.expectedSizeBytes) !== stat.size
+      ) {
+        throw new Error('Multipart upload initialization returned invalid transfer metadata.');
+      }
+      await uploadVideoMultipart(config, options, resolved, initialized, stat.size);
+    } else {
+      throw new Error('Video upload initialization returned no supported transport.');
+    }
+
+    const completedStat = await fs.stat(resolved);
+    if (
+      !completedStat.isFile()
+      || completedStat.size !== stat.size
+      || completedStat.mtimeMs !== stat.mtimeMs
+      || completedStat.ctimeMs !== stat.ctimeMs
+    ) {
+      throw Object.assign(
+        new Error('The video file changed while it was uploading. Abort this upload and retry with a new idempotency key.'),
+        { exitCode: EXIT.USAGE, data: { fileChangedDuringUpload: true } },
+      );
+    }
+
+    const result = await apiFetch(
+      config,
+      options,
+      'POST',
+      `/api/v1/videos/uploads/${encodeURIComponent(initialized.intentId)}/complete`,
+      {},
+    );
+    await removeVideoUploadResume(idempotencyKey);
+    if (result?.videoId) {
+      await persistActiveContext(
+        config,
+        options,
+        { videoId: result.videoId },
+        [{ type: 'video', id: result.videoId }],
+      );
+    }
+    output(result, options);
+  } catch (error) {
+    if (error && typeof error === 'object') {
+      const requiresNewIdempotencyKey = error.data?.requiresNewIdempotencyKey === true
+        || error.data?.code === 'IDEMPOTENCY_KEY_TERMINAL';
+      if (requiresNewIdempotencyKey) {
+        await removeVideoUploadResume(idempotencyKey);
+        error.data = {
+          ...(error.data && typeof error.data === 'object' ? error.data : {}),
+          uploadIntentId: initialized?.intentId ?? existingResume?.intentId,
+          idempotencyKey,
+        };
+        throw error;
+      }
+      const resumeArgs = [
+        'videos',
+        'upload',
+        resolved,
+        '--idempotency-key',
+        idempotencyKey,
+      ];
+      resumeArgs.push('--filename', filename);
+      if (title) resumeArgs.push('--title', title);
+      resumeArgs.push('--profile', uploadIdentity.profile);
+      resumeArgs.push('--base-url', uploadIdentity.baseUrl);
+      if (uploadIdentity.allowCustomHost) resumeArgs.push('--allow-custom-host');
+      if (boolOption(options.confirm) || boolOption(options.yes)) resumeArgs.push('--confirm');
+      if (wantJson(options)) resumeArgs.push('--json');
+      error.data = {
+        ...(error.data && typeof error.data === 'object' ? error.data : {}),
+        uploadIntentId: initialized?.intentId ?? existingResume?.intentId,
+        idempotencyKey,
+        resumeArgs,
+        resumeCommand: `clipit ${resumeArgs.map(shellQuote).join(' ')}`,
+      };
+    }
+    throw error;
+  }
+}
+
 async function videos(config, options, action, args) {
   if (action === 'list') {
     output(await apiFetch(config, options, 'GET', `/api/v1/videos${queryString({ limit: options.limit, offset: options.offset })}`), options);
@@ -1324,15 +2481,35 @@ async function videos(config, options, action, args) {
     const url = args[0] || options.url;
     if (!url) throw Object.assign(new Error('URL is required.'), { exitCode: EXIT.USAGE });
     await enforceMaxCredits(config, options, 'videos import-url', { url });
-    output(await apiFetch(config, options, 'POST', '/api/v1/videos/from-url', { url, title: options.title }), options);
+    confirmPaid(options, 'Importing a video from URL');
+    output(await apiFetch(config, options, 'POST', '/api/v1/videos/from-url', {
+      url,
+      title: options.title,
+      idempotencyKey: options['idempotency-key'] || randomUUID(),
+    }), options);
     return;
   }
   if (action === 'upload') {
     await uploadVideo(config, options, args[0] || options.file);
     return;
   }
+  if (action === 'abort-upload') {
+    const intentId = requiredString(args[0] || options['intent-id'], 'Upload intent id');
+    requireConfirm(options, 'Aborting a video upload');
+    const result = await apiFetch(
+      config,
+      options,
+      'DELETE',
+      `/api/v1/videos/uploads/${encodeURIComponent(intentId)}`,
+    );
+    await removeVideoUploadResumeByIntent(intentId);
+    output(result, options);
+    return;
+  }
   if (action === 'transcribe') {
     if (!args[0]) throw Object.assign(new Error('Video id is required.'), { exitCode: EXIT.USAGE });
+    await enforceMaxCredits(config, options, 'videos transcribe', { videoId: args[0] });
+    confirmPaid(options, 'Transcribing a video');
     output(await apiFetch(config, options, 'POST', `/api/v1/videos/${encodeURIComponent(args[0])}/transcribe`, {}), options);
     return;
   }
@@ -1352,6 +2529,8 @@ async function videos(config, options, action, args) {
           targetPlatforms: stringList(options.platforms),
           themes: stringList(options.themes),
         };
+    await enforceMaxCredits(config, options, 'videos suggest-clips', { videoId: args[0], body });
+    confirmPaid(options, 'Suggesting clips');
     output(await apiFetch(config, options, 'POST', `/api/v1/videos/${encodeURIComponent(args[0])}/suggest-clips`, body), options);
     return;
   }
@@ -1365,6 +2544,119 @@ async function videos(config, options, action, args) {
   throw Object.assign(new Error(`Unknown videos command: ${action || ''}`), { exitCode: EXIT.USAGE });
 }
 
+function formatClipDeliveryState(state) {
+  const editor = state?.editorState;
+  const selected = state?.selectedExport;
+  const candidates = Array.isArray(state?.exports) ? state.exports : [];
+  const blockers = Array.isArray(state?.deliveryBlockers) ? state.deliveryBlockers : [];
+  const lines = [
+    `Clip: ${state?.clipId || 'unknown'}`,
+    editor
+      ? `Editor snapshot: ${editor.snapshotId}`
+      : `Editor: ${state?.editorStateStatus || 'unavailable'}`,
+    editor ? `Editor version: ${editor.editorVersion}` : null,
+    editor ? `Editor state hash: ${editor.editorStateHash}` : null,
+    editor ? `Source object fingerprint: ${editor.sourceObjectFingerprint || 'unavailable'}` : null,
+    editor ? `Saved: ${editor.saveOrigin} at ${editor.savedAt}` : null,
+    editor
+      ? `Edit: ${editor.aspectRatio}; captions ${editor.caption?.enabled ? 'on' : 'off'}${editor.caption?.presetId ? `/${editor.caption.presetId}` : ''}; crop ${editor.cropSegmentCount}; keyframes ${editor.keyframeCount}; layout ${editor.layout || 'none'}`
+      : null,
+    `Selection: ${state?.selection?.status || 'unknown'}${state?.selection?.selectedExportId ? ` (${state.selection.selectedExportId})` : ''}`,
+    selected
+      ? `Selected export: ${selected.exportId}; snapshot ${selected.snapshotId || 'unavailable'}; exact current match ${selected.exactlyMatchesEditor === true ? 'yes' : 'no'}`
+      : `Artifacts: ${candidates.length}`,
+    selected ? `Output object fingerprint: ${selected.outputObjectFingerprint || 'unavailable'}` : null,
+    selected ? `Storage item: ${selected.storageItemId || 'unavailable'}` : null,
+    selected
+      ? `Artifact: ${selected.width || '?'}x${selected.height || '?'} ${selected.duration || '?'}s; audio ${selected.hasAudio === true ? 'yes' : selected.hasAudio === false ? 'no' : 'unknown'}; probe ${selected.inspectionStatus}`
+      : null,
+    `Ready to publish: ${state?.readyToPublish === true ? 'yes' : 'no'}`,
+  ].filter(Boolean);
+  if (candidates.length > 1) {
+    lines.push(`Export ids: ${candidates.map((candidate) => candidate.exportId).join(', ')}`);
+  }
+  if (blockers.length) {
+    lines.push('Blockers:');
+    lines.push(...blockers.map((blocker) => `- ${blocker}`));
+  }
+  return lines.join('\n');
+}
+
+function requireVerifiedEditorState(deliveryState, clipId) {
+  const editor = deliveryState?.editorState;
+  if (
+    deliveryState?.schema !== 'clipit_clip_delivery_state'
+    || deliveryState?.version !== 2
+    || deliveryState?.clipId !== clipId
+    || deliveryState?.editorStateStatus !== 'verified'
+    || !editor
+    || typeof editor.snapshotId !== 'string'
+    || !editor.snapshotId
+    || !Number.isInteger(editor.editorVersion)
+    || editor.editorVersion < 1
+    || typeof editor.editorStateHash !== 'string'
+    || !/^[a-f0-9]{64}$/i.test(editor.editorStateHash)
+    || editor.stateSource !== 'current_editor_snapshot'
+  ) {
+    throw Object.assign(
+      new Error('Clip does not have a verified canonical editor snapshot. Save and verify the editor state before continuing.'),
+      { exitCode: EXIT.SERVER, data: deliveryState },
+    );
+  }
+  return editor;
+}
+
+function requireExactCurrentExport(deliveryState, editorState, options = {}) {
+  const requestedExportId = options.requestedExportId
+    ? String(options.requestedExportId)
+    : null;
+  const selection = deliveryState?.selection;
+  const selected = deliveryState?.selectedExport;
+  const blockers = Array.isArray(deliveryState?.deliveryBlockers)
+    ? deliveryState.deliveryBlockers
+    : [];
+  const selectedBlockers = Array.isArray(selected?.blockers) ? selected.blockers : [];
+  const responseRequestedExportId = selection?.requestedExportId ?? null;
+  const exact = Boolean(
+    selection?.status === 'selected'
+    && selected
+    && typeof selected.exportId === 'string'
+    && selected.exportId
+    && selection.selectedExportId === selected.exportId
+    && responseRequestedExportId === requestedExportId
+    && (!requestedExportId || selected.exportId === requestedExportId)
+    && selected.snapshotId === editorState.snapshotId
+    && selected.editorVersion === editorState.editorVersion
+    && selected.editorStateHash === editorState.editorStateHash
+    && selected.exactlyMatchesEditor === true
+    && selected.inspectionStatus === 'verified'
+    && typeof selected.outputObjectFingerprint === 'string'
+    && /^[a-f0-9]{64}$/i.test(selected.outputObjectFingerprint)
+    && selectedBlockers.length === 0
+  );
+  const publishReady = !options.requireReadyToPublish
+    || (deliveryState?.readyToPublish === true && blockers.length === 0);
+  if (!exact || !publishReady) {
+    const detail = blockers.length
+      ? blockers.join(' ')
+      : `Selection status is ${selection?.status || 'unknown'}.`;
+    throw Object.assign(
+      new Error(`Clip does not have one verified exact-current export: ${detail}`),
+      { exitCode: EXIT.SERVER, data: deliveryState },
+    );
+  }
+  return selected;
+}
+
+async function fetchCanonicalClipDeliveryState(config, options, clipId, exportId) {
+  return apiFetch(
+    config,
+    options,
+    'GET',
+    `/api/v1/clips/${encodeURIComponent(clipId)}/delivery-state${queryString({ exportId })}`,
+  );
+}
+
 async function clips(config, options, action, args) {
   if (action === 'list') {
     output(await apiFetch(config, options, 'GET', `/api/v1/clips${queryString({
@@ -1381,6 +2673,19 @@ async function clips(config, options, action, args) {
     output(result, options);
     return;
   }
+  if (action === 'delivery-state') {
+    if (!args[0]) throw Object.assign(new Error('Clip id is required.'), { exitCode: EXIT.USAGE });
+    const result = await apiFetch(
+      config,
+      options,
+      'GET',
+      `/api/v1/clips/${encodeURIComponent(args[0])}/delivery-state${queryString({
+        exportId: options['export-id'],
+      })}`,
+    );
+    output(wantJson(options) ? result : formatClipDeliveryState(result), options);
+    return;
+  }
   if (action === 'create') {
     const body = options.params
       ? await readJsonOption(String(options.params))
@@ -1394,7 +2699,21 @@ async function clips(config, options, action, args) {
     if (!body.videoId) throw Object.assign(new Error('--video-id is required.'), { exitCode: EXIT.USAGE });
     if (body.startTime === undefined) throw Object.assign(new Error('--start is required.'), { exitCode: EXIT.USAGE });
     if (body.endTime === undefined) throw Object.assign(new Error('--end is required.'), { exitCode: EXIT.USAGE });
-    output(await apiFetch(config, options, 'POST', '/api/v1/clips', body), options);
+    await enforceMaxCredits(config, options, 'clips create', { body });
+    confirmPaid(options, 'Creating a clip');
+    const result = await apiFetch(config, options, 'POST', '/api/v1/clips', body);
+    if (result?.id) {
+      await persistActiveContext(
+        config,
+        options,
+        { videoId: result.videoId || body.videoId, clipId: result.id },
+        [
+          { type: 'video', id: result.videoId || body.videoId },
+          { type: 'clip', id: result.id },
+        ],
+      );
+    }
+    output(result, options);
     return;
   }
   if (action === 'update') {
@@ -1428,14 +2747,40 @@ async function clips(config, options, action, args) {
       if (body[key] === undefined) delete body[key];
     }
     await enforceMaxCredits(config, options, 'clips render', { clipId: args[0], body });
+    confirmPaid(options, 'Rendering a clip');
     output(await apiFetch(config, options, 'POST', `/api/v1/clips/${encodeURIComponent(args[0])}/render`, body), options);
     return;
   }
   if (action === 'download') {
     if (!args[0]) throw Object.assign(new Error('Clip id is required.'), { exitCode: EXIT.USAGE });
-    const result = await apiFetch(config, options, 'GET', `/api/v1/clips/${encodeURIComponent(args[0])}/download`);
+    const clipId = args[0];
+    const requestedExportId = options['export-id'];
+    const deliveryState = await fetchCanonicalClipDeliveryState(
+      config,
+      options,
+      clipId,
+      requestedExportId,
+    );
+    const editorState = requireVerifiedEditorState(deliveryState, clipId);
+    const selectedExport = requireExactCurrentExport(deliveryState, editorState, {
+      requestedExportId,
+    });
+    const result = await apiFetch(
+      config,
+      options,
+      'GET',
+      `/api/v1/exports/${encodeURIComponent(selectedExport.exportId)}/download`,
+    );
     if (options.open && result?.downloadUrl) openBrowser(result.downloadUrl);
-    output(result, options);
+    output({
+      ...result,
+      clipId,
+      exportId: selectedExport.exportId,
+      snapshotId: editorState.snapshotId,
+      editorVersion: editorState.editorVersion,
+      editorStateHash: editorState.editorStateHash,
+      outputObjectFingerprint: selectedExport.outputObjectFingerprint,
+    }, options);
     return;
   }
   if (action === 'delete') {
@@ -1460,18 +2805,78 @@ async function credits(config, options, action) {
   if (action === 'estimate') {
     const operationType = requiredString(options['operation-type'], '--operation-type');
     const provider = requiredString(options.provider, '--provider');
-    const metrics = await readMetricsOption(options.metrics);
-    output(await apiFetch(config, options, 'POST', '/api/v1/credits/estimate', compactObject({
+    const metrics = await readMetricsOption(options.metrics ?? options.metadata);
+    const request = normalizeCreditEstimateRequest(compactObject({
       operationType,
       provider,
       modelId: options['model-id'],
       metrics,
-    })), options);
+    }));
+    output(await apiFetch(config, options, 'POST', '/api/v1/credits/estimate', request), options);
     return;
   }
   throw Object.assign(new Error(`Unknown credits command: ${action || ''}`), { exitCode: EXIT.USAGE });
 }
 
+function normalizeBillingProvider(value) {
+  if (value === undefined || value === null || value === '') return undefined;
+  const provider = String(value);
+  if (!BILLING_PROVIDER_PREFERENCES.has(provider)) {
+    throw Object.assign(
+      new Error(`--provider must be one of: ${Array.from(BILLING_PROVIDER_PREFERENCES).join(', ')}.`),
+      { exitCode: EXIT.USAGE },
+    );
+  }
+  return provider;
+}
+
+function buildBillingAttemptBody(input = {}) {
+  return compactObject({
+    productKey: requiredString(input.productKey ?? input['product-key'] ?? input.product ?? input.key, '--product-key'),
+    providerPreference: normalizeBillingProvider(input.providerPreference ?? input.provider ?? input.rail),
+    idempotencyKey: input.idempotencyKey ?? input['idempotency-key'],
+  });
+}
+
+function billingAttemptId(args, options) {
+  return requiredString(args[0] ?? options['attempt-id'] ?? options.attemptId, 'Attempt id');
+}
+
+async function billing(config, options, action, args = []) {
+  if (action === 'capabilities') {
+    output(await apiFetch(config, options, 'GET', '/api/v1/agent/payment-capabilities', undefined, { noAuth: true }), options);
+    return;
+  }
+  if (action === 'catalog') {
+    output(await apiFetch(config, options, 'GET', '/api/v1/billing/catalog', undefined, { noAuth: true }), options);
+    return;
+  }
+  if (action === 'create-attempt') {
+    requireConfirm(options, 'Creating a machine-payment attempt');
+    const body = buildBillingAttemptBody({
+      ...options,
+      productKey: options['product-key'] ?? options.productKey ?? args[0],
+    });
+    output(await apiFetch(config, options, 'POST', '/api/v1/billing/agent-payments', body), options);
+    return;
+  }
+  if (action === 'attempt') {
+    const attemptId = billingAttemptId(args, options);
+    output(await apiFetch(config, options, 'GET', `/api/v1/billing/agent-payments/${encodeURIComponent(attemptId)}`), options);
+    return;
+  }
+  if (action === 'receipt') {
+    const attemptId = billingAttemptId(args, options);
+    output(await apiFetch(config, options, 'GET', `/api/v1/billing/agent-payments/${encodeURIComponent(attemptId)}/receipt`), options);
+    return;
+  }
+  if (action === 'subscription') {
+    output(await apiFetch(config, options, 'GET', '/api/v1/billing/subscription'), options);
+    return;
+  }
+  throw Object.assign(new Error(`Unknown billing command: ${action || ''}`), { exitCode: EXIT.USAGE });
+}
+
 async function analytics(config, options, action, args) {
   if (action === 'overview') {
     const suffix = queryString({ days: options.days ?? 30 });
@@ -1518,6 +2923,17 @@ function defaultExportStartBody(clipId) {
   };
 }
 
+function buildCanonicalExportStartBody(clipId, params, editorState, idempotencyKey) {
+  return {
+    ...defaultExportStartBody(clipId),
+    ...params,
+    clipId,
+    idempotencyKey,
+    expectedEditorVersion: editorState.editorVersion,
+    expectedEditorStateHash: editorState.editorStateHash,
+  };
+}
+
 async function pollExport(config, options, jobId) {
   const startedAt = Date.now();
   const timeoutMs = numberOption(options['timeout-ms'], '--timeout-ms');
@@ -1540,18 +2956,36 @@ async function exportsCommand(config, options, action, args) {
   if (action === 'start') {
     const clipId = requiredString(options['clip-id'], '--clip-id');
     const params = options.params ? await readJsonOption(String(options.params)) : {};
-    const body = {
-      ...defaultExportStartBody(clipId),
-      ...params,
+    if (!params || typeof params !== 'object' || Array.isArray(params)) {
+      throw Object.assign(new Error('--params must contain a JSON object.'), { exitCode: EXIT.USAGE });
+    }
+    const deliveryState = await fetchCanonicalClipDeliveryState(config, options, clipId);
+    const editorState = requireVerifiedEditorState(deliveryState, clipId);
+    const idempotencyKey = requiredString(
+      options['idempotency-key'] || params.idempotencyKey || `cli-export:${randomUUID()}`,
+      '--idempotency-key',
+    );
+    const body = buildCanonicalExportStartBody(
       clipId,
-    };
+      params,
+      editorState,
+      idempotencyKey,
+    );
     await enforceMaxCredits(config, options, 'exports start', { clipId, body });
     confirmPaid(options, 'Starting an export');
-    output(await apiFetch(config, options, 'POST', '/api/v1/exports', body), options);
+    const result = await apiFetch(config, options, 'POST', '/api/v1/exports', body);
+    output({
+      ...result,
+      clipId,
+      snapshotId: editorState.snapshotId,
+      expectedEditorVersion: body.expectedEditorVersion,
+      expectedEditorStateHash: body.expectedEditorStateHash,
+      idempotencyKey: body.idempotencyKey,
+    }, options);
     return;
   }
   if (action === 'list') {
-    output(await apiFetch(config, options, 'GET', `/api/v1/exports${queryString({ limit: options.limit, offset: options.offset })}`), options);
+    output(await apiFetch(config, options, 'GET', `/api/v1/exports${queryString({ limit: options.limit, offset: options.offset, clipId: options['clip-id'] })}`), options);
     return;
   }
   if (action === 'get') {
@@ -1572,38 +3006,83 @@ async function exportsCommand(config, options, action, args) {
   }
   if (action === 'cancel') {
     const jobId = requiredString(args[0], 'Export job id');
+    requireConfirm(options, 'Cancelling an export');
     output(await apiFetch(config, options, 'POST', `/api/v1/exports/${encodeURIComponent(jobId)}/cancel`, {}), options);
     return;
   }
   throw Object.assign(new Error(`Unknown exports command: ${action || ''}`), { exitCode: EXIT.USAGE });
 }
 
-function objectPathFromKey(key) {
-  return String(key).startsWith('/objects/') ? String(key) : `/objects/${key}`;
-}
-
-async function putSignedUpload(uploadUrl, filePath, contentType, size, options) {
-  let response;
-  const progress = createUploadProgress(options, size);
-  const body = createReadStream(filePath).pipe(progressTransform(progress));
-  try {
-    response = await fetch(uploadUrl, {
-      method: 'PUT',
-      headers: {
+async function putSignedUpload(uploadUrl, filePath, contentType, size, options, requiredHeaders) {
+  const headers = requiredHeaders && typeof requiredHeaders === 'object'
+    ? Object.fromEntries(Object.entries(requiredHeaders).map(([key, value]) => [key, String(value)]))
+    : {
         'Content-Type': contentType,
         'Content-Length': String(size),
-      },
-      body,
-      duplex: 'half',
-    });
-  } catch (error) {
-    throw Object.assign(new Error(`Upload failed: ${error.message}`), { exitCode: EXIT.NETWORK });
-  } finally {
-    progress.finish();
+      };
+  const requiredContentType = headers['Content-Type'] ?? headers['content-type'];
+  const requiredContentLength = headers['Content-Length'] ?? headers['content-length'];
+  if (requiredContentType !== contentType || requiredContentLength !== String(size)) {
+    throw Object.assign(
+      new Error('Upload signing response did not preserve the requested Content-Type and Content-Length headers.'),
+      { exitCode: EXIT.SERVER },
+    );
   }
-  if (!response.ok) {
-    const text = await response.text().catch(() => '');
-    throw Object.assign(new Error(`Upload failed: ${response.status} ${redact(text || response.statusText)}`), { exitCode: EXIT.SERVER });
+
+  for (let attempt = 0; attempt < VIDEO_UPLOAD_PART_ATTEMPTS; attempt += 1) {
+    const progress = createUploadProgress(options, size);
+    const controller = new AbortController();
+    let source;
+    let tracker;
+    const watchdog = createUploadActivityWatchdog(controller, () => {
+      source?.destroy();
+      tracker?.destroy();
+    });
+    try {
+      tracker = new Transform({
+        transform(chunk, encoding, callback) {
+          watchdog.activity();
+          progress.track(chunk);
+          callback(null, chunk);
+        },
+      });
+      source = createReadStream(filePath);
+      const response = await fetch(uploadUrl, {
+        method: 'PUT',
+        headers,
+        body: source.pipe(tracker),
+        duplex: 'half',
+        signal: controller.signal,
+      });
+      if (!response.ok) {
+        const text = await response.text().catch(() => '');
+        throw Object.assign(
+          new Error(`Upload failed: ${response.status} ${redact(text || response.statusText)}`),
+          { exitCode: EXIT.SERVER, status: response.status },
+        );
+      }
+      return;
+    } catch (error) {
+      const reason = controller.signal.aborted && controller.signal.reason instanceof Error
+        ? controller.signal.reason
+        : error;
+      const retryable = reason?.status === undefined
+        || reason.status === 408
+        || reason.status === 429
+        || reason.status >= 500;
+      if (attempt === VIDEO_UPLOAD_PART_ATTEMPTS - 1 || !retryable) {
+        throw Object.assign(new Error(`Upload failed: ${reason.message}`), {
+          exitCode: reason.exitCode || EXIT.NETWORK,
+          status: reason.status,
+        });
+      }
+      await sleep(VIDEO_UPLOAD_RETRY_BASE_MS * (2 ** attempt));
+    } finally {
+      watchdog.stop();
+      source?.destroy();
+      tracker?.destroy();
+      progress.finish();
+    }
   }
 }
 
@@ -1620,27 +3099,35 @@ async function uploadAsset(config, options, filePath) {
     contentType,
     size: stat.size,
     kind: options.kind,
+    idempotencyKey: `cli-library:${randomUUID()}`,
   });
+  requireConfirm(options, 'Uploading an asset');
   const signed = await apiFetch(config, options, 'POST', '/api/v1/assets/sign-upload', signBody);
-  if (!signed?.uploadUrl || !signed?.key || !signed?.assetId) {
+  const uploadUrl = signed?.uploadUrl || signed?.url;
+  if (!uploadUrl || !signed?.intentId || !signed?.assetId) {
     throw Object.assign(new Error('Asset sign-upload returned an unexpected response.'), { exitCode: EXIT.SERVER, data: signed });
   }
-  await putSignedUpload(signed.uploadUrl, resolved, contentType, stat.size, options);
-  const objectPath = objectPathFromKey(signed.key);
+  await putSignedUpload(uploadUrl, resolved, contentType, stat.size, options);
   output(await apiFetch(config, options, 'POST', `/api/v1/assets/${encodeURIComponent(signed.assetId)}/finalize`, {
-    objectPath,
-    fileSize: stat.size,
-    duration: options.duration === undefined ? null : numberOption(options.duration, '--duration'),
+    uploadIntentId: signed.intentId,
   }), options);
 }
 
 async function assets(config, options, action, args) {
   if (action === 'list') {
-    output(await apiFetch(config, options, 'GET', `/api/v1/assets${queryString({
+    const response = await apiFetch(config, options, 'GET', `/api/v1/assets${queryString({
       type: options.type,
       limit: options.limit,
       offset: options.offset,
-    })}`), options);
+    })}`, undefined, { includeResponseMetadata: true });
+    const items = Array.isArray(response.data) ? response.data : [];
+    const headerTotal = Number(response.headers['x-total-count']);
+    output({
+      items,
+      total: Number.isFinite(headerTotal) ? headerTotal : items.length,
+      limit: numberOption(options.limit, '--limit') ?? items.length,
+      offset: numberOption(options.offset, '--offset') ?? 0,
+    }, options);
     return;
   }
   if (action === 'upload') {
@@ -1747,13 +3234,83 @@ function socialPlatformList(value) {
   return platforms.map((platform) => platform.toLowerCase() === 'x' ? 'twitter' : platform);
 }
 
-function socialPostBody(options, scheduled) {
+function socialAccountIdPins(value) {
+  if (!value) return {};
+  const raw = String(value).trim();
+  if (!raw) return {};
+  if (raw.startsWith('{')) {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw Object.assign(new Error('--account-ids JSON must be an object of platform to account id.'), { exitCode: EXIT.USAGE });
+    }
+    return Object.fromEntries(Object.entries(parsed).map(([platform, accountId]) => [
+      platform.toLowerCase() === 'x' ? 'twitter' : platform.toLowerCase(),
+      requiredString(accountId, `account id for ${platform}`),
+    ]));
+  }
+  return Object.fromEntries(raw.split(',').filter(Boolean).map((entry) => {
+    const separator = entry.indexOf('=');
+    if (separator <= 0 || separator === entry.length - 1) {
+      throw Object.assign(new Error('--account-ids must use platform=accountId pairs.'), { exitCode: EXIT.USAGE });
+    }
+    const platform = entry.slice(0, separator).trim().toLowerCase();
+    const accountId = entry.slice(separator + 1).trim();
+    return [platform === 'x' ? 'twitter' : platform, accountId];
+  }));
+}
+
+async function socialPostBody(config, options, scheduled) {
+  const clipId = requiredString(options['clip-id'], '--clip-id');
+  const platforms = socialPlatformList(options.platforms);
+  const caption = requiredString(options.caption, '--caption');
+  const requestedExportId = options['export-id'];
+  const deliveryState = await fetchCanonicalClipDeliveryState(
+    config,
+    options,
+    clipId,
+    requestedExportId,
+  );
+  const editorState = requireVerifiedEditorState(deliveryState, clipId);
+  const selectedExport = requireExactCurrentExport(deliveryState, editorState, {
+    requestedExportId,
+    requireReadyToPublish: true,
+  });
+  const accountsResponse = await apiFetch(config, options, 'GET', '/api/v1/social/accounts');
+  const connectedAccounts = Array.isArray(accountsResponse?.accounts)
+    ? accountsResponse.accounts.filter((account) => account?.connected && typeof account?.accountId === 'string')
+    : [];
+  const requestedAccountIds = socialAccountIdPins(options['account-ids']);
+  const expectedAccountIds = Object.fromEntries(platforms.map((platform) => {
+    const choices = Array.from(new Set(connectedAccounts
+      .filter((account) => account.platform === platform)
+      .map((account) => account.accountId)));
+    const requestedAccountId = requestedAccountIds[platform];
+    if (requestedAccountId) {
+      if (!choices.includes(requestedAccountId)) {
+        throw Object.assign(new Error(`The selected ${platform} account id is not connected.`), { exitCode: EXIT.USAGE });
+      }
+      return [platform, requestedAccountId];
+    }
+    if (choices.length !== 1) {
+      const reason = choices.length === 0 ? 'no connected account' : 'multiple connected accounts';
+      throw Object.assign(
+        new Error(`${platform} has ${reason}. Run "clipit social accounts --json" and pass --account-ids ${platform}=<accountId>.`),
+        { exitCode: EXIT.USAGE },
+      );
+    }
+    return [platform, choices[0]];
+  }));
   const body = compactObject({
-    clipId: requiredString(options['clip-id'], '--clip-id'),
-    platforms: socialPlatformList(options.platforms),
-    caption: requiredString(options.caption, '--caption'),
+    clipId,
+    platforms,
+    caption,
     title: options.title,
     hashtags: stringList(options.hashtags),
+    exportId: selectedExport.exportId,
+    expectedSnapshotId: editorState.snapshotId,
+    expectedOutputObjectFingerprint: selectedExport.outputObjectFingerprint,
+    expectedAccountIds,
+    publishExactCurrentArtifact: true,
   });
   if (scheduled) body.scheduledFor = requiredString(options.at, '--at');
   return body;
@@ -1765,14 +3322,14 @@ async function social(config, options, action, args) {
     return;
   }
   if (action === 'post') {
-    const body = socialPostBody(options, false);
+    const body = await socialPostBody(config, options, false);
     await enforceMaxCredits(config, options, 'social post', { body });
     confirmPaid(options, 'Publishing a social post');
     output(await apiFetch(config, options, 'POST', '/api/v1/social/post', body), options);
     return;
   }
   if (action === 'schedule') {
-    const body = socialPostBody(options, true);
+    const body = await socialPostBody(config, options, true);
     await enforceMaxCredits(config, options, 'social schedule', { body });
     confirmPaid(options, 'Scheduling a social post');
     output(await apiFetch(config, options, 'POST', '/api/v1/social/schedule', body), options);
@@ -1809,19 +3366,41 @@ async function jobs(config, options, action, args) {
   const jobId = args[0];
   if (!jobId) throw Object.assign(new Error('Job id is required.'), { exitCode: EXIT.USAGE });
   const startedAt = Date.now();
-  const timeoutMs = numberOption(options['timeout-ms'], '--timeout-ms');
-  const intervalMs = numberOption(options.interval, '--interval') || 3000;
+  const requestedTimeoutMs = numberOption(options['timeout-ms'], '--timeout-ms');
+  const requestedIntervalMs = numberOption(options.interval, '--interval');
   while (true) {
     const job = await apiFetch(config, options, 'GET', `/api/v1/jobs/${encodeURIComponent(jobId)}`);
     if (action === 'get' || TERMINAL_JOB_STATUSES.has(job.status)) {
+      const videoId = job.videoId || job.result?.videoId;
+      const clipId = job.clipId || job.result?.clipId;
+      if (videoId || clipId) {
+        await persistActiveContext(
+          config,
+          options,
+          compactObject({ videoId, clipId }),
+          [
+            videoId ? { type: 'video', id: videoId } : null,
+            clipId ? { type: 'clip', id: clipId } : null,
+          ].filter(Boolean),
+        );
+      }
       output(job, options);
       return;
     }
-    if (options.stream) console.log(JSON.stringify({ type: 'job.progress', job }));
+    if (options.stream) console.log(JSON.stringify({ type: 'job.progress', job: redactDeep(job) }));
+    const serverMinimumWaitMs = typeof job.minimumWaitSeconds === 'number'
+      ? Math.max(0, job.minimumWaitSeconds * 1000)
+      : 0;
+    const timeoutMs = requestedTimeoutMs
+      ? Math.max(requestedTimeoutMs, serverMinimumWaitMs)
+      : undefined;
     if (timeoutMs && Date.now() - startedAt > timeoutMs) {
       throw Object.assign(new Error(`Timed out waiting for job ${jobId}.`), { exitCode: EXIT.SERVER });
     }
-    await sleep(intervalMs);
+    const serverIntervalMs = typeof job.recommendedPollIntervalSeconds === 'number'
+      ? Math.max(1000, job.recommendedPollIntervalSeconds * 1000)
+      : 0;
+    await sleep(requestedIntervalMs || serverIntervalMs || 3000);
   }
 }
 
@@ -1865,9 +3444,8 @@ async function appUrl(config, options, kind, id) {
     params.set('clip', id);
     return `${baseUrl}/clips/review?${params.toString()}`;
   }
-  // A video link should open that video's clips in the Review page (which keys
-  // off ?video=), not the generic /clips library list which has no selection.
-  if (kind === 'video') return `${baseUrl}/clips/review${id ? `?video=${encodeURIComponent(id)}` : ''}`;
+  // A video-level agent result should land in the Agent Content library tab.
+  if (kind === 'video') return `${baseUrl}/clips${id ? `?tab=agent&video=${encodeURIComponent(id)}` : '?tab=agent'}`;
   // The editor lives at /editor and reads ?project= (NOT /editor/projects, which
   // redirects to /clips and drops the query — the same dead-end class as the
   // clip/video link bug). There is no surface that consumes a raw sequenceId, so
@@ -1904,27 +3482,501 @@ async function links(config, options, kind, id) {
   output(result, options);
 }
 
+function mcpToolInputSchema(tool) {
+  const schema = tool?.inputSchema || tool?.parametersSchema || tool?.parameterSchema || tool?.parameters;
+  if (schema && typeof schema === 'object' && !Array.isArray(schema)) return schema;
+  return { type: 'object', additionalProperties: true };
+}
+
+function mcpToolConfirmationDescription(tool) {
+  if (!mcpToolRequiresConfirmation(tool, tool?.name)) return null;
+  const parts = [
+    tool?.confirmation?.riskLevel ? `risk=${tool.confirmation.riskLevel}` : null,
+    tool?.confirmation?.reason || null,
+  ].filter(Boolean);
+  if (parts.length) return parts.join('; ');
+
+  const costBand = String(tool?.costBand || tool?.cost_band || '').toLowerCase();
+  if (costBand && costBand !== 'free' && costBand !== 'none') {
+    return `cost=${costBand}; may spend credits or mutate user-visible ClipIt state. Ask the user before retrying with confirmed:true.`;
+  }
+  return 'may mutate user-visible ClipIt state. Ask the user before retrying with confirmed:true.';
+}
+
+function mcpToolDescription(tool) {
+  const confirmationDescription = mcpToolConfirmationDescription(tool);
+  return [
+    tool?.description,
+    tool?.skill ? `Skill: ${tool.skill}` : null,
+    tool?.costBand ? `Cost: ${tool.costBand}` : null,
+    confirmationDescription ? `Confirmation required: ${confirmationDescription}` : null,
+  ].filter(Boolean).join('\n');
+}
+
+function mcpToolRequiresConfirmation(tool, name) {
+  if (RUN_METERED_CONFIRMATION_EXEMPTIONS.has(name)) return false;
+  if (RUN_CONFIRMATION_LABELS[name]) return true;
+  if (tool?.confirmation?.required) return true;
+  if (tool?.requiresConfirmation === true) return true;
+  const costBand = String(tool?.costBand || tool?.cost_band || '').toLowerCase();
+  return Boolean(costBand && costBand !== 'free' && costBand !== 'none');
+}
+
+function readMcpMaxCredits(parameters) {
+  if (!parameters || typeof parameters !== 'object' || Array.isArray(parameters)) return null;
+  let raw;
+  for (const key of ['maxCredits', 'max_credits', 'maxCreditsClip']) {
+    if (raw === undefined && parameters[key] !== undefined) raw = parameters[key];
+    delete parameters[key];
+  }
+  if (raw === undefined) return null;
+  const limit = Number(raw);
+  if (!Number.isFinite(limit) || limit < 0) {
+    throw new Error('MCP tools/call maxCredits must be 0 or greater.');
+  }
+  return limit;
+}
+
+async function mcpEstimatePayload(config, options, tool, name, parameters, payload) {
+  const runEstimate = tool?.estimate ?? tool?.confirmation?.estimate ?? tool?.confirmation?.costEstimate ?? null;
+  if (runEstimate) {
+    const estimatedCostClip = estimatedClipCostFromData(runEstimate);
+    return compactObject({
+      estimate: compactObject({
+        estimatedCostClip,
+        estimatedCostLabel: estimatedCostClip === null ? undefined : clipCostLabel(estimatedCostClip),
+        affordable: runEstimate.affordable,
+        estimates: [runEstimate],
+      }),
+    });
+  }
+
+  try {
+    const estimates = await buildStaticRunEstimates(config, options, name, parameters, payload);
+    if (estimates?.length) {
+      const estimatedCostClip = estimates.reduce((sum, estimate) => sum + Number(estimate.estimatedCostClip ?? 0), 0);
+      return {
+        estimate: {
+          estimatedCostClip,
+          estimatedCostLabel: clipCostLabel(estimatedCostClip),
+          affordable: estimates.every((estimate) => estimate.affordable !== false),
+          estimates,
+        },
+      };
+    }
+  } catch (error) {
+    return { estimateUnavailable: redact(error.message || String(error)) };
+  }
+
+  const costBand = String(tool?.costBand || tool?.cost_band || '').toLowerCase();
+  if (costBand && costBand !== 'free' && costBand !== 'none') {
+    return { estimateUnavailable: 'No local cost estimate is available for this tool; use estimateOperationCost before approval when possible.' };
+  }
+  return {};
+}
+
+async function mcpMaxCreditsResult(config, options, tool, name, parameters, payload, maxCredits) {
+  if (maxCredits === null) return null;
+  const estimatePayload = await mcpEstimatePayload(config, options, tool, name, parameters, payload);
+  if (!estimatePayload.estimate) {
+    const costBand = String(tool?.costBand || tool?.cost_band || '').toLowerCase();
+    if (!mcpToolRequiresConfirmation(tool, name) && (!costBand || costBand === 'free' || costBand === 'none')) {
+      return null;
+    }
+    return {
+      error: 'max_credits_unenforceable',
+      functionName: name,
+      maxCredits,
+      maxCreditsLabel: clipCostLabel(maxCredits),
+      estimateUnavailable: estimatePayload.estimateUnavailable || 'No local cost estimate is available for this tool.',
+    };
+  }
+  const estimatedCostClip = Number(estimatePayload.estimate.estimatedCostClip);
+  if (!Number.isFinite(estimatedCostClip)) {
+    return {
+      error: 'max_credits_unenforceable',
+      functionName: name,
+      maxCredits,
+      maxCreditsLabel: clipCostLabel(maxCredits),
+      estimate: estimatePayload.estimate,
+      estimateUnavailable: 'The available estimate did not include an estimatedCostClip value.',
+    };
+  }
+  if (estimatedCostClip > maxCredits) {
+    return {
+      error: 'max_credits_exceeded',
+      functionName: name,
+      maxCredits,
+      maxCreditsLabel: clipCostLabel(maxCredits),
+      estimatedCostClip,
+      estimatedCostLabel: clipCostLabel(estimatedCostClip),
+      estimate: estimatePayload.estimate,
+    };
+  }
+  return null;
+}
+
+async function mcpConfirmationPayload(config, options, tool, name, parameters, payload, maxCredits = null) {
+  const reason = tool?.confirmation?.reason || `${name} may spend credits or mutate user-visible ClipIt state. Ask the user before retrying with confirmed:true.`;
+  const confirmation = compactObject({
+    requiresConfirmation: true,
+    functionName: name,
+    reason,
+    confirmation: tool?.confirmation || undefined,
+    confirmationParams: parameters,
+    retryArguments: {
+      ...(parameters || {}),
+      confirmed: true,
+      maxCredits: maxCredits ?? undefined,
+    },
+  });
+
+  Object.assign(confirmation, await mcpEstimatePayload(config, options, tool, name, parameters, payload));
+
+  return confirmation;
+}
+
+function mcpTextResult(value, isError = false) {
+  const text = typeof value === 'string' ? value : JSON.stringify(redactDeep(value), null, 2);
+  return compactObject({
+    content: [{ type: 'text', text }],
+    isError: isError || undefined,
+  });
+}
+
+async function fetchMcpTools(config, options) {
+  const response = await apiFetch(config, options, 'GET', '/api/v1/agent/tools');
+  return mergeMcpTools(Array.isArray(response?.tools) ? response.tools : []);
+}
+
+function mergeMcpTools(serverTools) {
+  const seen = new Set();
+  const merged = [];
+  for (const tool of [...LOCAL_MCP_BILLING_TOOLS, ...serverTools]) {
+    if (typeof tool?.name !== 'string' || seen.has(tool.name)) continue;
+    seen.add(tool.name);
+    merged.push(tool);
+  }
+  return merged;
+}
+
+function localMcpBillingTool(name) {
+  return LOCAL_MCP_BILLING_TOOLS.find((tool) => tool.name === name) || null;
+}
+
+async function handleLocalMcpBillingTool(config, options, name, parameters = {}) {
+  if (name === 'getPaymentCapabilities') {
+    return apiFetch(config, options, 'GET', '/api/v1/agent/payment-capabilities', undefined, { noAuth: true });
+  }
+  if (name === 'getBillingCatalog') {
+    return apiFetch(config, options, 'GET', '/api/v1/billing/catalog', undefined, { noAuth: true });
+  }
+  if (name === 'createPaymentAttempt') {
+    return apiFetch(config, options, 'POST', '/api/v1/billing/agent-payments', buildBillingAttemptBody(parameters));
+  }
+  if (name === 'getPaymentAttempt') {
+    const attemptId = requiredString(parameters.attemptId ?? parameters.attempt_id, 'attemptId');
+    return apiFetch(config, options, 'GET', `/api/v1/billing/agent-payments/${encodeURIComponent(attemptId)}`);
+  }
+  if (name === 'getPaymentReceipt') {
+    const attemptId = requiredString(parameters.attemptId ?? parameters.attempt_id, 'attemptId');
+    return apiFetch(config, options, 'GET', `/api/v1/billing/agent-payments/${encodeURIComponent(attemptId)}/receipt`);
+  }
+  if (name === 'getBillingSubscription') {
+    return apiFetch(config, options, 'GET', '/api/v1/billing/subscription');
+  }
+  throw Object.assign(new Error(`Unknown local billing tool: ${name}`), { exitCode: EXIT.USAGE });
+}
+
+async function handleMcpRequest(config, options, message) {
+  if (!message || typeof message !== 'object' || Array.isArray(message)) {
+    return { jsonrpc: '2.0', id: null, error: { code: -32600, message: 'Invalid JSON-RPC request.' } };
+  }
+
+  const id = message.id ?? null;
+  const method = message.method;
+  const isNotification = message.id === undefined;
+
+  if (method === 'notifications/initialized' || method === 'notifications/cancelled') return null;
+  if (method === 'initialize') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        protocolVersion: message.params?.protocolVersion || '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'clipit', version: VERSION },
+      },
+    };
+  }
+  if (method === 'ping') return isNotification ? null : { jsonrpc: '2.0', id, result: {} };
+  if (isNotification) return null;
+
+  if (method === 'tools/list') {
+    const tools = await fetchMcpTools(config, options);
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        tools: tools.map((tool) => ({
+          name: tool.name,
+          description: mcpToolDescription(tool),
+          inputSchema: mcpToolInputSchema(tool),
+        })).filter((tool) => typeof tool.name === 'string' && tool.name.length > 0),
+      },
+    };
+  }
+
+  if (method === 'tools/call') {
+    const name = typeof message.params?.name === 'string' ? message.params.name : null;
+    if (!name) {
+      return { jsonrpc: '2.0', id, error: { code: -32602, message: 'tools/call requires params.name.' } };
+    }
+    const parameters = message.params?.arguments && typeof message.params.arguments === 'object' && !Array.isArray(message.params.arguments)
+      ? { ...message.params.arguments }
+      : {};
+    const confirmed = parameters.confirmed === true || parameters.confirm === true;
+    delete parameters.confirm;
+    if (confirmed) parameters.confirmed = true;
+    else delete parameters.confirmed;
+    let maxCredits = null;
+    try {
+      maxCredits = readMcpMaxCredits(parameters);
+    } catch (error) {
+      return { jsonrpc: '2.0', id, error: { code: -32602, message: error.message } };
+    }
+    const tools = await fetchMcpTools(config, options);
+    const tool = tools.find((candidate) => candidate.name === name);
+    if (!tool) {
+      return { jsonrpc: '2.0', id, error: { code: -32602, message: `Unknown ClipIt tool: ${name}` } };
+    }
+    const localBillingTool = localMcpBillingTool(name);
+    const payload = {
+      functionName: name,
+      parameters,
+      confirmed,
+    };
+    if (localBillingTool) {
+      if (!confirmed && mcpToolRequiresConfirmation(localBillingTool, name)) {
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: mcpTextResult(await mcpConfirmationPayload(config, options, localBillingTool, name, parameters, payload, maxCredits)),
+        };
+      }
+      const result = await handleLocalMcpBillingTool(config, options, name, parameters);
+      return { jsonrpc: '2.0', id, result: mcpTextResult(result, Boolean(result?.error)) };
+    }
+    applyContextToAgentPayload(payload, parameters, await buildContext(config, options));
+    if (!confirmed && mcpToolRequiresConfirmation(tool, name)) {
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: mcpTextResult(await mcpConfirmationPayload(config, options, tool, name, parameters, payload, maxCredits)),
+      };
+    }
+    const maxCreditsResult = await mcpMaxCreditsResult(config, options, tool, name, parameters, payload, maxCredits);
+    if (maxCreditsResult) {
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: mcpTextResult(maxCreditsResult, true),
+      };
+    }
+    const result = normalizeAgentExecuteResult(await apiFetch(config, options, 'POST', '/api/v1/agent/execute', payload));
+    return { jsonrpc: '2.0', id, result: mcpTextResult(result, Boolean(result?.error)) };
+  }
+
+  return { jsonrpc: '2.0', id, error: { code: -32601, message: `Unsupported MCP method: ${method || ''}` } };
+}
+
+function mcpFrame(message) {
+  const body = JSON.stringify(redactDeep(message));
+  return `Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n${body}`;
+}
+
+function mcpHeaderEnd(buffer) {
+  const crlf = buffer.indexOf('\r\n\r\n');
+  const lf = buffer.indexOf('\n\n');
+  if (crlf === -1) return lf === -1 ? null : { index: lf, length: 2 };
+  if (lf === -1) return { index: crlf, length: 4 };
+  return crlf < lf ? { index: crlf, length: 4 } : { index: lf, length: 2 };
+}
+
+function mcpLooksFramed(buffer) {
+  const prefix = 'Content-Length:';
+  const sample = buffer.toString('utf8', 0, Math.min(buffer.length, prefix.length));
+  if (prefix.startsWith(sample)) return buffer.length < prefix.length ? null : true;
+  return false;
+}
+
+function readMcpFrame(buffer) {
+  const headerEnd = mcpHeaderEnd(buffer);
+  if (!headerEnd) return { incomplete: true, buffer };
+  const header = buffer.subarray(0, headerEnd.index).toString('utf8');
+  const match = /^Content-Length:\s*(\d+)\s*$/im.exec(header);
+  if (!match) {
+    return {
+      message: null,
+      error: { code: -32600, message: 'Invalid MCP frame: missing Content-Length header.' },
+      buffer: Buffer.alloc(0),
+    };
+  }
+  const contentLength = Number(match[1]);
+  const bodyStart = headerEnd.index + headerEnd.length;
+  const bodyEnd = bodyStart + contentLength;
+  if (buffer.length < bodyEnd) return { incomplete: true, buffer };
+  const body = buffer.subarray(bodyStart, bodyEnd).toString('utf8');
+  try {
+    return {
+      message: JSON.parse(body),
+      buffer: buffer.subarray(bodyEnd),
+    };
+  } catch (error) {
+    return {
+      message: null,
+      error: { code: -32700, message: `Parse error: ${error.message}` },
+      buffer: buffer.subarray(bodyEnd),
+    };
+  }
+}
+
+async function respondToMcpMessage(config, options, message, send) {
+  try {
+    send(await handleMcpRequest(config, options, message));
+  } catch (error) {
+    send({
+      jsonrpc: '2.0',
+      id: message?.id ?? null,
+      error: {
+        code: -32000,
+        message: redact(error.message || String(error)),
+        data: redactDeep(compactObject({ status: error.status, requestId: error.requestId, details: error.data })),
+      },
+    });
+  }
+}
+
+async function runMcpStdio(config, options) {
+  let framed = null;
+  let frameBuffer = Buffer.alloc(0);
+  let lineBuffer = '';
+  const send = (message) => {
+    if (!message) return;
+    if (framed) {
+      process.stdout.write(mcpFrame(message));
+      return;
+    }
+    process.stdout.write(`${JSON.stringify(redactDeep(message))}\n`);
+  };
+
+  const sendTransportError = (error) => send({ jsonrpc: '2.0', id: null, error });
+  const processLineBuffer = async (flush = false) => {
+    let newlineIndex = lineBuffer.indexOf('\n');
+    while (newlineIndex !== -1) {
+      const line = lineBuffer.slice(0, newlineIndex).trim();
+      lineBuffer = lineBuffer.slice(newlineIndex + 1);
+      newlineIndex = lineBuffer.indexOf('\n');
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch (error) {
+        sendTransportError({ code: -32700, message: `Parse error: ${error.message}` });
+        continue;
+      }
+      await respondToMcpMessage(config, options, message, send);
+    }
+    if (flush && lineBuffer.trim()) {
+      const line = lineBuffer.trim();
+      lineBuffer = '';
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch (error) {
+        sendTransportError({ code: -32700, message: `Parse error: ${error.message}` });
+        return;
+      }
+      await respondToMcpMessage(config, options, message, send);
+    }
+  };
+
+  for await (const chunk of process.stdin) {
+    const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    let appendedToFrame = false;
+    if (framed === null) {
+      frameBuffer = Buffer.concat([frameBuffer, chunkBuffer]);
+      appendedToFrame = true;
+      const decision = mcpLooksFramed(frameBuffer);
+      if (decision === null) continue;
+      framed = decision;
+      if (!framed) {
+        lineBuffer += frameBuffer.toString('utf8');
+        frameBuffer = Buffer.alloc(0);
+        await processLineBuffer();
+        continue;
+      }
+    }
+
+    if (!framed) {
+      lineBuffer += chunkBuffer.toString('utf8');
+      await processLineBuffer();
+      continue;
+    }
+
+    if (framed && !appendedToFrame) {
+      frameBuffer = Buffer.concat([frameBuffer, chunkBuffer]);
+    }
+    while (framed) {
+      const parsed = readMcpFrame(frameBuffer);
+      frameBuffer = parsed.buffer;
+      if (parsed.incomplete) break;
+      if (parsed.error) {
+        sendTransportError(parsed.error);
+        continue;
+      }
+      await respondToMcpMessage(config, options, parsed.message, send);
+    }
+  }
+
+  if (framed === false) await processLineBuffer(true);
+}
+
+async function mcp(config, options, action) {
+  if (action && action !== 'stdio') {
+    throw Object.assign(new Error(`Unknown mcp command: ${action}`), { exitCode: EXIT.USAGE });
+  }
+  await runMcpStdio(config, options);
+}
+
 async function examples(options) {
   const data = {
     login: 'clipit login',
     installCodexSkill: 'clipit agent install codex',
     validate: 'clipit doctor --json',
-    importUrl: 'clipit videos import-url "https://www.youtube.com/watch?v=..." --json',
+    uploadVideo: 'clipit videos upload ./source.mp4 --confirm --json',
+    importUrl: 'clipit videos import-url "https://www.youtube.com/watch?v=..." --confirm --json',
     waitForJob: 'clipit jobs wait <jobId> --json',
     ask: 'clipit ask "Find the strongest clip in this video" --video-id <videoId>',
     approveWorkflow: 'clipit workflow approve <jobId> --approval-id <approvalId> --decision approved',
     waitForWorkflow: 'clipit workflow wait <jobId> --stream',
     setContext: 'clipit context use --video-id <videoId>',
-    suggestClips: 'clipit videos suggest-clips <videoId> --count 5 --json',
-    createClip: 'clipit clips create --video-id <videoId> --start 12 --end 42 --title "Strong hook" --json',
-    renderClip: 'clipit clips render <clipId> --aspect 9:16 --quality high --json',
+    mcp: 'clipit mcp stdio',
+    suggestClips: 'clipit videos suggest-clips <videoId> --count 5 --confirm --json',
+    createClip: 'clipit clips create --video-id <videoId> --start 12 --end 42 --title "Strong hook" --confirm --json',
+    renderClip: 'clipit clips render <clipId> --aspect 9:16 --quality high --confirm --json',
     creditsBalance: 'clipit credits balance --json',
+    billingCapabilities: 'clipit billing capabilities --json',
+    billingCatalog: 'clipit billing catalog --json',
+    billingX402Attempt: 'clipit billing create-attempt --product-key boost --provider x402_direct --confirm --json',
+    billingStripeX402Attempt: 'clipit billing create-attempt --product-key boost --provider stripe_x402 --confirm --json',
+    billingLinkAttempt: 'clipit billing create-attempt --product-key boost --provider stripe_mpp --confirm --json',
     analyticsOverview: 'clipit analytics overview --days 30 --json',
     exportClip: 'clipit exports start --clip-id <clipId> --confirm --json',
-    uploadAsset: 'clipit assets upload ./brand-logo.png --kind image --json',
+    uploadAsset: 'clipit assets upload ./brand-logo.png --kind image --confirm --json',
     thumbnail: 'clipit thumbnails generate --clip-id <clipId> --prompt "Expressive high-contrast thumbnail" --confirm --json',
     brollPlan: 'clipit broll plan <clipId> --count 3 --confirm --json',
-    socialPost: 'clipit social post --clip-id <clipId> --platforms x,tiktok --caption "New clip" --confirm --json',
+    socialPost: 'clipit social post --clip-id <clipId> --platforms x,tiktok --account-ids x=<xAccountId>,tiktok=<tiktokAccountId> --caption "New clip" --confirm --json',
     runTool: 'clipit run <functionName> --clip-id <clipId> --params @params.json --json',
     reviewLink: 'clipit links clip <clipId> --json',
   };
@@ -1945,13 +3997,19 @@ Rules:
 - If not connected, ask the user to run \`clipit login\` and approve the browser link.
 - Never ask the user to paste API keys into chat.
 - Use \`clipit skills list --json\` and \`clipit tools list --json\` to discover capability.
+- Use \`clipit mcp stdio\` when an MCP-compatible client can launch local stdio servers; it speaks standard \`Content-Length\` framed JSON-RPC.
 - Prefer friendly commands such as \`clipit videos list --json\`, \`clipit clips list --json\`, \`clipit credits balance --json\`, and \`clipit jobs wait <jobId> --json\`.
 - Use \`clipit ask "..."\` for natural-language Clippy workflows, and \`clipit workflow wait <jobId> --json\` or \`clipit workflow approve <jobId> --approval-id <id>\` for workflow follow-through.
+- Use \`clipit ask "..." --auto-confirm-costly\` only when the human has asked you to work autonomously on ClipIt-only cost-spending tasks. It never authorizes social publishing/scheduling or destructive actions.
 - Use \`clipit run <functionName> --params @file.json --json\` for exact Clippy tools.
 - Treat paid generation, publishing, deletion, broad mutation, and \`requiresConfirmation\` responses as user approval checkpoints.
 - Treat exit code 13 as insufficient credits or an API key spend-limit block; top up billing or adjust the key's spend limit in ClipIt Settings.
+- When credits are insufficient, discover payment rails with \`clipit billing capabilities --json\` and \`clipit billing catalog --json\`.
+- Only create direct x402, Stripe-managed x402, or Stripe Link/SPT payment attempts after explicit human approval or a configured budget policy: \`clipit billing create-attempt --product-key <key> --provider x402_direct|stripe_x402|stripe_mpp --confirm --json\`.
+- Credits from subscriptions and top-ups stack; paid features are credit-gated, so verify the payment receipt or balance before running paid ClipIt tools.
 - Use \`clipit open clip <id>\` when the user should review work in ClipIt.
 - Use \`clipit context use --video-id <id>\` or \`clipit context use --clip-id <id>\` to persist the current target for later commands.
+- Run \`clipit social accounts --json\` before posting. If a platform has multiple connected accounts, pin the intended one with \`--account-ids platform=accountId\`; ClipIt will not guess.
 - Do not write API keys into this skill file or any project files.
 
 Useful commands:
@@ -1961,24 +4019,32 @@ clipit auth status --json
 clipit skills list --json
 clipit tools list --json
 clipit tools describe <functionName> --json
+clipit mcp stdio
 clipit ask "Find the strongest clip in this video" --video-id <videoId> --json
 clipit workflow wait <jobId> --stream
 clipit videos list --json
-clipit videos import-url "https://example.com/video" --json
+clipit videos upload ./source.mp4 --confirm --json
+clipit videos import-url "https://example.com/video" --confirm --json
 clipit videos transcript <videoId> --json
-clipit videos suggest-clips <videoId> --count 5 --json
+clipit videos suggest-clips <videoId> --count 5 --confirm --json
 clipit clips list --json
-clipit clips create --video-id <videoId> --start 12 --end 42 --title "Hook" --json
-clipit clips render <clipId> --aspect 9:16 --quality high --json
+clipit clips create --video-id <videoId> --start 12 --end 42 --title "Hook" --confirm --json
+clipit clips render <clipId> --aspect 9:16 --quality high --confirm --json
 clipit jobs wait <jobId> --stream
 clipit credits balance --json
 clipit credits usage --json
 clipit credits estimate --operation-type transcription --provider deepgram --metrics @metrics.json --json
+clipit billing capabilities --json
+clipit billing catalog --json
+clipit billing create-attempt --product-key boost --provider x402_direct --confirm --json
+clipit billing create-attempt --product-key boost --provider stripe_x402 --confirm --json
+clipit billing create-attempt --product-key boost --provider stripe_mpp --confirm --json
+clipit billing receipt <attemptId> --json
 clipit analytics overview --days 30 --json
 clipit exports start --clip-id <clipId> --confirm --json
 clipit thumbnails generate --clip-id <clipId> --prompt "High contrast thumbnail" --confirm --json
-clipit social post --clip-id <clipId> --platforms x,tiktok --caption "New clip" --confirm --json
-clipit run renderClipWithRemotion --clip-id <clipId> --params @params.json --json
+clipit social post --clip-id <clipId> --platforms x,tiktok --account-ids x=<xAccountId>,tiktok=<tiktokAccountId> --caption "New clip" --confirm --json
+clipit run renderClipWithRemotion --clip-id <clipId> --params @params.json --confirm --json
 \`\`\`
 
 Common workflow:
@@ -1992,6 +4058,28 @@ Agent target: ${agent}
 `;
 }
 
+function mcpSkillAddendum() {
+  return [
+    '## MCP Stdio Bridge',
+    '- If your agent runtime supports MCP stdio servers, prefer launching `clipit mcp stdio` from the user\'s machine instead of manually shelling every command.',
+    '- The bridge uses the authenticated CLI profile, speaks standard `Content-Length` framed JSON-RPC over stdio, and exposes the same live tools as `clipit tools list --json` / `GET /api/v1/agent/tools`.',
+    '- `tools/call` delegates to `/api/v1/agent/execute`, inherits the active CLI context from `clipit context use`, and preserves confirmation gates for paid generation, publishing, deletion, export, and other mutating calls.',
+    '- The bridge also exposes local billing discovery tools: `getPaymentCapabilities`, `getBillingCatalog`, `createPaymentAttempt`, `getPaymentAttempt`, `getPaymentReceipt`, and `getBillingSubscription`.',
+    '- `createPaymentAttempt` returns a payment URL for direct x402, Stripe-managed x402, or Stripe MPP/Link SPT settlement and requires `confirmed:true`; do not retry it until the human approves the product, amount, rail, and budget policy.',
+    '- If the MCP client cannot launch local commands, fall back to the CLI/API commands above.',
+  ].join('\n');
+}
+
+function withLocalCliSkillAddenda(markdown) {
+  const addenda = [];
+  let next = String(markdown || '');
+  if (!/clipit\s+mcp\s+stdio/i.test(next) && !/MCP Stdio Bridge/i.test(next)) {
+    next = `${next.trimEnd()}\n\n${mcpSkillAddendum()}\n`;
+    addenda.push('mcp-stdio-bridge');
+  }
+  return { markdown: next, addenda };
+}
+
 function fallbackSkillResult(target, reason) {
   const generatedAt = new Date().toISOString();
   return {
@@ -2041,10 +4129,14 @@ async function resolveAgentSkill(config, options, target) {
     });
   }
 
+  const augmented = withLocalCliSkillAddenda(response.markdown);
   return {
-    markdown: response.markdown,
+    markdown: augmented.markdown,
     source: 'server',
-    meta: response.meta,
+    meta: compactObject({
+      ...response.meta,
+      localCliAddenda: augmented.addenda.length ? augmented.addenda : undefined,
+    }),
   };
 }
 
@@ -2065,6 +4157,7 @@ function agentSkillSidecar(target, skill) {
     target,
     source: skill.source,
     generatedAt: skill.meta?.generatedAt,
+    markdownHash: hashText(skill.markdown),
     serverMeta: skill.source === 'server' ? skill.meta : undefined,
     fallbackReason: skill.fallbackReason,
   });
@@ -2088,7 +4181,11 @@ function agentInstallDir(target, options) {
 async function installedAgentStatus(target, options) {
   const baseDir = agentInstallDir(target, options);
   try {
-    const stat = await fs.stat(path.join(baseDir, 'SKILL.md'));
+    const skillPath = path.join(baseDir, 'SKILL.md');
+    const [stat, markdown] = await Promise.all([
+      fs.stat(skillPath),
+      fs.readFile(skillPath, 'utf8'),
+    ]);
     const sidecar = await readAgentSkillMeta(baseDir);
     return {
       target,
@@ -2098,6 +4195,7 @@ async function installedAgentStatus(target, options) {
       skillSource: sidecar?.source || 'unknown',
       generatedAt: sidecar?.generatedAt || null,
       fallbackReason: sidecar?.fallbackReason || null,
+      markdownHash: sidecar?.markdownHash || hashText(markdown),
       serverMeta: sidecar?.serverMeta || null,
     };
   } catch {
@@ -2105,6 +4203,24 @@ async function installedAgentStatus(target, options) {
   }
 }
 
+function agentFreshnessReason(status, currentSkill) {
+  const currentMeta = currentSkill.source === 'server' ? currentSkill.meta : null;
+  if (status.skillSource !== currentSkill.source) {
+    return `installed source ${status.skillSource || 'unknown'} differs from current source ${currentSkill.source}`;
+  }
+  if (status.serverMeta?.toolCount !== undefined
+    && currentMeta?.toolCount !== undefined
+    && status.serverMeta.toolCount !== currentMeta.toolCount) {
+    return `installed tool count ${status.serverMeta.toolCount} differs from current tool count ${currentMeta.toolCount}`;
+  }
+  if (status.serverMeta?.skillCount !== undefined
+    && currentMeta?.skillCount !== undefined
+    && status.serverMeta.skillCount !== currentMeta.skillCount) {
+    return `installed skill count ${status.serverMeta.skillCount} differs from current skill count ${currentMeta.skillCount}`;
+  }
+  return 'installed skill content differs from current generated instructions';
+}
+
 async function agent(config, options, action, args) {
   const target = args[0] || 'generic';
   const baseDir = agentInstallDir(target, options);
@@ -2121,12 +4237,41 @@ async function agent(config, options, action, args) {
   }
   if (action === 'doctor') {
     const status = await installedAgentStatus(target, options);
+    const hasCredential = Boolean(getApiKey(config, options));
     status.cli = {
       version: VERSION,
       configPath: configPath(),
       profile: profileName(config, options),
-      hasCredential: Boolean(getApiKey(config, options)),
+      hasCredential,
     };
+    if (status.installed) {
+      if (!hasCredential) {
+        status.upToDate = null;
+        status.stale = null;
+        status.freshnessError = 'Cannot verify installed skill freshness without credentials.';
+      } else {
+        const currentSkill = await resolveAgentSkill(config, options, target);
+        status.latest = compactObject({
+          skillSource: currentSkill.source,
+          generatedAt: currentSkill.meta?.generatedAt || null,
+          serverMeta: currentSkill.source === 'server' ? currentSkill.meta : undefined,
+          fallbackReason: currentSkill.fallbackReason,
+        });
+        if (currentSkill.source === 'fallback') {
+          status.upToDate = null;
+          status.stale = null;
+          status.freshnessError = `Cannot verify installed skill freshness: ${currentSkill.fallbackReason || 'current instructions unavailable'}`;
+        } else {
+          const currentHash = hashText(currentSkill.markdown);
+          status.upToDate = status.markdownHash === currentHash;
+          status.stale = !status.upToDate;
+          if (status.stale) {
+            status.staleReason = agentFreshnessReason(status, currentSkill);
+            status.updateCommand = `clipit agent update ${target}`;
+          }
+        }
+      }
+    }
     output(status, options);
     return;
   }
@@ -2160,6 +4305,10 @@ async function main() {
   const config = await readConfig();
   const [command, subcommand, ...rest] = positionals;
 
+  if (options.version === true || options.version === 'true') {
+    output({ version: VERSION }, options);
+    return;
+  }
   if (!command || options.help) {
     console.log(usage());
     return;
@@ -2176,17 +4325,20 @@ async function main() {
   if (command === 'auth' && subcommand === 'set-key') return setKey(config, options);
   if (command === 'auth' && subcommand === 'open-settings') return openCommand(config, options, 'settings');
   if (command === 'auth' && subcommand === 'profiles') return listProfiles(config, options);
+  if (command === 'auth' && subcommand === 'use') return useProfile(config, options, rest[0]);
   if (command === 'context') return contextCommand(config, options, subcommand);
   if (command === 'skills' && subcommand === 'list') return listSkills(config, options);
   if (command === 'tools' && subcommand === 'list') return listTools(config, options);
   if (command === 'tools' && subcommand === 'describe') return describeTool(config, options, rest[0]);
   if (command === 'ask') return askWorkflow(config, options, [subcommand, ...rest]);
   if (command === 'workflow') return workflow(config, options, subcommand, rest);
+  if (command === 'mcp') return mcp(config, options, subcommand);
   if (command === 'run') return runTool(config, options, subcommand);
   if (command === 'videos') return videos(config, options, subcommand, rest);
   if (command === 'clips') return clips(config, options, subcommand, rest);
   if (command === 'jobs') return jobs(config, options, subcommand, rest);
   if (command === 'credits') return credits(config, options, subcommand, rest);
+  if (command === 'billing') return billing(config, options, subcommand, rest);
   if (command === 'analytics') return analytics(config, options, subcommand, rest);
   if (command === 'exports') return exportsCommand(config, options, subcommand, rest);
   if (command === 'assets') return assets(config, options, subcommand, rest);
@@ -2213,6 +4365,9 @@ function handleMainError(error) {
     }), null, 2));
   } else {
     console.error(message);
+    const details = redactDeep(error.data);
+    if (details?.resumeCommand) console.error(`Resume with: ${details.resumeCommand}`);
+    if (details?.abortCommand) console.error(`Abort the prior upload with: ${details.abortCommand}`);
   }
   process.exit(exitCode);
 }
@@ -2235,4 +4390,18 @@ if (await isDirectRun()) {
   main().catch(handleMainError);
 }
 
-export { main, redact };
+export {
+  buildCanonicalExportStartBody,
+  main,
+  redact,
+  clipCostLabel,
+  requireExactCurrentExport,
+  requireVerifiedEditorState,
+  handleMcpRequest,
+  readPositiveIntegerEnv,
+  readSecretLine,
+  readVideoUploadResumes,
+  removeVideoUploadResume,
+  saveVideoUploadResume,
+  shellQuote,
+};