aimakeall-mcp 0.14.1 → 0.14.3

package/README.md

@@ -5,6 +5,14 @@ Claude Code·Codex 같은 MCP 클라이언트에서 자연어로 AImakeAll 영
 - **클라우드 툴**: 기획 → 씬 이미지/영상 생성 → TTS/음악 → 타임라인 스티치 → YouTube 퍼블리시 (PAT 인증, aimakeall.com API)
 - **로컬 툴**: mp4 렌더 — **항상 이 PC의 AImakeAll 컴패니언(127.0.0.1:9876)에서 수행**됩니다. 서버는 렌더하지 않습니다.
 
+## 0.14.3 리뷰 분석 업데이트
+
+전편 분석의 서버 실행 방식 조회, 계정·서버별 체크포인트 고정, 알려진 작업의 읽기 전용
+복구를 추가했습니다. 공유 큐 실행은 서버가 명시적으로 제공할 때만 사용합니다.
+기존 단일 서버에서는 명시된 동기 실행 방식을 유지하며, 요청 실패 후 유료 작업을
+자동으로 다시 생성하지 않습니다. 이는 운영 PostgreSQL·자동 확장 활성화를 의미하지 않습니다.
+실행 중인 제작은 먼저 완료한 뒤 MCP를 재연결하세요. 설치용 부트스트랩 버전은 그대로입니다.
+
 ## 설정
 
 macOS·Windows에서 **Node.js 20 이상**이 필요합니다.

package/lib/api-client.mjs

@@ -1,9 +1,20 @@
 import { MCP_PROXY_VERSION } from "./config.mjs";
+import { attachReviewStoryJobFailureMetadata, REVIEW_STORY_JOBS } from "./review-story-job-request.mjs";
+import { attachReviewNativeJobFailureMetadata } from "./review-native-job-request.mjs";
 
 // aimakeall.com API 클라이언트 — PAT(Bearer) 인증 + 프록시 버전 핸드셰이크.
 // 서버 오류 코드를 사용자 행동 가능한 한국어 안내로 매핑한다.
 
 const DEFAULT_TIMEOUT_MS = 60_000;
+const clientAuthorities = new WeakMap();
+// Authenticated transports must not silently use the token captured by an old
+// API client after its caller's config changed. Non-HTTP test adapters return
+// null; the actual client identity remains private and exposes no credential.
+export function matchesApiClientAuthority(client, { apiBase, pat } = {}) {
+  const binding = clientAuthorities.get(client);
+  return binding ? typeof pat === "string" && pat.length > 0 && binding.pat === pat
+    && binding.apiBase === String(apiBase || "").replace(/\/$/u, "") : null;
+}
 
 export class AimakeallApiError extends Error {
   constructor(message, { errorCode = "", retryAfterSeconds = 0, status = 0, accountCostEvents, acceptedTaskCosts, operationId, costUsd, usage, partialProviderUsage, fallbackMetadata } = {}) {
@@ -42,7 +53,7 @@ function describeApiFailure(status, payload) {
 }
 
 export function createApiClient({ apiBase, pat }) {
-  async function request(pathName, { method = "GET", body, timeoutMs = DEFAULT_TIMEOUT_MS, rawBody, headers = {} } = {}) {
+  async function request(pathName, { method = "GET", body, timeoutMs = DEFAULT_TIMEOUT_MS, rawBody, headers = {}, signal, cache } = {}) {
     const requestHeaders = {
       Authorization: `Bearer ${pat}`,
       "X-AImakeAll-MCP-Version": MCP_PROXY_VERSION,
@@ -62,7 +73,8 @@ export function createApiClient({ apiBase, pat }) {
       ...(rawBody !== undefined && typeof rawBody?.pipe !== "function" && rawBody?.[Symbol.asyncIterator] ? { duplex: "half" } : {}),
       headers: requestHeaders,
       method,
-      signal: AbortSignal.timeout(timeoutMs),
+      signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs),
+      ...(cache === undefined ? {} : { cache }),
     });
 
     const text = await response.text();
@@ -74,7 +86,7 @@ export function createApiClient({ apiBase, pat }) {
     }
 
     if (!response.ok) {
-      throw new AimakeallApiError(describeApiFailure(response.status, payload), {
+      const error = new AimakeallApiError(describeApiFailure(response.status, payload), {
         errorCode: String(payload?.code || payload?.error || ""),
         retryAfterSeconds: Number(payload?.retryAfterSeconds) || Number(response.headers.get("retry-after")) || 0,
         status: response.status,
@@ -83,6 +95,9 @@ export function createApiClient({ apiBase, pat }) {
         usage: payload?.usage, partialProviderUsage: payload?.partialProviderUsage,
         fallbackMetadata: payload,
       });
+      if (pathName === REVIEW_STORY_JOBS) attachReviewStoryJobFailureMetadata(error, payload);
+      if (["/api/tracker/review/chunk-jobs", "/api/tracker/review/evidence-jobs"].includes(pathName)) attachReviewNativeJobFailureMetadata(error, payload);
+      throw error;
     }
     return payload;
   }
@@ -229,5 +244,7 @@ export function createApiClient({ apiBase, pat }) {
     return { events, result };
   }
 
-  return { request, requestBinary, requestSse, requestStreamUpload };
+  const client = { request, requestBinary, requestSse, requestStreamUpload };
+  clientAuthorities.set(client, { apiBase: String(apiBase || "").replace(/\/$/u, ""), pat });
+  return client;
 }

package/lib/cloud-tools.mjs

@@ -23,7 +23,8 @@ import {
 import { audioDurationSecFromFile } from "./audio-duration.mjs";
 import { canonicalYoutubeWatchUrl } from "./payload-guard.mjs";
 import { createUsageEventId } from "./usage-event.mjs";
-import { fetchGenerationJob, GENERATION_JOB_PATH, submitGenerationJob } from "./generation-jobs.mjs";
+import { fetchGenerationJob, GENERATION_JOB_PATH, submitGenerationJob, requestGenerationJobAction } from "./generation-jobs.mjs";
+import { durableSpeechToolSchema, submitDurableSpeech, durableSpeechResult } from "./durable-speech.mjs";
 import { loudnessDbfsFromWav, silenceRatioFromWav } from "./wav-dsp.mjs";
 import { trimWavToSeconds } from "./wav-trim.mjs";
 import { registerComposerTools } from "./composer-tools.mjs";
@@ -203,6 +204,7 @@ export function registerCloudTools(server, config, api) {
   registerComposerTools(server, config, api);
   registerReviewTools(server, config, api, { wrap: handler => wrapCloudHandler(config, handler) });
   async function completedGenerationResult(job, includePreview) {
+    if (job.kind === "tts") return jsonResult(durableSpeechResult(job, config));
     const payload = job.result || {};
     const resultBody = { generationJobId: job.id, status: job.status, kind: job.kind,
       model: payload.model, taskId: payload.taskId, providerTasks: job.providerTasks };
@@ -242,21 +244,49 @@ export function registerCloudTools(server, config, api) {
 
   server.tool(
     "get_generation_job",
-    "generate_scene_image/video가 반환한 generationJobId의 상태·결과를 조회합니다. running이면 잠시 뒤 다시 조회하고, completed의 imageUrl/videoUrl로 다음 단계를 진행하세요. MCP를 재시작해도 같은 ID로 회수할 수 있습니다.",
+    "이미지·영상·start_speech_generation의 generationJobId 상태·결과를 조회합니다. running이면 같은 ID를 다시 조회하세요. TTS 완료는 서버 소유 오디오 링크를 반환하며 다운로드·재합성하지 않습니다. MCP 재시작 뒤에도 같은 ID를 사용하세요.",
     { generationJobId: z.string(), includePreview: z.boolean().optional().describe("이미지/대표 프레임 미리보기 포함. 미지정 시 생성 요청의 returnImage/returnFrames 설정 유지") },
     wrapCloudHandler(config, async ({ generationJobId, includePreview }) => {
       const job = await fetchGenerationJob(api, generationJobId);
       if (job.status === "completed") return completedGenerationResult(job, includePreview ?? job.includePreview ?? true);
       return textResult(JSON.stringify({ generationJobId: job.id, kind: job.kind, status: job.status,
-        providerTasks: job.providerTasks, error: job.error,
-        guidance: job.status === "running" ? "생성 중입니다. 5~10초 후 이 ID를 다시 조회하세요. 새로 생성하지 마세요." : "비용 원장과 providerTasks를 먼저 확인하세요. 실패·중단 작업을 자동 재생성하지 마세요." }, null, 2),
+        providerTasks: job.providerTasks, error: job.error, workflow: job.workflow,
+        ...(job.status === "cancelled" ? { result: job.result } : {}),
+        guidance: job.status === "running" ? "생성 중입니다. 5~10초 후 이 ID를 다시 조회하세요. 새로 생성하지 마세요."
+          : ["cancel_requested", "cancelled"].includes(job.status) ? "취소 의도가 저장되어 있습니다. 공급자 중단·환불을 의미하지 않습니다. 이미 접수된 작업과 비용 원장을 확인하세요."
+            : job.workflow?.canResume ? "resume_generation_job으로 이미 접수된 작업의 상태만 복구할 수 있습니다. 새 유료 생성을 제출하지 마세요."
+              : "비용 원장과 providerTasks를 먼저 확인하세요. 실패·중단 작업을 자동 재생성하지 마세요." }, null, 2),
       { isError: job.status === "failed" || job.status === "interrupted" });
     }),
   );
 
+  server.tool(
+    "start_speech_generation",
+    "지정한 ElevenLabs/Typecast/Supertone 한 곳에 비동기 내레이션 작업을 접수합니다. 공유 실행 저장소가 필요합니다. requestId를 유지하고 get_generation_job으로 조회하세요. 대체 공급자·자동 재합성·기존 바이너리 TTS로 전환하지 않으며, 완료 오디오는 서버 소유 링크로 반환됩니다.",
+    durableSpeechToolSchema,
+    wrapCloudHandler(config, async input => {
+      const result = await submitDurableSpeech(api, input);
+      return textResult(JSON.stringify(result, null, 2), { isError: ["unavailable", "rejected"].includes(result.status) });
+    }),
+  );
+
+  server.tool(
+    "resume_generation_job",
+    "내 계정의 기존 생성 작업에서 접수된 공급자 작업 상태·결과를 복구합니다. 원래 유료 생성은 다시 제출하지 않습니다. get_generation_job의 workflow.canResume이 true일 때 사용하세요.",
+    { generationJobId: z.string() },
+    wrapCloudHandler(config, async ({ generationJobId }) => jsonResult(await requestGenerationJobAction(api, generationJobId, "resume"))),
+  );
+
+  server.tool(
+    "cancel_generation_job",
+    "내 계정의 기존 생성 작업에 취소 의도를 저장하고 가능한 로컬 대기를 중단합니다. 공급자 작업 중단·환불을 보장하지 않으며 접수된 작업과 비용 기록은 유지합니다.",
+    { generationJobId: z.string() },
+    wrapCloudHandler(config, async ({ generationJobId }) => jsonResult(await requestGenerationJobAction(api, generationJobId, "cancel"))),
+  );
+
   server.tool(
     "list_generation_jobs",
-    "내 계정의 최근 이미지·영상 생성 작업 ID와 상태를 조회합니다. 연결이 끊기거나 MCP를 재시작했을 때 결과를 복구하고 중복 생성을 피하는 데 사용하세요.",
+    "내 계정의 최근 이미지·영상·음성 생성 작업 ID와 상태를 조회합니다. 연결이 끊기거나 MCP를 재시작했을 때 결과를 복구하고 중복 생성을 피하는 데 사용하세요.",
     {},
     wrapCloudHandler(config, async () => jsonResult(await api.request(GENERATION_JOB_PATH, { timeoutMs: 30_000 }))),
   );

package/lib/config.mjs

@@ -2,7 +2,7 @@ import { homedir } from "node:os";
 import path from "node:path";
 
 // 프록시 버전 — 서버가 X-AImakeAll-MCP-Version 으로 하한을 강제(426)할 수 있다.
-export const MCP_PROXY_VERSION = "0.14.1";
+export const MCP_PROXY_VERSION = "0.14.3";
 
 export const DEFAULT_API_BASE = "https://aimakeall.com";
 export const DEFAULT_COMPANION_URL = "http://127.0.0.1:9876";

package/lib/durable-speech.mjs

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { DEFAULT_API_BASE } from "./config.mjs";
+import { GENERATION_JOB_PATH } from "./generation-jobs.mjs";
+
+const ID = /^[a-zA-Z0-9_-]{16,80}$/u, PROVIDERS = ["elevenlabs", "typecast", "supertone"];
+const MODELS = Object.freeze({ elevenlabs: "elevenlabs-multilingual-v2", typecast: "typecast-narration", supertone: "supertone-narration" });
+const common = ["voice", "voiceId", "modelId", "fileName", "speed"];
+const perProvider = Object.freeze({ elevenlabs: ["languageCode", "similarityBoost", "speakerBoost", "stability", "style"],
+  typecast: ["language", "emotion", "pitch", "smartEmotion", "volume"], supertone: ["language", "lang", "style"] });
+const invalid = () => new Error("Invalid durable speech request or result.");
+const short = max => z.string().max(max);
+const optionsSchema = z.object({ voice: short(320).optional(), voiceId: short(160).optional(), modelId: short(100).optional(), fileName: short(240).optional(),
+  languageCode: short(20).optional(), language: short(20).optional(), lang: short(20).optional(), emotion: short(160).optional(),
+  speed: z.number().min(0.5).max(2).optional(), similarityBoost: z.number().min(0).max(1).optional(), stability: z.number().min(0).max(1).optional(),
+  style: z.union([z.number().min(0).max(1), short(160)]).optional(), speakerBoost: z.boolean().optional(), smartEmotion: z.boolean().optional(),
+  pitch: z.number().int().min(-12).max(12).optional(), volume: z.number().int().min(0).max(200).optional(),
+}).strict();
+export const durableSpeechToolSchema = Object.freeze({
+  requestId: z.string().regex(ID).describe("새 작업의 고유 ID. 응답이 끊겨도 이 ID를 유지하고 먼저 상태를 조회하세요."),
+  provider: z.enum(PROVIDERS).describe("지정 공급자만 사용합니다. 자동 선택·대체 공급자 재합성 없음"),
+  text: z.string().min(1).max(10000).describe("전체 내레이션. 최대 5,000자, Supertone은 300자"),
+  options: optionsSchema.optional().describe("해당 공급자의 보이스·모델·언어·속도 옵션. 비용 이벤트/실행 상태는 전달하지 마세요."),
+});
+function capture(value) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) throw invalid();
+  const props = Object.getOwnPropertyDescriptors(value);
+  if (Reflect.ownKeys(props).some(key => !["requestId", "provider", "text", "options"].includes(key) || !Object.hasOwn(props[key], "value"))) throw invalid();
+  const options = props.options?.value;
+  if (options !== undefined && (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options))
+    || Reflect.ownKeys(Object.getOwnPropertyDescriptors(options)).some(key => typeof key !== "string" || !Object.hasOwn(Object.getOwnPropertyDescriptor(options, key), "value")))) throw invalid();
+  const parsed = z.object(durableSpeechToolSchema).strict().parse(value), { provider } = parsed;
+  if (!parsed.text.isWellFormed() || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u.test(parsed.text)
+    || !parsed.text.trim() || Array.from(parsed.text).length > (provider === "supertone" ? 300 : 5000)) throw invalid();
+  const rawOptions = parsed.options || {};
+  if (Object.keys(rawOptions).some(key => ![...common, ...perProvider[provider]].includes(key))) throw invalid();
+  for (const [key, value] of Object.entries(rawOptions)) {
+    if (typeof value === "string" && (!value.isWellFormed() || /[\u0000-\u001f\u007f]/u.test(value))) throw invalid();
+    if (["voiceId", "modelId"].includes(key) && value && !/^[A-Za-z0-9_.:-]+$/u.test(value)) throw invalid();
+  }
+  if (provider === "elevenlabs" && (rawOptions.speed !== undefined && (rawOptions.speed < 0.7 || rawOptions.speed > 1.2)
+    || rawOptions.style !== undefined && typeof rawOptions.style !== "number")
+    || provider === "supertone" && rawOptions.style !== undefined && typeof rawOptions.style !== "string") throw invalid();
+  return { requestId: parsed.requestId, input: { provider, text: parsed.text.trim(), ...rawOptions, allowProviderFallback: false } };
+}
+
+/** One JSON submit only. Neither errors nor a missing shared backend may invoke
+ * the legacy binary tool, switch provider, or create a replacement request ID. */
+export async function submitDurableSpeech(api, value) {
+  const { requestId, input } = capture(value), base = { generationJobId: requestId, kind: "tts", paidReplayAllowed: false, nextTool: "get_generation_job" };
+  try {
+    const response = await api.request(GENERATION_JOB_PATH, { method: "POST", timeoutMs: 30000, body: { id: requestId, kind: "tts", input, includePreview: false } });
+    if (response?.job?.id !== requestId || response.job.kind !== "tts" || !["pending", "running", "completed", "failed", "interrupted", "cancel_requested", "cancelled"].includes(response.job.status)) throw invalid();
+    return { ...base, status: response.job.status, existing: response.existing === true,
+      guidance: "이 ID를 get_generation_job으로 조회하세요. 완료 전 새 TTS 작업이나 바이너리 합성 도구로 다시 요청하지 마세요." };
+  } catch (error) {
+    const code = typeof error?.errorCode === "string" && /^[A-Z][A-Z0-9_]{0,99}$/u.test(error.errorCode) ? error.errorCode : "SPEECH_SUBMISSION_UNCONFIRMED";
+    if (code === "MACHINE_TTS_DURABLE_WORKLOAD_REQUIRED") return { ...base, status: "unavailable", code,
+      guidance: "서버의 공유 TTS 실행 저장소가 준비되지 않았습니다. 자동 재시도나 기존 바이너리 합성으로 전환하지 마세요." };
+    return { ...base, status: Number(error?.status) >= 400 && Number(error?.status) < 500 ? "rejected" : "unknown", code,
+      guidance: "이 작업 ID로 먼저 상태를 조회하세요. 접수 결과가 불명확하면 새 ID 제출·공급자 교체·바이너리 재합성을 하지 마세요." };
+  }
+}
+
+/** Pure URL projection only: no fetch and no PAT-bearing request to an asset.
+ * Only the configured server's canonical protected filename and its asset_sig
+ * may leave this helper; provider URLs, credentials and unrelated query data do
+ * not become clickable output. */
+export function durableSpeechResult(job, { apiBase = DEFAULT_API_BASE } = {}) {
+  const payload = job?.result;
+  if (!ID.test(job?.id || "") || job.kind !== "tts" || job.status !== "completed" || !PROVIDERS.includes(payload?.provider)
+    || payload.primaryProvider !== payload.provider || !/^user-[a-f0-9]{24}-[A-Za-z0-9._-]+$/u.test(payload.filename || "")
+    || payload.filename.includes("..") || payload.filename.length > 512 || !["audio/mpeg", "audio/wav", "audio/ogg", "audio/mp4"].includes(payload.contentType)) throw invalid();
+  const base = new URL(apiBase), rawUrl = payload.assetUrl;
+  if (!["https:", "http:"].includes(base.protocol) || base.username || base.password || base.search || base.hash
+    || typeof rawUrl !== "string" || rawUrl.length > 8192 || /[\s\\\u0000-\u001f\u007f]/u.test(rawUrl) || rawUrl.startsWith("//")) throw invalid();
+  const url = new URL(rawUrl, base.origin);
+  if (url.origin !== base.origin || url.username || url.password || url.hash || url.pathname !== `/api/tracker/extension/assets/${encodeURIComponent(payload.filename)}`
+    || ![url.href, `${url.pathname}${url.search}`].includes(rawUrl)
+    || [...url.searchParams.keys()].some(key => key !== "asset_sig") || url.searchParams.getAll("asset_sig").length > 1
+    || url.searchParams.has("asset_sig") && !/^[A-Za-z0-9_-]{43}$/u.test(url.searchParams.get("asset_sig"))) throw invalid();
+  const cost = payload.accountCostEvents?.[0];
+  if (payload.hasAccountCostEvents !== true || !Array.isArray(payload.accountCostEvents) || payload.accountCostEvents.length !== 1
+    || !cost || cost.provider !== payload.provider || cost.model !== MODELS[payload.provider] || !/^tts-job-v1:[a-f0-9]{64}$/u.test(cost.accountCostEventId || "")
+    || payload.accountCostEventId !== cost.accountCostEventId || payload.accountCostRecorded !== cost.accountCostRecorded
+    || payload.accountCostSuppressedByReset !== cost.accountCostSuppressedByReset
+    || typeof cost.costUsd !== "number" || !Number.isFinite(cost.costUsd) || cost.costUsd < 0 || cost.costUsd > 10000
+    || !Number.isSafeInteger(cost.createdAt) || cost.createdAt < 1
+    || !(cost.accountCostRecorded === true && cost.accountCostSuppressedByReset !== true || cost.accountCostRecorded === false && cost.accountCostSuppressedByReset === true)) throw invalid();
+  const receipt = { accountCostEventId: cost.accountCostEventId, model: cost.model, provider: cost.provider, createdAt: cost.createdAt,
+    costUsd: cost.costUsd, accountCostRecorded: cost.accountCostRecorded, ...(cost.accountCostSuppressedByReset === true ? { accountCostSuppressedByReset: true } : {}) };
+  return { generationJobId: job.id, status: "completed", kind: "tts", provider: payload.provider, filename: payload.filename, contentType: payload.contentType,
+    serverUrl: base.origin, assetPath: `${url.pathname}${url.search}`, assetUrl: url.href, ...receipt, hasAccountCostEvents: true, accountCostEvents: [receipt],
+    guidance: "오디오가 서버의 계정 소유 자산으로 저장되었습니다. 이 링크를 사용하세요. 이 도구는 오디오를 다운로드하거나 PAT를 자산 요청에 전달하지 않습니다." };
+}

package/lib/generation-jobs.mjs

@@ -37,3 +37,18 @@ export async function fetchGenerationJob(api, generationJobId) {
   if (!response?.job || response.job.id !== id) throw new Error("생성 작업 상태 응답이 올바르지 않습니다.");
   return response.job;
 }
+
+// Both actions operate on the authenticated owner's existing job only. Resume
+// observes accepted provider receipts; it never resubmits the original request.
+export async function requestGenerationJobAction(api, generationJobId, action) {
+  const id = assertGenerationJobId(generationJobId);
+  if (!["resume", "cancel"].includes(action)) throw new Error("지원하지 않는 생성 작업 동작입니다.");
+  const response = await api.request(`${GENERATION_JOB_PATH}/${encodeURIComponent(id)}/${action}`, { method: "POST", timeoutMs: 30_000 });
+  if (!response?.job || response.job.id !== id || response.job.workflow?.paidReplayAllowed !== false) throw new Error("생성 작업 상태 응답이 올바르지 않습니다.");
+  return { generationJobId: id, kind: response.job.kind, status: response.job.status,
+    workflow: response.job.workflow, providerTasks: response.job.providerTasks, existing: response.existing === true,
+    nextTool: "get_generation_job",
+    guidance: action === "resume"
+      ? "접수된 공급자 작업의 상태·결과만 복구합니다. 유료 생성을 다시 제출하지 않습니다. get_generation_job으로 이 ID를 조회하세요."
+      : "취소 의도를 저장했습니다. 공급자 작업 중단·비용 환불은 보장하지 않습니다. 이미 접수된 작업과 비용 기록은 유지되므로 get_generation_job으로 확인하세요." };
+}

package/lib/review-full-analysis.mjs

@@ -4,6 +4,10 @@ import path from "node:path";
 import { savePayloadHandle } from "./media-store.mjs";
 import { canonicalYoutubeWatchUrl } from "./payload-guard.mjs";
 import { inspectReviewLocalFile, readReviewHandle, reviewPublicSources, validateReviewSources } from "./review-sources.mjs";
+import { createReviewStoryJobClient, REVIEW_STORY_TRANSPORT } from "./review-story-job-request.mjs";
+import { createReviewNativeJobClient, REVIEW_NATIVE_TRANSPORT, unwrapReviewNativeJobResult } from "./review-native-job-request.mjs";
+import { DEFAULT_API_BASE } from "./config.mjs";
+import { matchesApiClientAuthority } from "./api-client.mjs";
 
 const KIND = "aimakeall-review-full-analysis";
 const MAX_CHUNK_BYTES = 10 * 1024 * 1024;
@@ -68,14 +72,64 @@ function lockAnalysis(config, analysisId) {
 function receipt(value, stage, chunkId = "") {
   return { stage, chunkId, ...Object.fromEntries(RECEIPT_KEYS.filter(key => value?.[key] !== undefined).map(key => [key, value[key]])) };
 }
+function upsertStoryReceipt(state, value, operationId) {
+  upsertStageReceipt(state, value, operationId, "synthesizing");
+}
+function upsertStageReceipt(state, value, operationId, stage, chunkId = "") {
+  const item = { ...receipt(value, stage, chunkId), clientOperationId: operationId };
+  const index = state.receipts.findIndex(row => row.clientOperationId === operationId);
+  if (index < 0) state.receipts.push(item);
+  else {
+    const previous = state.receipts[index];
+    const unique = field => [...new Map([...(previous[field] || []), ...(item[field] || [])]
+      .map(event => [event.accountCostEventId || event.eventId || event.id || JSON.stringify(event), event])).values()];
+    state.receipts[index] = { ...previous, ...item, usage: item.usage || previous.usage,
+      operationId: item.operationId || previous.operationId, costUsd: Math.max(Number(previous.costUsd) || 0, Number(item.costUsd) || 0),
+      accountCostEvents: unique("accountCostEvents"), acceptedTaskCosts: unique("acceptedTaskCosts") };
+  }
+}
+function authorityBinding(config) {
+  const scope = new URL(config.apiBase || DEFAULT_API_BASE).href.replace(/\/$/u, "");
+  return { apiScope: scope, authorityFingerprint: createHash("sha256").update(JSON.stringify([scope, config.pat || ""])).digest("hex") };
+}
+function assertCheckpointAuthority(config, state) {
+  const current = authorityBinding(config);
+  if (!state.authorityBinding && (state.inFlight || state.pendingStageResult || state.receipts?.length || Object.keys(state.analyses || {}).length)) {
+    throw fail("REVIEW_CHECKPOINT_AUTHORITY_MISSING", "이전 분석 기록에 서버·계정 연결 증명이 없습니다. 기존 파일의 로컬 확인만 가능하며 현재 PAT로 결과를 적용하거나 유료 요청을 다시 보내지 않습니다.");
+  }
+  if (state.authorityBinding && (state.authorityBinding.apiScope !== current.apiScope || state.authorityBinding.authorityFingerprint !== current.authorityFingerprint)) {
+    throw fail("REVIEW_CHECKPOINT_AUTHORITY_CHANGED", "분석을 시작한 서버와 PAT로 기존 작업을 확인해 주세요. 계정이 변경된 상태에서는 업로드·유료 요청·결과 조회를 하지 않습니다.");
+  }
+  state.authorityBinding ||= current;
+}
+function storyClient(config, api) {
+  return createReviewStoryJobClient({ apiScope: config.apiBase || DEFAULT_API_BASE,
+    getAuthority: () => transportAuthority(config, api),
+    request: (route, options) => api.request(route, { ...options, ...(options.body === undefined ? {} : { body: JSON.parse(options.body) }) }),
+  });
+}
+function nativeClient(config, api) {
+  return createReviewNativeJobClient({ apiScope: config.apiBase || DEFAULT_API_BASE,
+    getAuthority: () => transportAuthority(config, api),
+    request: (route, options) => api.request(route, { ...options, ...(options.body === undefined ? {} : { body: JSON.parse(options.body) }) }),
+  });
+}
+function transportAuthority(config, api) {
+  if (matchesApiClientAuthority(api, { apiBase: config.apiBase || DEFAULT_API_BASE, pat: config.pat }) === false) return null;
+  return config.pat ? JSON.stringify([config.apiBase || DEFAULT_API_BASE, config.pat]) : api;
+}
+function mediaDescriptor(media) {
+  const { videoBase64, ...chunk } = media.chunk;
+  return { source: media.source, chunk, ...(media.workTitle !== undefined ? { workTitle: media.workTitle } : {}) };
+}
 function safeStageResult(value) {
   if (Array.isArray(value)) return value.map(safeStageResult);
   if (!value || typeof value !== "object") return value;
-  return Object.fromEntries(Object.entries(value).filter(([key]) => !/base64|dataUrl|localPath|sourceHandle|apiKey|token/i.test(key)).map(([key, item]) => [key, safeStageResult(item)]));
+  return Object.fromEntries(Object.entries(value).filter(([key]) => !/base64|dataUrl|localPath|sourceHandle|apiKey|^token$|accessToken|refreshToken|authorization|cookie/i.test(key)).map(([key, item]) => [key, safeStageResult(item)]));
 }
 function billing(state) {
   const costs = state.receipts || [];
-  const unique = (field) => [...new Map(costs.flatMap(item => item[field] || []).map(item => [item.eventId || item.id || JSON.stringify(item), item])).values()];
+  const unique = (field) => [...new Map(costs.flatMap(item => item[field] || []).map(item => [item.accountCostEventId || item.eventId || item.id || JSON.stringify(item), item])).values()];
   return { accountCostEvents: unique("accountCostEvents"), acceptedTaskCosts: unique("acceptedTaskCosts"),
     costUsd: costs.reduce((sum, item) => sum + (Number(item.costUsd) || 0), 0), stageReceipts: costs };
 }
@@ -94,12 +148,58 @@ function summary(state, resumePath) {
       analyzedTimelineSec: analyzedMs / 1000, totalTimelineSec: state.sources.reduce((sum, item) => sum + item.durationSec, 0) },
     sources: reviewPublicSources(state.sources), ...billing(state),
     warnings: state.warnings || [], error: state.error || undefined,
+    ...(state.inFlight?.transport === REVIEW_STORY_TRANSPORT ? { storyJob: { requestId: state.inFlight.operationId,
+      jobId: state.inFlight.jobId || null, apiScope: state.inFlight.apiScope, recovery: "read-only-known-job", paidReplayAllowed: false } } : {}),
+    ...(state.inFlight?.transport === REVIEW_NATIVE_TRANSPORT ? { nativeJob: { stage: state.inFlight.stage,
+      requestId: state.inFlight.operationId, jobId: state.inFlight.jobId || null, status: state.inFlight.jobStatus || "unknown",
+      apiScope: state.inFlight.apiScope, mediaAttemptId: state.inFlight.mediaAttempt?.attemptId || null,
+      fileState: state.inFlight.mediaReference ? "ready" : state.inFlight.mediaAttempt ? "reconciliation-required" : "not-uploaded",
+      recovery: state.inFlight.jobId ? "read-only-known-job" : state.inFlight.submissionAttempted ? "submission-unknown-no-replay" : "reconcile-upload",
+      paidReplayAllowed: false, automaticUploadRetryAllowed: false } } : {}),
+    mediaFiles: { ready: Object.keys(state.mediaReferences || {}).length, retainedForVerification: true },
+    reviewRequired: state.reviewRequired === true,
     failedStageResultPath: state.failedStageResultPath || undefined,
     requiresHumanReview: true, next: state.stage === "complete" ? "plan_review_video({reviewSourcePath,...})" : state.stage === "blocked" ? "실패 원인·이미 접수된 비용을 확인하세요. 자동 재시도하지 않습니다." : "analyze_review_sources({resumePath,allowCloudVideoUpload:true})로 다음 1개 단계를 계속하세요.",
   };
 }
 export function fullReviewStatus(config, resumePath) { const loaded = loadFullReviewAnalysis(config, resumePath); return summary(loaded.state, loaded.resumePath); }
 
+export async function refreshFullReviewStatus(config, api, resumePath) {
+  const loaded = loadFullReviewAnalysis(config, resumePath);
+  const release = lockAnalysis(config, loaded.state.analysisId);
+  try {
+    let { state, resumePath: latestPath } = loadFullReviewAnalysis(config, resumePath);
+    assertCheckpointAuthority(config, state);
+    const operation = state.inFlight;
+    if (![REVIEW_STORY_TRANSPORT, REVIEW_NATIVE_TRANSPORT].includes(operation?.transport)
+        || operation.transport === REVIEW_STORY_TRANSPORT && !operation.jobId) return summary(state, latestPath);
+    try {
+      const job = operation.transport === REVIEW_STORY_TRANSPORT
+        ? await storyClient(config, api).read(operation.jobId, { requestId: operation.operationId, apiScope: operation.apiScope })
+        : await nativeClient(config, api).read(operation.stage, { ...operation, requestId: operation.operationId,
+          onCheckpoint: async metadata => {
+            assertCheckpointAuthority(config, state); Object.assign(operation, metadata);
+            if (operation.mediaReference) (state.mediaReferences ||= {})[operation.chunkId] = operation.mediaReference;
+            latestPath = snapshot(config, state);
+          } });
+      assertCheckpointAuthority(config, state);
+      operation.jobStatus = job.status;
+      if (job.status === "completed") {
+        if (!job.result || typeof job.result !== "object" || Array.isArray(job.result)) throw fail("REVIEW_STORY_RESULT_MISSING", "저장된 줄거리 결과가 없습니다.");
+        const result = operation.transport === REVIEW_STORY_TRANSPORT ? job.result
+          : unwrapReviewNativeJobResult(operation.stage, job.result, operation.mediaReference);
+        upsertStageReceipt(state, result, operation.operationId, operation.stage, operation.chunkId);
+        state.pendingStageResult = safeStageResult(result);
+      }
+      latestPath = snapshot(config, state);
+    } catch (error) {
+      state.error = { code: error.code || error.errorCode || "REVIEW_JOB_READ_FAILED", message: String(error.message || error) };
+      latestPath = snapshot(config, state);
+    }
+    return summary(state, latestPath);
+  } finally { release(); }
+}
+
 // This limits only the editing candidate list, never the full story/transcript
 // evidence. All native analysis remains in the original immutable handle.
 export function selectReviewPlanningCatalog(handle, requestedIds) {
@@ -188,7 +288,8 @@ export async function runFullReviewAnalysis({ config, api, args, companionJson,
     const health = await companionJson(config, "/health", undefined, 15000);
     if (health.capabilities?.reviewSourceAnalysis !== true || health.capabilities?.reviewSourceChunks !== true || health.capabilities.reviewSourceChunkMaxDurationSec < 300 || health.capabilities.reviewSourceChunkMaxBytes < MAX_CHUNK_BYTES) throw fail("COMPANION_UPDATE_REQUIRED", "전체 영상·음성 분석 청크를 지원하는 로컬 처리기로 업데이트하세요. 대표 프레임으로 우회하지 않습니다.");
     const state = { kind: KIND, version: 1, analysisId: randomUUID(), revision: 0, stage: "analyzing", workTitle: args.workTitle || "",
-      sources: [], chunks: [], analyses: {}, verifications: {}, receipts: [], warnings: ["전체 구간을 압축 영상+오디오로 분석하고 서사 주장을 실제 원본 구간으로 재검증합니다. 공개 권리와 최종 해석은 사람이 확인해야 합니다."], uploadConsent: true };
+      sources: [], chunks: [], analyses: {}, verifications: {}, receipts: [], mediaReferences: {}, authorityBinding: authorityBinding(config),
+      warnings: ["전체 구간을 압축 영상+오디오로 분석하고 서사 주장을 실제 원본 구간으로 재검증합니다. 공개 권리와 최종 해석은 사람이 확인해야 합니다."], uploadConsent: true };
     const fingerprints = args.sources.map(source => source.kind === "local" ? inspectReviewLocalFile(source.videoPath) : null);
     for (const [index, input] of args.sources.entries()) {
       const id = `review-${randomUUID().slice(0, 8)}`;
@@ -209,16 +310,27 @@ export async function runFullReviewAnalysis({ config, api, args, companionJson,
   let state, resumePath;
   try {
     ({ state, resumePath } = loadFullReviewAnalysis(config, args.resumePath));
-    validateReviewSources(state.sources);
+    assertCheckpointAuthority(config, state);
     if (state.stage === "complete") return summary(state, resumePath);
+    if (state.reviewRequired) return { ...summary(state, resumePath), requiresExplicitRetryApproval: false };
     if (state.inFlight || state.stage === "blocked") {
+      if ([REVIEW_STORY_TRANSPORT, REVIEW_NATIVE_TRANSPORT].includes(state.inFlight?.transport) || state.pendingStageResult) {
+        if (!state.inFlight || !["analyzing", "synthesizing", "verifying"].includes(state.inFlight.stage)
+            || state.inFlight.transport === REVIEW_STORY_TRANSPORT && state.inFlight.stage !== "synthesizing") throw fail("REVIEW_JOB_STATE_INVALID", "저장된 작업 단계가 다릅니다.");
+        state.stage = state.inFlight.stage;
+        delete state.error;
+      } else {
       if (args.retryFailedStage !== true) return { ...summary(state, resumePath), requiresExplicitRetryApproval: true };
       state.stage = state.failedStage || state.inFlight?.stage || "analyzing";
       delete state.inFlight; delete state.error;
+      }
       resumePath = snapshot(config, state);
     }
     const refreshed = new Set();
     const getMedia = async (chunk, expectedSha256) => {
+      // A known server job / saved result does not need the local source. Only
+      // a genuinely new media transfer or explicit legacy recheck reads it.
+      validateReviewSources(state.sources);
       const index = state.sources.findIndex(source => source.id === chunk.sourceId);
       try { return await videoChunk(config, companionJson, state.sources[index], chunk, expectedSha256); }
       catch (error) {
@@ -232,41 +344,87 @@ export async function runFullReviewAnalysis({ config, api, args, companionJson,
       if (!onProgress) return;
       try { await onProgress(summary(state, resumePath)); } catch { /* Progress delivery cannot replay/abort an accepted paid operation. */ }
     };
-    const charge = async (stage, chunkId, route, body) => {
-      state.inFlight = { stage, chunkId, operationId: randomUUID() }; state.failedStage = stage;
+    const charge = async (stage, chunkId, body, options = {}) => {
+      assertCheckpointAuthority(config, state);
+      const existing = state.inFlight;
+      if (existing && (existing.stage !== stage || existing.chunkId !== chunkId)) throw fail("REVIEW_JOB_STATE_INVALID", "체크포인트의 작업 구간이 다릅니다.");
+      if (state.pendingStageResult) return state.pendingStageResult;
+      state.inFlight = existing || { stage, chunkId, operationId: randomUUID(),
+        ...(stage === "analyzing" ? { mediaDescriptor: mediaDescriptor(body), priorContext: body.priorContext || "" } : {}) }; state.failedStage = stage;
       resumePath = snapshot(config, state);
       await progress();
       let response;
-      try { response = await api.request(route, { method: "POST", body: { ...body, costEventId: state.inFlight.operationId }, timeoutMs: 600000 }); }
-      catch (error) { state.receipts.push(receipt(error, stage, chunkId)); throw error; }
-      state.receipts.push(receipt(response, stage, chunkId));
+      const operationId = state.inFlight.operationId;
+      try {
+        response = stage === "synthesizing"
+          ? await storyClient(config, api).run(body, {
+            requestId: operationId, ...(existing ? { transport: existing.transport, jobId: existing.jobId, apiScope: existing.apiScope } : {}),
+            onSubmissionAttempt: async metadata => { Object.assign(state.inFlight, metadata); resumePath = snapshot(config, state); },
+            onJobAccepted: async metadata => { Object.assign(state.inFlight, metadata); resumePath = snapshot(config, state); },
+          })
+          : await nativeClient(config, api).run(stage, body, { ...state.inFlight, requestId: operationId,
+            // A resumed operation owns its exact reference and origin. Never
+            // repair a damaged/missing binding from the analysis-wide cache.
+            ...(!existing && options.mediaReference ? { mediaReference: options.mediaReference,
+              apiScope: state.authorityBinding.apiScope } : {}),
+            getLegacyMedia: options.getLegacyMedia,
+            onCheckpoint: async metadata => {
+              assertCheckpointAuthority(config, state); Object.assign(state.inFlight, metadata);
+              if (state.inFlight.mediaReference) (state.mediaReferences ||= {})[chunkId] = state.inFlight.mediaReference;
+              resumePath = snapshot(config, state);
+            },
+          });
+      }
+      catch (error) {
+        if (stage === "synthesizing") upsertStoryReceipt(state, error, operationId);
+        else upsertStageReceipt(state, error, operationId, stage, chunkId);
+        throw error;
+      }
+      assertCheckpointAuthority(config, state);
+      if (stage === "synthesizing") upsertStoryReceipt(state, response, operationId);
+      else upsertStageReceipt(state, response, operationId, stage, chunkId);
+      if (state.inFlight.transport) state.inFlight.jobStatus = "completed";
       state.pendingStageResult = safeStageResult(response);
+      // Commit received output before validation/application can fail or MCP exits.
+      resumePath = snapshot(config, state);
       return response;
     };
     for (let step = 0; step < (args.maxSteps ?? 1); step++) {
       if (state.stage === "analyzing") {
         const chunk = state.chunks.find(item => !state.analyses[item.chunkId]);
         if (!chunk) { state.stage = "synthesizing"; resumePath = snapshot(config, state); step--; continue; }
-        const media = await getMedia(chunk);
-        media.workTitle = state.workTitle;
-        const previous = Object.values(state.analyses).filter(item => item.sourceId === chunk.sourceId && item.startMs < chunk.startMs).sort((a, b) => b.startMs - a.startMs)[0];
-        if (previous) media.priorContext = JSON.stringify({ previousSummary: previous.summary, observedCharacters: previous.characters }).slice(0, 12000);
-        const response = await charge("analyzing", chunk.chunkId, "/api/tracker/review/analyze-chunk", media);
+        let media;
+        if (state.inFlight?.transport === REVIEW_NATIVE_TRANSPORT || state.pendingStageResult) {
+          media = state.inFlight.mediaDescriptor;
+          if (!media?.chunk || media.chunk.chunkId !== chunk.chunkId) throw fail("REVIEW_MEDIA_CHECKPOINT_INVALID", "저장된 미디어 구간 정보가 없습니다. 다시 인코딩하거나 업로드하지 않습니다.");
+        } else {
+          media = await getMedia(chunk); media.workTitle = state.workTitle;
+          const previous = Object.values(state.analyses).filter(item => item.sourceId === chunk.sourceId && item.startMs < chunk.startMs).sort((a, b) => b.startMs - a.startMs)[0];
+          if (previous) media.priorContext = JSON.stringify({ previousSummary: previous.summary, observedCharacters: previous.characters }).slice(0, 12000);
+        }
+        const response = await charge("analyzing", chunk.chunkId, state.inFlight?.transport === REVIEW_NATIVE_TRANSPORT
+          ? state.inFlight.jobId ? null : { priorContext: state.inFlight.priorContext || "" } : media);
         state.analyses[chunk.chunkId] = checkedAnalysis(response, chunk, media);
       } else if (state.stage === "synthesizing") {
         const body = { sources: reviewPublicSources(state.sources), chunks: Object.values(state.analyses), workTitle: state.workTitle };
         textBudget(body);
-        state.storyResult = await charge("synthesizing", "", "/api/tracker/review/synthesize-story", body);
+        state.storyResult = await charge("synthesizing", "", body);
         state.verifyChunkIds = verificationGroups(state);
         state.stage = "verifying";
       } else if (state.stage === "verifying") {
         const id = state.verifyChunkIds.find(chunkId => !state.verifications[chunkId]);
         if (!id) { state.stage = "finalizing"; step--; continue; }
         const chunk = state.chunks.find(item => item.chunkId === id), analyzed = state.analyses[id];
-        const media = await getMedia(chunk, analyzed.sha256);
-        const response = await charge("verifying", id, "/api/tracker/review/verify-evidence", { story: state.storyResult.story, chunks: Object.values(state.analyses), chunk: media });
-        if (response.chunkId !== id || !Array.isArray(response.verdicts) || !response.verdicts.length || response.verdicts.some(item => item.status !== "supported")) throw fail("REVIEW_ORIGINAL_VERIFICATION_FAILED", "원본 재검증에서 모순되거나 근거가 부족한 주장이 발견되었습니다. 전체 이해 완료나 자동 기획으로 진행하지 않습니다. 사용자가 줄거리·근거를 검토해야 합니다.");
+        const response = await charge("verifying", id, state.inFlight?.jobId ? null
+          : { story: state.storyResult.story, chunks: Object.values(state.analyses), chunkId: id },
+        { mediaReference: state.mediaReferences?.[id], getLegacyMedia: async () => ({ ...await getMedia(chunk, analyzed.sha256), workTitle: state.workTitle }) });
+        if (response.chunkId !== id || !Array.isArray(response.verdicts) || !response.verdicts.length
+            || response.verdicts.some(item => !["supported", "contradicted", "insufficient"].includes(item.status))) throw fail("REVIEW_ORIGINAL_VERIFICATION_INVALID", "저장된 원본 재검증 결과가 불완전합니다. 다시 과금하지 않습니다.");
         state.verifications[id] = response;
+        if (response.verdicts.some(item => item.status !== "supported")) {
+          state.reviewRequired = true;
+          throw fail("REVIEW_ORIGINAL_VERIFICATION_FAILED", "원본 재검증에서 모순되거나 근거가 부족한 주장이 발견되었습니다. 판정과 비용은 저장했습니다. 자동 재검증·전체 이해 완료·자동 기획으로 진행하지 않으며 사용자의 검토가 필요합니다.");
+        }
       } else if (state.stage === "finalizing") {
         const completed = { kind: "aimakeall-review-sources", version: 1, analysisScope: "full", analysisId: state.analysisId,
           sources: state.sources, sourceCatalog: Object.values(state.analyses).flatMap(chunk => chunk.sceneCatalog), globalStory: state.storyResult.story,
@@ -290,13 +448,18 @@ export async function runFullReviewAnalysis({ config, api, args, companionJson,
     return summary(state, resumePath);
   } catch (error) {
     if (!state) throw error;
+    // Never attach another account's saved costs/results to the caller or write
+    // through its journal after PAT/server changes (including mid-request).
+    assertCheckpointAuthority(config, state);
     state.failedStage ||= state.stage; state.stage = "blocked";
     state.error = { code: error.errorCode || error.code || "REVIEW_FULL_ANALYSIS_FAILED", message: String(error.message || error) };
-    if (state.pendingStageResult) {
+    if (state.pendingStageResult && state.inFlight?.transport !== REVIEW_STORY_TRANSPORT) {
       state.failedStageResultPath = savePayloadHandle(config.stateDir, { kind: "aimakeall-review-failed-stage", version: 1, analysisId: state.analysisId, stage: state.failedStage, result: state.pendingStageResult }, "review-failed-stage").filePath;
-      delete state.pendingStageResult;
+      // Keep the received result in the journal too: a restart must apply it,
+      // never repeat the paid request (including legacy successful responses).
     }
     resumePath = snapshot(config, state);
-    return { ...summary(state, resumePath), requiresExplicitRetryApproval: true };
+    return { ...summary(state, resumePath), requiresExplicitRetryApproval: !state.reviewRequired
+      && ![REVIEW_STORY_TRANSPORT, REVIEW_NATIVE_TRANSPORT].includes(state.inFlight?.transport) };
   } finally { release(); }
 }

package/lib/review-native-job-request.mjs

@@ -0,0 +1,329 @@
+// Shared browser/MCP one-way native-media transport. A stored attempt is never
+// permission to upload again; a submitted paid request is only ever read again.
+export const REVIEW_NATIVE_TRANSPORT = "review-native-queue-v2";
+export const REVIEW_NATIVE_CAPABILITY = "/api/tracker/review/native-execution";
+export const REVIEW_NATIVE_ATTEMPTS = "/api/tracker/review/media-attempts";
+export const REVIEW_NATIVE_CHUNK_JOBS = "/api/tracker/review/chunk-jobs";
+export const REVIEW_NATIVE_EVIDENCE_JOBS = "/api/tracker/review/evidence-jobs";
+const UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/u;
+const ASSET = /^[a-f0-9]{8}-[a-f0-9]{4}-[1-8][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/u;
+const HASH = /^[a-f0-9]{64}$/u, JOB = /^epoch-v2-[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/u;
+const MAX_VIDEO = 10 * 1024 * 1024, MAX_TEXT = 4 * 1024 * 1024;
+const encoder = new TextEncoder(), knownFailures = new WeakMap();
+// Native ingress admits one request per owner. Serialize actual I/O (not whole
+// queued jobs) across client instances. An adapter ignoring AbortSignal keeps
+// its slot until it truly settles; a timed-out waiter never dispatches later.
+const requestLanes = new Map();
+function serializedRequest(scope, authority, check, callback) {
+  let owners = requestLanes.get(scope);
+  if (!owners) { owners = new Map(); requestLanes.set(scope, owners); }
+  const previous = owners.get(authority) || Promise.resolve();
+  const work = previous.then(() => { check(); return callback(); });
+  const settled = work.then(() => {}, () => {}).finally(() => {
+    if (owners.get(authority) === settled) owners.delete(authority);
+    if (!owners.size && requestLanes.get(scope) === owners) requestLanes.delete(scope);
+  });
+  owners.set(authority, settled); return work;
+}
+const stages = Object.freeze({ analyzing: { path: REVIEW_NATIVE_CHUNK_JOBS, type: "review:analyze-chunk", kind: "review-chunk", field: "chunkAnalysis", legacy: "analyze-chunk" },
+  verifying: { path: REVIEW_NATIVE_EVIDENCE_JOBS, type: "review:verify-evidence", kind: "review-evidence", field: "verification", legacy: "verify-evidence" } });
+const object = value => value !== null && typeof value === "object" && !Array.isArray(value);
+const failure = (code, message = "원본 분석 기록을 안전하게 확인하지 못했습니다. 자동으로 다시 생성하지 않습니다.") => Object.assign(new Error(message), { code, paidReplayAllowed: false, automaticUploadRetryAllowed: false });
+function freeze(value) { if (value && typeof value === "object") { for (const child of Object.values(value)) freeze(child); Object.freeze(value); } return value; }
+function fields(value, allowed, required = []) {
+  if (!value || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) throw failure("REVIEW_NATIVE_INPUT_INVALID");
+  const descriptors = Object.getOwnPropertyDescriptors(value), keys = Reflect.ownKeys(descriptors);
+  if (keys.some(key => !allowed.includes(key) || !("value" in descriptors[key]) || !descriptors[key].enumerable)
+    || required.some(key => !Object.hasOwn(descriptors, key))) throw failure("REVIEW_NATIVE_INPUT_INVALID");
+  return Object.fromEntries(keys.map(key => [key, descriptors[key].value]));
+}
+function capture(value, maximum = MAX_TEXT) {
+  let nodes = 0, bytes = 0; const ancestors = new Set();
+  const add = size => { if ((bytes += size) > maximum) throw failure("REVIEW_NATIVE_INPUT_LIMIT"); };
+  function copy(item, depth) {
+    if (++nodes > 400000 || depth > 24) throw failure("REVIEW_NATIVE_INPUT_LIMIT");
+    if (item === null || typeof item === "boolean") { add(JSON.stringify(item).length); return item; }
+    if (typeof item === "number" && Number.isFinite(item)) { add(JSON.stringify(item).length); return item; }
+    if (typeof item === "string") {
+      if (item.length > maximum || !item.isWellFormed()) throw failure("REVIEW_NATIVE_INPUT_LIMIT");
+      add(encoder.encode(JSON.stringify(item)).length); return item;
+    }
+    if (!item || typeof item !== "object" || ancestors.has(item)) throw failure("REVIEW_NATIVE_INPUT_INVALID");
+    const array = Array.isArray(item), descriptors = Object.getOwnPropertyDescriptors(item), keys = Reflect.ownKeys(descriptors);
+    if (array ? Object.getPrototypeOf(item) !== Array.prototype : ![Object.prototype, null].includes(Object.getPrototypeOf(item))) throw failure("REVIEW_NATIVE_INPUT_INVALID");
+    if (keys.some(key => typeof key !== "string" || !("value" in descriptors[key]) || key.length > 128 || ["__proto__", "prototype", "constructor", "toJSON"].includes(key)
+      || key !== "length" && !descriptors[key].enumerable)) throw failure("REVIEW_NATIVE_INPUT_INVALID");
+    ancestors.add(item); add(2); let result;
+    if (array) {
+      if (item.length > 60000 || keys.length !== item.length + 1) throw failure("REVIEW_NATIVE_INPUT_INVALID");
+      result = Array.from({ length: item.length }, (_, index) => { if (!Object.hasOwn(descriptors, index)) throw failure("REVIEW_NATIVE_INPUT_INVALID"); if (index) add(1); return copy(descriptors[index].value, depth + 1); });
+    } else result = Object.fromEntries(keys.map((key, index) => { add(encoder.encode(JSON.stringify(key)).length + 1 + (index ? 1 : 0)); return [key, copy(descriptors[key].value, depth + 1)]; }));
+    ancestors.delete(item); return result;
+  }
+  return freeze(copy(value, 0));
+}
+function scopeOf(value) {
+  let parsed; try { parsed = new URL(value); } catch { throw failure("REVIEW_NATIVE_SCOPE_INVALID"); }
+  if (!["https:", "http:"].includes(parsed.protocol) || parsed.username || parsed.password || parsed.search || parsed.hash) throw failure("REVIEW_NATIVE_SCOPE_INVALID");
+  return parsed.href.replace(/\/$/u, "");
+}
+const text = (value, maximum, empty = true) => {
+  if (typeof value !== "string" || value.length > maximum || !value.isWellFormed() || (!empty && !value.trim()) || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u.test(value)) throw failure("REVIEW_NATIVE_INPUT_INVALID");
+  return value;
+};
+function metadata(value) {
+  const keys = ["version", "sourceId", "chunkId", "startMs", "endMs", "sourceDurationMs", "hasAudio", "videoId", "workTitle", "mimeType", "actualDurationSec"];
+  const raw = fields(value, keys, keys.filter(key => key !== "actualDurationSec"));
+  if (raw.version !== 1 || raw.mimeType !== "video/mp4" || typeof raw.sourceId !== "string" || !/^[A-Za-z0-9_.:-]{1,90}$/u.test(raw.sourceId)
+    || !Number.isSafeInteger(raw.sourceDurationMs) || raw.sourceDurationMs < 1 || raw.sourceDurationMs > 86400000
+    || !Number.isSafeInteger(raw.startMs) || !Number.isSafeInteger(raw.endMs) || raw.startMs < 0 || raw.endMs <= raw.startMs || raw.endMs > raw.sourceDurationMs
+    || raw.endMs - raw.startMs > 300000 || raw.chunkId !== `${raw.sourceId}:${raw.startMs}-${raw.endMs}` || typeof raw.hasAudio !== "boolean"
+    || typeof raw.videoId !== "string" || raw.videoId !== "" && !/^[A-Za-z0-9_-]{11}$/u.test(raw.videoId)
+    || text(raw.workTitle, 200) !== raw.workTitle.trim() || raw.actualDurationSec !== undefined && (!Number.isFinite(raw.actualDurationSec) || raw.actualDurationSec <= 0 || Math.abs(raw.actualDurationSec * 1000 - raw.endMs + raw.startMs) > 250)) throw failure("REVIEW_NATIVE_MEDIA_INVALID");
+  return freeze(Object.fromEntries(keys.filter(key => Object.hasOwn(raw, key)).map(key => [key, raw[key]])));
+}
+function mediaIdentity(value, reference = false) {
+  const keys = reference ? ["assetId", "namespace", "metadata", "sha256", "byteLength", "inputHash", "expiresAt"] : ["attemptId", "metadata", "sha256", "byteLength", "inputHash"];
+  const raw = fields(value, keys, keys);
+  if (!HASH.test(raw.sha256 || "") || !HASH.test(raw.inputHash || "") || !Number.isSafeInteger(raw.byteLength) || raw.byteLength < 16 || raw.byteLength > MAX_VIDEO
+    || reference && (!ASSET.test(raw.assetId || "") || !HASH.test(raw.namespace || "") || !Number.isSafeInteger(raw.expiresAt) || raw.expiresAt <= 0)
+    || !reference && !UUID.test(raw.attemptId || "")) throw failure("REVIEW_NATIVE_MEDIA_INVALID");
+  return freeze({ ...raw, metadata: metadata(raw.metadata) });
+}
+/** Compact allowlist suitable for IndexedDB/MCP checkpoint files. No tokens,
+ * paths, source handles, source URL, raw media or server-owned keys are allowed. */
+export function captureReviewNativeCheckpoint(value) {
+  const raw = fields(value, ["transport", "apiScope", "mediaAttempt", "mediaReference", "submissionAttempted", "requestBinding", "jobId"]);
+  if (raw.transport !== undefined && raw.transport !== REVIEW_NATIVE_TRANSPORT || raw.submissionAttempted !== undefined && typeof raw.submissionAttempted !== "boolean"
+    || raw.requestBinding !== undefined && !HASH.test(raw.requestBinding) || raw.jobId !== undefined && !JOB.test(raw.jobId)) throw failure("REVIEW_NATIVE_CHECKPOINT_INVALID");
+  return freeze({ ...raw, ...(raw.apiScope === undefined ? {} : { apiScope: scopeOf(raw.apiScope) }),
+    ...(raw.mediaAttempt === undefined ? {} : { mediaAttempt: mediaIdentity(raw.mediaAttempt) }),
+    ...(raw.mediaReference === undefined ? {} : { mediaReference: mediaIdentity(raw.mediaReference, true) }) });
+}
+const digest = async value => [...new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", typeof value === "string" ? encoder.encode(value) : value))].map(byte => byte.toString(16).padStart(2, "0")).join("");
+async function checkIdentity(identity) {
+  if (await digest(JSON.stringify({ version: 1, metadata: identity.metadata, sha256: identity.sha256, byteLength: identity.byteLength })) !== identity.inputHash) throw failure("REVIEW_NATIVE_MEDIA_MISMATCH");
+}
+function uploadShape(value) {
+  const raw = fields(value, ["source", "chunk", "workTitle", "priorContext"], ["source", "chunk"]);
+  const source = fields(raw.source, ["id", "videoId", "kind", "title", "durationSec", "hasAudio"], ["id", "durationSec"]);
+  const chunk = fields(raw.chunk, ["chunkId", "sourceId", "startMs", "endMs", "mimeType", "videoBase64", "sha256", "hasAudio", "actualDurationSec"], ["chunkId", "startMs", "endMs", "mimeType", "videoBase64", "sha256", "hasAudio"]);
+  if (!Number.isFinite(source.durationSec) || source.durationSec <= 0 || source.durationSec > 86400 || source.kind !== undefined && !["local", "youtube"].includes(source.kind)
+    || chunk.sourceId !== undefined && chunk.sourceId !== source.id || source.hasAudio !== undefined && source.hasAudio !== chunk.hasAudio) throw failure("REVIEW_NATIVE_MEDIA_INVALID");
+  if (source.title !== undefined) text(source.title, 200);
+  const meta = metadata({ version: 1, sourceId: source.id, chunkId: chunk.chunkId, startMs: chunk.startMs, endMs: chunk.endMs,
+    sourceDurationMs: Math.round(source.durationSec * 1000), hasAudio: chunk.hasAudio, videoId: (source.videoId ?? "").trim(),
+    workTitle: text(raw.workTitle ?? source.title ?? "", 200).trim(), mimeType: chunk.mimeType,
+    ...(chunk.actualDurationSec === undefined ? {} : { actualDurationSec: chunk.actualDurationSec }) });
+  if (typeof chunk.videoBase64 !== "string" || chunk.videoBase64.length > 4 * Math.ceil(MAX_VIDEO / 3) || !chunk.videoBase64.length || chunk.videoBase64.length % 4 || !/^[A-Za-z0-9+/]+={0,2}$/u.test(chunk.videoBase64) || !HASH.test(chunk.sha256 || "")) throw failure("REVIEW_NATIVE_MEDIA_INVALID");
+  let bytes; try { const binary = atob(chunk.videoBase64); if (btoa(binary) !== chunk.videoBase64) throw new Error(); bytes = Uint8Array.from(binary, char => char.charCodeAt(0)); } catch { throw failure("REVIEW_NATIVE_MEDIA_INVALID"); }
+  if (bytes.length < 16 || bytes.length > MAX_VIDEO || new TextDecoder().decode(bytes.slice(4, 8)) !== "ftyp") throw failure("REVIEW_NATIVE_MEDIA_INVALID");
+  return { input: { source, chunk, ...(raw.workTitle === undefined ? {} : { workTitle: raw.workTitle }) }, metadata: meta, bytes, sha256: chunk.sha256, priorContext: text(raw.priorContext ?? "", 12000).trim() };
+}
+function safeReferences(value) {
+  if (Array.isArray(value)) { for (const item of value) safeReferences(item); return; }
+  if (!object(value)) { if (typeof value === "string" && /^\s*(?:data|blob|file):/iu.test(value)) throw failure("REVIEW_NATIVE_INPUT_INVALID"); return; }
+  for (const [key, child] of Object.entries(value)) {
+    if (/^(?:owneruserid|ownerid|userid|inputhash|namespace|assetid|localpath|filepath|path|filename|url|asseturl|objectkey|bucket|videobase64|audiobase64|base64data|dataurl|buffer|credentials|cookie|sessionid|sessiontoken|token|secret|byok)$/u.test(key.replace(/[^a-z0-9]/giu, "").toLowerCase())
+      || /apikey|authorization|accesstoken|refreshtoken|clientsecret|password|privatekey/iu.test(key)) throw failure("REVIEW_NATIVE_INPUT_INVALID");
+    safeReferences(child);
+  }
+}
+function logicalInput(stage, body, identity) {
+  if (body === null) return null;
+  if (stage === "analyzing") {
+    fields(body, ["source", "chunk", "workTitle", "priorContext"]);
+    return { priorContext: text(body.priorContext ?? "", 12000).trim() };
+  }
+  const raw = fields(body, ["chunk", "chunkId", "chunks", "story"], ["chunks", "story"]);
+  const chunkId = raw.chunkId ?? raw.chunk?.chunk?.chunkId ?? raw.chunk?.chunkId;
+  if (chunkId !== identity.metadata.chunkId || !Array.isArray(raw.chunks) || raw.chunks.length < 1 || raw.chunks.length > 500 || !object(raw.story)) throw failure("REVIEW_NATIVE_INPUT_INVALID");
+  safeReferences({ chunks: raw.chunks, story: raw.story });
+  const matches = raw.chunks.filter(item => item?.chunkId === chunkId), receipt = matches[0];
+  if (matches.length !== 1 || receipt.sha256 !== identity.sha256 || ["sourceId", "startMs", "endMs", "sourceDurationMs", "hasAudio", "videoId", "workTitle"].some(key => receipt[key] !== identity.metadata[key])) throw failure("REVIEW_NATIVE_MEDIA_MISMATCH");
+  if (encoder.encode(JSON.stringify({ chunks: raw.chunks, story: raw.story })).length > MAX_TEXT) throw failure("REVIEW_NATIVE_INPUT_LIMIT");
+  return { chunkId, chunks: raw.chunks, story: raw.story };
+}
+/** Only the actual HTTP adapters attach typed unknown-submission metadata. */
+export function attachReviewNativeJobFailureMetadata(error, payload) {
+  if (!object(error) || !object(payload) || payload.submissionState !== "unknown" || payload.retryAllowed !== false || payload.paidReplayAllowed !== false
+    || !UUID.test(payload.requestId || "") || !JOB.test(payload.jobId || "") || payload.recoveryAction !== "read-known-job") return false;
+  const stage = Object.keys(stages).find(key => payload.statusPath === `${stages[key].path}/${payload.jobId}`);
+  if (!stage) return false;
+  knownFailures.set(error, { stage, requestId: payload.requestId, jobId: payload.jobId }); return true;
+}
+function jobFrom(payload, stage, requestId, jobId) {
+  const raw = capture(payload, 8 * 1024 * 1024 + 4096), job = raw.job;
+  if (raw.ok !== true || raw.async !== true || raw.requestId !== requestId || !object(job) || !JOB.test(job.id || "") || jobId && jobId !== job.id
+    || job.type !== stages[stage].type || !["queued", "pending", "running", "completed", "failed", "cancelled", "unknown", "interrupted", "cancel_requested"].includes(job.status)
+    || job.workflow?.paidReplayAllowed !== false || job.workflow?.recovery !== "read-only-known-job") throw failure("REVIEW_NATIVE_RESPONSE_INVALID");
+  return job;
+}
+export function unwrapReviewNativeJobResult(stage, value, suppliedReference) {
+  if (!stages[stage]) throw failure("REVIEW_NATIVE_STAGE_INVALID");
+  const ref = mediaIdentity(suppliedReference, true), result = capture(value, 8 * 1024 * 1024), native = result[stages[stage].field];
+  if (result.kind !== stages[stage].kind || result.assetId !== ref.assetId || result.namespace !== ref.namespace || result.mediaInputHash !== ref.inputHash
+    || result.accountingState !== "settled" || result.paidReplayAllowed !== false || result.hasAccountCostEvents !== true || !object(native)
+    || native.chunkId !== ref.metadata.chunkId || !Array.isArray(result.accountCostEvents) || !result.accountCostEvents.length
+    || !Array.isArray(result.acceptedTaskCosts) || !object(result.usage) || !Number.isFinite(result.costUsd) || result.costUsd < 0
+    || typeof result.operationId !== "string" || !new RegExp(`^bg-review-${stage === "analyzing" ? "chunk" : "evidence"}-v1:[a-f0-9]{64}$`, "u").test(result.operationId)
+    || result.accountCostEvents.some((event, index) => event.accountCostEventId !== `${result.operationId}:${index + 1}` || event.accountCostRecorded !== true && event.accountCostSuppressedByReset !== true)) throw failure("REVIEW_NATIVE_RESULT_INVALID");
+  if (stage === "analyzing" && (native.sha256 !== ref.sha256 || ["sourceId", "startMs", "endMs", "sourceDurationMs", "hasAudio", "videoId", "workTitle"].some(key => native[key] !== ref.metadata[key]))) throw failure("REVIEW_NATIVE_RESULT_MISMATCH");
+  if (stage === "verifying" && (native.verificationKind !== "native-video-audio-recheck" || native.coverage?.startMs !== ref.metadata.startMs || native.coverage?.endMs !== ref.metadata.endMs
+    || native.coverage?.nativeAudioSubmitted !== ref.metadata.hasAudio || native.selectedSourceIds?.length !== 1 || native.selectedSourceIds[0] !== ref.metadata.sourceId)) throw failure("REVIEW_NATIVE_RESULT_MISMATCH");
+  return freeze({ ...native, ...Object.fromEntries(["operationId", "accountCostEvents", "acceptedTaskCosts", "hasAccountCostEvents", "accountingState", "costUsd", "usage", "model", "provider", "generatedAt", "paidReplayAllowed", "requiresHumanReview"].filter(key => result[key] !== undefined).map(key => [key, result[key]])) });
+}
+
+export function createReviewNativeJobClient({ request, getAuthority, apiScope, pollMs = 1000, readTimeoutMs = 30000,
+  now = Date.now, uuid = () => globalThis.crypto.randomUUID(), setTimer = setTimeout, clearTimer = clearTimeout } = {}) {
+  if (typeof request !== "function" || typeof getAuthority !== "function" || !Number.isSafeInteger(pollMs) || pollMs < 1 || pollMs > 10000
+    || !Number.isSafeInteger(readTimeoutMs) || readTimeoutMs < 1 || readTimeoutMs > 60000) throw new TypeError("Native review transport dependencies required");
+  const scope = scopeOf(apiScope);
+  async function run(stage, body, options = {}) {
+    if (!stages[stage]) throw failure("REVIEW_NATIVE_STAGE_INVALID");
+    // Capture descriptors and all input values before the first await, including
+    // before crypto hashing, capability discovery or journal persistence.
+    const captured = body == null ? null : capture(body, 4 * Math.ceil(MAX_VIDEO / 3) + MAX_TEXT + 32768);
+    const checkpoint = captureReviewNativeCheckpoint(Object.fromEntries(["transport", "apiScope", "mediaAttempt", "mediaReference", "submissionAttempted", "requestBinding", "jobId"].filter(key => options[key] !== undefined && options[key] !== "").map(key => [key, options[key]])));
+    const { requestId, onCheckpoint, signal } = options, authority = getAuthority();
+    if (!authority) throw failure("REVIEW_NATIVE_AUTHORITY_REQUIRED");
+    if (!UUID.test(requestId || "")) throw failure("REVIEW_NATIVE_ID_INVALID");
+    const recovering = checkpoint.transport !== undefined || checkpoint.mediaAttempt !== undefined || checkpoint.submissionAttempted !== undefined || checkpoint.jobId !== undefined;
+    if (recovering && (checkpoint.transport !== REVIEW_NATIVE_TRANSPORT || !checkpoint.apiScope || checkpoint.submissionAttempted === undefined
+      || !checkpoint.requestBinding || !checkpoint.mediaAttempt && !checkpoint.mediaReference)) throw failure("REVIEW_NATIVE_CHECKPOINT_INVALID");
+    if (checkpoint.mediaReference && !checkpoint.apiScope) throw failure("REVIEW_NATIVE_SCOPE_INVALID");
+    if (checkpoint.apiScope && checkpoint.apiScope !== scope) throw failure("REVIEW_NATIVE_SCOPE_CHANGED");
+    if (checkpoint.jobId && checkpoint.submissionAttempted !== true || checkpoint.submissionAttempted === true && !checkpoint.mediaReference) throw failure("REVIEW_NATIVE_CHECKPOINT_INVALID");
+    let state = { ...checkpoint }, lastJob, uploadStatus, uploadInput, logical;
+    const timeoutMs = options.timeoutMs ?? 600000;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 900000) throw new TypeError("Invalid native review deadline");
+    const deadline = now() + timeoutMs;
+    const check = () => {
+      if (getAuthority() !== authority) throw failure("REVIEW_NATIVE_OWNER_CHANGED");
+      if (signal?.aborted) throw failure("REVIEW_NATIVE_WAIT_ABORTED");
+      if (now() >= deadline) throw failure("REVIEW_NATIVE_WAIT_TIMEOUT");
+    };
+    async function bounded(callback, maximum = readTimeoutMs) {
+      check(); const controller = new AbortController(); let timer, listener;
+      const stop = new Promise((_, reject) => {
+        listener = () => { const error = failure("REVIEW_NATIVE_WAIT_ABORTED"); controller.abort(error); reject(error); };
+        signal?.addEventListener("abort", listener, { once: true });
+        timer = setTimer(() => { const error = failure("REVIEW_NATIVE_WAIT_TIMEOUT"); controller.abort(error); reject(error); }, Math.min(maximum, deadline - now()));
+      });
+      try { const value = await Promise.race([Promise.resolve().then(() => { check(); return callback(controller.signal); }), stop]); check(); return value; }
+      finally { clearTimer(timer); signal?.removeEventListener("abort", listener); }
+    }
+    const call = (path, init, maximum) => bounded(signal => serializedRequest(scope, authority, check,
+      () => { if (signal.aborted) throw signal.reason || failure("REVIEW_NATIVE_WAIT_ABORTED");
+        return request(path, { ...init, cache: "no-store", signal, timeoutMs: maximum || readTimeoutMs }); }), maximum);
+    // Durable writes are awaited to completion, never raced against timeout.
+    const persist = async patch => {
+      check(); state = captureReviewNativeCheckpoint({ ...state, ...patch });
+      if (typeof onCheckpoint !== "function") throw failure("REVIEW_NATIVE_JOURNAL_REQUIRED");
+      await onCheckpoint(state); check();
+    };
+    async function readUpload(value) {
+      const raw = capture(value, 16384), attempt = state.mediaAttempt;
+      if (!attempt || raw.attemptId !== attempt.attemptId || raw.automaticUploadRetryAllowed !== false
+        || !["ready", "reserved", "unconfirmed", "not_found", "deleting", "deleted"].includes(raw.status)) throw failure("REVIEW_NATIVE_UPLOAD_RESPONSE_INVALID");
+      if (raw.status === "ready") {
+        if (raw.ok !== true) throw failure("REVIEW_NATIVE_UPLOAD_RESPONSE_INVALID");
+        const reference = mediaIdentity(raw.reference, true); await checkIdentity(reference); check();
+        if (reference.inputHash !== attempt.inputHash || reference.sha256 !== attempt.sha256 || reference.byteLength !== attempt.byteLength
+          || raw.assetId !== reference.assetId || raw.namespace !== reference.namespace || raw.inputHash !== reference.inputHash
+          || state.mediaReference && JSON.stringify(state.mediaReference) !== JSON.stringify(reference)) throw failure("REVIEW_NATIVE_MEDIA_MISMATCH");
+        await persist({ mediaReference: reference });
+      } else if (raw.status !== "not_found" && (raw.inputHash !== attempt.inputHash || !ASSET.test(raw.assetId || "") || !HASH.test(raw.namespace || ""))) throw failure("REVIEW_NATIVE_MEDIA_MISMATCH");
+      return raw;
+    }
+    try {
+      check();
+      if (state.mediaAttempt) { await checkIdentity(state.mediaAttempt); check(); }
+      if (state.mediaReference) { await checkIdentity(state.mediaReference); check(); }
+      if (state.mediaAttempt && state.mediaReference && state.mediaAttempt.inputHash !== state.mediaReference.inputHash) throw failure("REVIEW_NATIVE_MEDIA_MISMATCH");
+      const suppliedMedia = stage === "analyzing" && (captured?.source || captured?.chunk) ? captured : stage === "verifying" ? captured?.chunk : null;
+      const existingIdentity = state.mediaReference || state.mediaAttempt;
+      if (suppliedMedia && existingIdentity) {
+        const media = uploadShape(suppliedMedia);
+        const hash = await digest(JSON.stringify({ version: 1, metadata: media.metadata, sha256: media.sha256, byteLength: media.bytes.length })); check();
+        if (hash !== existingIdentity.inputHash || await digest(media.bytes) !== existingIdentity.sha256) throw failure("REVIEW_NATIVE_MEDIA_MISMATCH"); check();
+      }
+      if (state.submissionAttempted === true && !state.jobId) throw failure("REVIEW_NATIVE_ACCEPTANCE_UNKNOWN");
+      if (!recovering && options.readOnly !== true) {
+        const cap = await call(REVIEW_NATIVE_CAPABILITY, { method: "GET" });
+        if (cap?.ok !== true || cap.kind !== "review-native" || cap.version !== 2 || cap.automaticUploadRetryAllowed !== false || cap.paidReplayAllowed !== false || !["queue-v2", "legacy-sync", "unavailable"].includes(cap.mode)) throw failure("REVIEW_NATIVE_CAPABILITY_INVALID");
+        if (cap.mode === "legacy-sync") {
+          if (state.mediaReference) throw failure("REVIEW_NATIVE_CAPABILITY_CHANGED");
+          if (!captured) throw failure("REVIEW_NATIVE_INPUT_REQUIRED");
+          let legacy = captured;
+          if (stage === "verifying" && !captured.chunk) {
+            if (typeof options.getLegacyMedia !== "function") throw failure("REVIEW_NATIVE_INPUT_REQUIRED");
+            const media = capture(await bounded(() => options.getLegacyMedia()), 4 * Math.ceil(MAX_VIDEO / 3) + 16384);
+            legacy = { chunks: captured.chunks, story: captured.story, chunk: media };
+          }
+          return await call(`/api/tracker/review/${stages[stage].legacy}`, { method: "POST", body: JSON.stringify({ ...legacy, costEventId: requestId }) }, timeoutMs);
+        }
+        if (cap.mode === "unavailable") throw failure("REVIEW_NATIVE_UNAVAILABLE");
+        if (!Array.isArray(cap.jobTypes) || !cap.jobTypes.includes(stages[stage].type)) throw failure("REVIEW_NATIVE_UNAVAILABLE");
+      }
+      if (!state.mediaReference && !state.mediaAttempt) {
+        if (options.readOnly === true || !captured) throw failure("REVIEW_NATIVE_INPUT_REQUIRED");
+        uploadInput = uploadShape(stage === "analyzing" ? captured : captured.chunk);
+        if (await digest(uploadInput.bytes) !== uploadInput.sha256) throw failure("REVIEW_NATIVE_MEDIA_MISMATCH"); check();
+        const base = { metadata: uploadInput.metadata, sha256: uploadInput.sha256, byteLength: uploadInput.bytes.length };
+        const mediaAttempt = mediaIdentity({ attemptId: uuid(), ...base, inputHash: await digest(JSON.stringify({ version: 1, ...base })) }); check();
+        logical = logicalInput(stage, captured, mediaAttempt);
+        const requestBinding = await digest(JSON.stringify({ requestId, stage, mediaInputHash: mediaAttempt.inputHash, ...logical })); check();
+        await persist({ transport: REVIEW_NATIVE_TRANSPORT, apiScope: scope, mediaAttempt, submissionAttempted: false, requestBinding });
+        uploadStatus = await readUpload(await call(REVIEW_NATIVE_ATTEMPTS, { method: "POST", body: JSON.stringify({ attemptId: mediaAttempt.attemptId, input: uploadInput.input, consent: true }) }));
+      }
+      if (!state.mediaReference && state.mediaAttempt) {
+        uploadStatus = await readUpload(await call(`${REVIEW_NATIVE_ATTEMPTS}/${state.mediaAttempt.attemptId}`, { method: "GET" }));
+        if (uploadStatus.status === "unconfirmed") uploadStatus = await readUpload(await call(`${REVIEW_NATIVE_ATTEMPTS}/${state.mediaAttempt.attemptId}/reconcile`, { method: "POST" }));
+        if (options.readOnly === true) return freeze({ kind: "review-media-attempt", ...uploadStatus });
+        if (!state.mediaReference) throw failure("REVIEW_NATIVE_UPLOAD_UNCONFIRMED");
+      }
+      if (!state.mediaReference) throw failure("REVIEW_NATIVE_MEDIA_REQUIRED");
+      logical ??= logicalInput(stage, captured, state.mediaReference);
+      if (logical) {
+        const binding = await digest(JSON.stringify({ requestId, stage, mediaInputHash: state.mediaReference.inputHash, ...logical })); check();
+        if (state.requestBinding && state.requestBinding !== binding) throw failure("REVIEW_NATIVE_INPUT_CHANGED");
+        if (!state.requestBinding) state.requestBinding = binding;
+      }
+      if (!state.jobId) {
+        if (options.readOnly === true) return freeze({ kind: "review-media-attempt", ...(uploadStatus || { status: "ready", reference: state.mediaReference, automaticUploadRetryAllowed: false }) });
+        if (!logical) throw failure("REVIEW_NATIVE_INPUT_REQUIRED");
+        if (state.mediaReference.expiresAt <= now()) throw failure("REVIEW_NATIVE_MEDIA_EXPIRED");
+        const ref = state.mediaReference, input = { assetId: ref.assetId, namespace: ref.namespace, mediaInputHash: ref.inputHash, ...logical };
+        if (encoder.encode(JSON.stringify(input)).length > (stage === "analyzing" ? 65536 : MAX_TEXT)) throw failure("REVIEW_NATIVE_INPUT_LIMIT");
+        await persist({ transport: REVIEW_NATIVE_TRANSPORT, apiScope: scope, submissionAttempted: true, requestBinding: state.requestBinding });
+        lastJob = jobFrom(await call(stages[stage].path, { method: "POST", body: JSON.stringify({ requestId, input, consent: true }) }), stage, requestId);
+        await persist({ jobId: lastJob.id });
+      }
+      for (;;) {
+        if (!lastJob) lastJob = jobFrom(await call(`${stages[stage].path}/${state.jobId}`, { method: "GET" }), stage, requestId, state.jobId);
+        if (options.readOnly === true) return lastJob;
+        if (lastJob.status === "completed") return unwrapReviewNativeJobResult(stage, lastJob.result, state.mediaReference);
+        if (!["queued", "pending", "running"].includes(lastJob.status)) throw failure("REVIEW_NATIVE_JOB_STOPPED", typeof lastJob.error === "string" && lastJob.error ? lastJob.error.slice(0, 1000) : undefined);
+        let timer; try { await bounded(() => new Promise(resolve => { timer = setTimer(resolve, pollMs); }), pollMs + readTimeoutMs); }
+        finally { if (timer !== undefined) clearTimer(timer); }
+        lastJob = null;
+      }
+    } catch (caught) {
+      if (getAuthority() !== authority) throw failure("REVIEW_NATIVE_OWNER_CHANGED");
+      let error = caught instanceof Error ? caught : failure("REVIEW_NATIVE_REQUEST_FAILED");
+      const known = knownFailures.get(error);
+      if (state.submissionAttempted === true && !state.jobId && known?.stage === stage && known.requestId === requestId) {
+        try { await persist({ jobId: known.jobId }); } catch (storageError) { error = storageError; }
+        if (getAuthority() !== authority) throw failure("REVIEW_NATIVE_OWNER_CHANGED");
+      }
+      if (!(error instanceof Error)) error = failure("REVIEW_NATIVE_REQUEST_FAILED");
+      // Raw error.jobId is not a recovery capability. Only an accepted response
+      // or adapter-branded, matching typed failure can populate this identity.
+      if (!state.jobId) delete error.jobId;
+      if (state.transport) Object.assign(error, state, { requestId, reconciliationRequired: true, paidReplayAllowed: false, automaticUploadRetryAllowed: false });
+      throw error;
+    }
+  }
+  return Object.freeze({ run, read: (stage, options = {}) => run(stage, null, { ...options, readOnly: true }) });
+}

package/lib/review-story-job-request.mjs

@@ -0,0 +1,131 @@
+// Shared browser/MCP transport. No credentials, paid retries or server failover.
+export const REVIEW_STORY_TRANSPORT = "review-story-queue-v1";
+export const REVIEW_STORY_JOBS = "/api/tracker/review/story-jobs";
+export const REVIEW_STORY_CAPABILITY = "/api/tracker/review/story-execution";
+const UUID = "[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}";
+const ID = new RegExp(`^${UUID}$`, "u"), JOB_ID = new RegExp(`^epoch-v2-${UUID}$`, "u");
+const statuses = new Set(["queued", "pending", "running", "completed", "failed", "interrupted", "unknown", "cancelled", "cancel_requested"]);
+const object = value => value !== null && typeof value === "object" && !Array.isArray(value);
+const knownErrorJobs = new WeakMap();
+// Only HTTP adapters call this with the typed server failure body. A copied
+// public jobId/error property alone never becomes a trusted recovery handle.
+export function attachReviewStoryJobFailureMetadata(error, payload) {
+  if (!error || typeof error !== "object" || !object(payload) || payload.submissionState !== "unknown"
+      || payload.retryAllowed !== false || payload.paidReplayAllowed !== false || !ID.test(payload.requestId || "")
+      || !JOB_ID.test(payload.jobId || "") || payload.statusPath !== `${REVIEW_STORY_JOBS}/${payload.jobId}`
+      || payload.recoveryAction !== "read-known-job") return false;
+  const identity = { requestId: payload.requestId, jobId: payload.jobId, statusPath: payload.statusPath };
+  knownErrorJobs.set(error, identity);
+  Object.assign(error, identity, { paidReplayAllowed: false, retryAllowed: false, reconciliationRequired: true });
+  return true;
+}
+const failure = (code, message) => Object.assign(new Error(message), { code, paidReplayAllowed: false });
+const validScope = value => {
+  let url; try { url = new URL(value); } catch { throw failure("REVIEW_STORY_SCOPE_INVALID", "분석 서버를 확인할 수 없습니다."); }
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) throw failure("REVIEW_STORY_SCOPE_INVALID", "분석 서버를 확인할 수 없습니다.");
+  return url.href.replace(/\/$/u, "");
+};
+function jobFrom(payload, requestId, expectedId) {
+  const job = payload?.job;
+  if (payload?.ok !== true || payload.async !== true || payload.requestId !== requestId || !object(job)
+      || !JOB_ID.test(job.id || "") || (expectedId && job.id !== expectedId)
+      || job.type !== "review:synthesize-story" || !statuses.has(job.status)) {
+    throw failure("REVIEW_STORY_RESPONSE_INVALID", "저장된 줄거리 작업을 안전하게 확인하지 못했습니다.");
+  }
+  if (job.result !== null && job.result !== undefined && new TextEncoder().encode(JSON.stringify(job.result)).length > 8 * 1024 * 1024) {
+    throw failure("REVIEW_STORY_RESULT_LIMIT", "저장된 줄거리 결과가 크기 한도를 초과했습니다.");
+  }
+  return job;
+}
+function captureInput(input) {
+  if (!object(input) || Object.keys(input).some(key => !["workTitle", "sources", "chunks"].includes(key))
+      || !Array.isArray(input.sources) || !Array.isArray(input.chunks)) throw failure("REVIEW_STORY_INPUT_INVALID", "전체 줄거리 분석 입력을 확인해 주세요.");
+  const json = JSON.stringify(input);
+  if (new TextEncoder().encode(json).length > 4 * 1024 * 1024) throw failure("REVIEW_STORY_INPUT_LIMIT", "전체 분석 자료가 4MiB를 초과했습니다.");
+  return JSON.parse(json);
+}
+export function createReviewStoryJobClient({ request, getAuthority, apiScope, pollMs = 1000, readTimeoutMs = 30000,
+  now = Date.now, setTimer = setTimeout, clearTimer = clearTimeout } = {}) {
+  if (typeof request !== "function" || typeof getAuthority !== "function" || !Number.isSafeInteger(pollMs) || pollMs < 1 || pollMs > 10000
+      || !Number.isSafeInteger(readTimeoutMs) || readTimeoutMs < 1 || readTimeoutMs > 60000) throw new TypeError("Review story transport dependencies required");
+  const scope = validScope(apiScope);
+  async function run(input, options = {}) {
+    const { requestId, onSubmissionAttempt, onJobAccepted, signal } = options;
+    const authority = getAuthority();
+    let jobId = options.jobId || "", attempted = options.transport === REVIEW_STORY_TRANSPORT || Boolean(jobId), lastJob;
+    if (!authority) throw failure("REVIEW_STORY_AUTHORITY_REQUIRED", "로그인 후 줄거리 분석을 이용해 주세요.");
+    if (!ID.test(requestId || "") || (jobId && !JOB_ID.test(jobId))) throw failure("REVIEW_STORY_ID_INVALID", "저장된 줄거리 작업 ID를 확인해 주세요.");
+    if ((options.transport && options.transport !== REVIEW_STORY_TRANSPORT) || (attempted && !options.apiScope)) throw failure("REVIEW_STORY_SCOPE_INVALID", "기존 작업의 서버 기록이 없습니다. 다시 제출하지 않습니다.");
+    if (options.apiScope && validScope(options.apiScope) !== scope) throw failure("REVIEW_STORY_SCOPE_CHANGED", "원래 분석 서버에서 기존 작업을 확인해 주세요.");
+    const timeoutMs = options.timeoutMs ?? 600000;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 900000) throw new TypeError("Invalid review waiting deadline");
+    const deadline = now() + timeoutMs;
+    const check = () => {
+      if (getAuthority() !== authority) throw failure("REVIEW_STORY_OWNER_CHANGED", "로그인 상태가 변경되어 이전 분석 조회를 중단했습니다.");
+      if (signal?.aborted) throw failure("REVIEW_STORY_WAIT_ABORTED", "분석 기다리기를 중단했습니다. 서버 작업을 취소하거나 재생성하지 않습니다.");
+      if (now() >= deadline) throw failure("REVIEW_STORY_WAIT_TIMEOUT", "분석 대기 시간이 초과되었습니다. 기존 작업만 조회하세요.");
+    };
+    async function bounded(callback, maximum = readTimeoutMs) {
+      check();
+      const controller = new AbortController(); let timer, listener;
+      const stop = new Promise((_, reject) => {
+        listener = () => { const error = failure("REVIEW_STORY_WAIT_ABORTED", "분석 기다리기를 중단했습니다."); controller.abort(error); reject(error); };
+        signal?.addEventListener("abort", listener, { once: true });
+        timer = setTimer(() => { const error = failure("REVIEW_STORY_WAIT_TIMEOUT", "분석 대기 시간이 초과되었습니다. 기존 작업만 조회하세요."); controller.abort(error); reject(error); }, Math.min(maximum, deadline - now()));
+      });
+      try {
+        const value = await Promise.race([Promise.resolve().then(() => { check(); return callback(controller.signal); }), stop]);
+        check(); return value;
+      } finally { clearTimer(timer); signal?.removeEventListener("abort", listener); }
+    }
+    const call = (path, init, maximum) => bounded(signal => request(path, { ...init, cache: "no-store", signal, timeoutMs: maximum || readTimeoutMs }), maximum);
+    // Persistence is deliberately awaited, not raced against abort/deadline.
+    const persist = async (callback, value) => { check(); await callback(value); check(); };
+    try {
+      if (attempted && !jobId) throw failure("REVIEW_STORY_ACCEPTANCE_UNKNOWN", "접수 응답에서 작업 ID를 받지 못했습니다. 유료 단계를 다시 제출하지 않습니다.");
+      if (!jobId) {
+        const captured = captureInput(input);
+        const capability = await call(REVIEW_STORY_CAPABILITY, { method: "GET" });
+        if (capability?.version !== 1 || capability.kind !== "review-story" || capability.recovery !== "read-only-known-job"
+            || capability.paidReplayAllowed !== false || !["legacy-sync", "queue-v2", "unavailable"].includes(capability.mode)) throw failure("REVIEW_STORY_CAPABILITY_INVALID", "줄거리 실행 방식이 확인되지 않아 생성을 시작하지 않았습니다.");
+        if (capability.mode === "unavailable") throw failure("REVIEW_STORY_UNAVAILABLE", "이 서버에서 줄거리 작업을 실행할 수 없습니다.");
+        if (capability.mode === "legacy-sync") return await call("/api/tracker/review/synthesize-story", { method: "POST", body: JSON.stringify(captured) }, timeoutMs);
+        if (typeof onSubmissionAttempt !== "function" || typeof onJobAccepted !== "function") throw failure("REVIEW_STORY_JOURNAL_REQUIRED", "작업 기록을 저장할 수 없어 분석을 시작하지 않았습니다.");
+        attempted = true;
+        await persist(onSubmissionAttempt, { transport: REVIEW_STORY_TRANSPORT, apiScope: scope });
+        lastJob = jobFrom(await call(REVIEW_STORY_JOBS, { method: "POST", body: JSON.stringify({ requestId, input: captured }) }), requestId);
+        jobId = lastJob.id;
+        await persist(onJobAccepted, { jobId, requestId, transport: REVIEW_STORY_TRANSPORT, apiScope: scope });
+      }
+      for (;;) {
+        if (!lastJob) lastJob = jobFrom(await call(`${REVIEW_STORY_JOBS}/${jobId}`, { method: "GET" }), requestId, jobId);
+        if (options.readOnly === true) return lastJob;
+        if (lastJob.status === "completed") {
+          if (!object(lastJob.result)) throw failure("REVIEW_STORY_RESULT_MISSING", "저장된 분석 결과를 확인하지 못했습니다.");
+          return lastJob.result;
+        }
+        if (!["queued", "pending", "running"].includes(lastJob.status)) throw failure("REVIEW_STORY_JOB_STOPPED", typeof lastJob.error === "string" ? lastJob.error.slice(0, 1000) : "기존 줄거리 작업을 확인해야 합니다. 다시 생성하지 않습니다.");
+        let timer;
+        try { await bounded(() => new Promise(resolve => { timer = setTimer(resolve, pollMs); }), pollMs + readTimeoutMs); }
+        finally { if (timer !== undefined) clearTimer(timer); }
+        lastJob = null;
+      }
+    } catch (caught) {
+      if (getAuthority() !== authority) throw failure("REVIEW_STORY_OWNER_CHANGED", "로그인 상태가 변경되어 이전 분석 조회를 중단했습니다.");
+      let error = caught instanceof Error ? caught : failure("REVIEW_STORY_REQUEST_FAILED", "분석 상태를 확인할 수 없습니다.");
+      const known = knownErrorJobs.get(error);
+      if (attempted && !jobId && known?.requestId === requestId) {
+        jobId = known.jobId;
+        try { await persist(onJobAccepted, { jobId, requestId, transport: REVIEW_STORY_TRANSPORT, apiScope: scope }); }
+        catch (storageError) { error = storageError; }
+        if (getAuthority() !== authority) throw failure("REVIEW_STORY_OWNER_CHANGED", "로그인 상태가 변경되어 이전 분석 조회를 중단했습니다.");
+      }
+      if (attempted) Object.assign(error, { requestId, jobId, transport: REVIEW_STORY_TRANSPORT, apiScope: scope, reconciliationRequired: true, paidReplayAllowed: false });
+      if (object(lastJob?.result)) for (const key of ["operationId", "accountCostEvents", "acceptedTaskCosts", "costUsd", "usage", "model", "partialProviderUsage"]) {
+        if (lastJob.result[key] !== undefined) error[key] = lastJob.result[key];
+      }
+      throw error;
+    }
+  }
+  return Object.freeze({ run, read: (jobId, options = {}) => run(null, { ...options, jobId, readOnly: true }) });
+}

package/lib/review-tools.mjs

@@ -9,7 +9,7 @@ import { wavDurationSec } from "./audio-duration.mjs";
 import { mp3DurationSec } from "./mp3-duration.mjs";
 import { createUsageEventId } from "./usage-event.mjs";
 import { assertReviewBudget, bindReviewRenderSources, inspectReviewLocalFile, readReviewHandle, REVIEW_MAX_FRAMES, reviewPublicSources, validateReviewSources } from "./review-sources.mjs";
-import { fullReviewStatus, runFullReviewAnalysis, selectReviewPlanningCatalog } from "./review-full-analysis.mjs";
+import { refreshFullReviewStatus, runFullReviewAnalysis, selectReviewPlanningCatalog } from "./review-full-analysis.mjs";
 
 const spoiler = z.enum(["none", "limited", "full", "unknown"]);
 const interval = z.object({ startMs: z.number().int().min(0), endMs: z.number().int().positive(),
@@ -96,10 +96,10 @@ export function registerReviewTools(server, config, api, { wrap = handler => han
     }
   });
   server.tool("analyze_review_sources",
-    "영화·드라마 전체 영상+오디오를 Gemini 3.8로 분석하고 서사와 원본 근거를 재검증합니다. 기본 full은 모든 구간을 최대300초 MP4로 압축하여 클라우드에 전송하므로 사용자 업로드·과금 동의 후 allowCloudVideoUpload:true 필수. 첫 호출은 무료 원본 검사/범위 준비만, 이후 resumePath로 기본1단계씩 계속하세요. 완료된 청크는 재과금하지 않으며 실패 재시도는 명시 승인 필요. 대표 프레임 점검만 원하면 analysisScope:'sample'을 명시하세요(전체 이해가 아님).",
+    "영화·드라마 전체 영상+오디오를 Gemini 3.8로 분석하고 서사와 원본 근거를 재검증합니다. 기본 full은 모든 구간을 최대300초 MP4로 압축하여 클라우드에 전송하므로 사용자 업로드·과금 동의 후 allowCloudVideoUpload:true 필수. 첫 호출은 무료 원본 검사/범위 준비만, 이후 resumePath로 기본1단계씩 계속하세요. 지원 서버에서는 영상 업로드·구간 분석·줄거리·원본 검증을 영속 작업으로 기록합니다. 기존 작업은 조회/업로드 확인만 하며 접수 미확정 유료 요청이나 업로드를 재전송하지 않습니다. 완료된 청크는 재과금하지 않습니다. 명시된 기존 동기 방식의 실패 재시도만 승인 후 가능합니다. 모순/근거 부족 판정은 저장하고 사람 검토를 기다립니다. 대표 프레임 점검만 원하면 analysisScope:'sample'을 명시하세요(전체 이해가 아님).",
     { sources: z.array(sourceInput).min(1).max(5).optional(), analysisScope: z.enum(["full", "sample"]).optional(),
       allowCloudVideoUpload: z.boolean().optional(), resumePath: z.string().optional(), workTitle: z.string().max(200).optional(),
-      maxSteps: z.number().int().min(1).max(4).optional(), retryFailedStage: z.boolean().optional(),
+      maxSteps: z.number().int().min(1).max(4).optional(), retryFailedStage: z.boolean().optional().describe("기존 동기 실패 단계만 추가 과금 재시도 승인. 업로드/구간/줄거리/검증 큐의 접수 미확정 작업과 이미 받은 결과는 재전송하지 않습니다. 모순·근거 부족 판정도 재과금하지 않습니다."),
       maxFrames: z.number().int().min(3).max(REVIEW_MAX_FRAMES).optional() },
     wrapReview(async (args, extra) => {
       if (args.analysisScope !== "sample") return result(await runFullReviewAnalysis({ config, api, args, companionJson,
@@ -194,7 +194,7 @@ export function registerReviewTools(server, config, api, { wrap = handler => han
     }));
 
   server.tool("review_analysis_status", "전체 원작 분석의 최신 진행률·청크 완료·원본 검증·누적 비용을 조회합니다. 유료 API를 호출하지 않습니다. 오래된 resumePath도 최신 체크포인트를 찾아 반환합니다.",
-    { resumePath: z.string() }, wrapReview(async ({ resumePath }) => result(fullReviewStatus(config, resumePath))));
+    { resumePath: z.string() }, wrapReview(async ({ resumePath }) => result(await refreshFullReviewStatus(config, api, resumePath))));
 
   server.tool("plan_review_video",
     "검토한 영화·드라마 원본 카탈로그로 60~900초 리뷰를 기획합니다. 원작 사실·해석·가상해석을 구분하며 spoilerPolicy를 지킵니다. reviewSourcePath는 analyze_review_sources 결과. 영화 전체를 봤다고 가정하지 않으며 기획에 분석 과금이 발생할 수 있습니다. 반환 productionPath를 보이스 추천·리뷰 편집에 전달하세요.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aimakeall-mcp",
-  "version": "0.14.1",
+  "version": "0.14.3",
   "description": "AImakeAll MCP 서버 — Claude Code/Codex에서 자연어로 영상 기획·생성·렌더·퍼블리시 (렌더는 로컬 컴패니언)",
   "type": "module",
   "bin": {
@@ -23,6 +23,9 @@
     "@modelcontextprotocol/sdk": "^1.30.0",
     "zod": "^3.25.1"
   },
-  "bundleDependencies": ["@modelcontextprotocol/sdk", "zod"],
+  "bundleDependencies": [
+    "@modelcontextprotocol/sdk",
+    "zod"
+  ],
   "license": "UNLICENSED"
 }