aimakeall-mcp 0.9.1 → 0.10.0

package/README.md

@@ -16,7 +16,7 @@ Claude Code·Codex 같은 MCP 클라이언트에서 자연어로 AImakeAll 영
   "mcpServers": {
     "aimakeall": {
       "command": "npx",
-      "args": ["-y", "aimakeall-mcp@0.9.1"],
+      "args": ["-y", "aimakeall-mcp@0.10.0"],
       "env": { "AIMAKEALL_PAT": "aio_pat_..." }
     }
   }
@@ -35,13 +35,14 @@ Claude Code·Codex 같은 MCP 클라이언트에서 자연어로 AImakeAll 영
 ## 기본 플로우 (쇼츠)
 
 ```
-plan_shorts_video → (씬마다) generate_scene_image → [QC: 동봉 이미지 직접 확인 또는 verify_scene_image] → generate_scene_video_prompt → generate_scene_video → [QC: 동봉 프레임 확인 또는 verify_scene_video]
+plan_shorts_video → (씬마다) generate_scene_image → get_generation_job(completed까지 조회) → [QC: 동봉 이미지 직접 확인 또는 verify_scene_image] → generate_scene_video_prompt → generate_scene_video → get_generation_job(completed까지 조회) → [QC: 동봉 프레임 확인 또는 verify_scene_video]
 → (보이스 미지정 시) recommend_voice → tts_narration_with_captions(하단자막·강조용) 또는 tts_narration → stitch_timeline → render_start → render_status(폴링) → render_result
 → ai_publish_metadata → publish_youtube
 ```
 
-- 씬 영상 생성은 동기 호출로 최대 15분 걸립니다 — MCP 클라이언트의 툴 타임아웃(`MCP_TIMEOUT`)을 충분히 잡아주세요.
-- 렌더 잡은 `~/.aimakeall/render-jobs.json`에 기록되어 프록시 재시작 후 `list_render_jobs`로 복구할 수 있습니다.
+- 이미지·영상 생성은 즉시 `generationJobId`를 반환합니다. `get_generation_job`으로 상태를 조회하고 `completed`의 `imageUrl`/`videoUrl`을 다음 단계에 사용하세요. 연결이 끊겼을 때는 재생성 전에 `list_generation_jobs`로 기존 작업을 확인하세요. 완료 결과는 서버 DB에 48시간 보관되며 계정 소유자만 조회할 수 있습니다.
+- 서버 자체가 생성 중 재시작되면 작업은 `interrupted`로 표시됩니다. 이미 접수된 `providerTasks`와 비용 원장을 확인해야 하며, 자동으로 유료 생성을 재실행하지 않습니다. 이 기능에는 0.10.0 대응 서버가 필요합니다.
+- 렌더 잡은 `~/.aimakeall/render-jobs/` 아래 작업별 파일에 기록되어 프록시 재시작 후 `list_render_jobs`로 복구할 수 있습니다. 기존 `render-jobs.json`도 계속 읽을 수 있습니다.
 - 대용량 산출물(TTS mp3, 스티치 매니페스트)은 파일 경로로 주고받아 모델 컨텍스트를 오염시키지 않습니다.
 - `recommend_voice`는 주제·샘플 영상(유튜브)에 맞는 보이스를 자동 선정합니다 — 샘플 화자 분석은 컴패니언 앱이 실행 중일 때만 동작합니다.
 - 자체검증(QC): 씬 이미지/영상 결과에 이미지·프레임 블록이 동봉되어 에이전트가 직접 보고 판정합니다. 비전 미지원 클라이언트는 `verify_scene_image`/`verify_scene_video`(서버 Gemini 판정)를 쓰세요 — 불합격 시 `regenerationHint`를 반영해 재생성.

package/lib/audio-duration.mjs

@@ -0,0 +1,57 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+import { mp3DurationSec } from "./mp3-duration.mjs";
+
+// WAV duration comes from sample frames, never an assumed MP3 bitrate. Walk RIFF
+// chunks because encoders may include JUNK/LIST metadata before the audio data.
+export function wavDurationSec(buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length < 44
+    || buffer.toString("ascii", 0, 4) !== "RIFF"
+    || buffer.toString("ascii", 8, 12) !== "WAVE") return 0;
+  let format = null;
+  let dataBytes = 0;
+  for (let offset = 12; offset + 8 <= buffer.length;) {
+    const id = buffer.toString("ascii", offset, offset + 4);
+    const size = buffer.readUInt32LE(offset + 4);
+    const body = offset + 8;
+    if (id === "fmt " && size >= 16 && body + size <= buffer.length) {
+      let encoding = buffer.readUInt16LE(body);
+      if (encoding === 0xfffe && size >= 40) {
+        // WAVE_FORMAT_EXTENSIBLE PCM / IEEE_FLOAT subformat GUID.
+        const guidTail = buffer.subarray(body + 28, body + 40).toString("hex");
+        encoding = guidTail === "00001000800000aa00389b71" ? buffer.readUInt32LE(body + 24) : 0;
+      }
+      format = {
+        encoding,
+        channels: buffer.readUInt16LE(body + 2),
+        sampleRate: buffer.readUInt32LE(body + 4),
+        blockAlign: buffer.readUInt16LE(body + 12),
+        bits: buffer.readUInt16LE(body + 14),
+      };
+    } else if (id === "data") {
+      dataBytes += Math.min(size, buffer.length - body);
+    }
+    offset = body + size + (size % 2);
+  }
+  if (!format || !format.channels || !format.sampleRate) return 0;
+  const allowedBits = format.encoding === 1 ? [8, 16, 24, 32] : format.encoding === 3 ? [32, 64] : [];
+  if (!allowedBits.includes(format.bits)) return 0;
+  const blockAlign = format.channels * (format.bits / 8);
+  if (format.blockAlign !== blockAlign) return 0;
+  return Math.round((Math.floor(dataBytes / blockAlign) / format.sampleRate) * 100) / 100;
+}
+
+export function audioDurationSecFromFile(filePath) {
+  const buffer = readFileSync(filePath);
+  if (path.extname(filePath).toLowerCase() === ".wav"
+    || (buffer.toString("ascii", 0, 4) === "RIFF" && buffer.toString("ascii", 8, 12) === "WAVE")) {
+    const seconds = wavDurationSec(buffer);
+    if (seconds > 0) return seconds;
+    throw new Error("WAV 길이를 읽지 못했습니다. PCM WAV로 변환하거나 audioDurationSec에 실제 길이를 지정하세요.");
+  }
+  const seconds = mp3DurationSec(buffer);
+  if (seconds > 0) return seconds;
+  // Preserve the existing approximation only for unparseable MP3 inputs.
+  return Math.round((buffer.length * 8) / (128 * 1000) * 10) / 10;
+}

package/lib/audio-duration.test.mjs

@@ -0,0 +1,89 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { audioDurationSecFromFile, wavDurationSec } from "./audio-duration.mjs";
+import { fileToDataUrl } from "./media-store.mjs";
+
+function makeWav({ seconds = 10, rate = 16000, channels = 1, bits = 16, encoding = 1, metadata = false, extensible = false } = {}) {
+  const formatBytes = extensible ? 40 : 16;
+  const header = Buffer.alloc(20 + formatBytes);
+  header.write("RIFF");
+  header.write("WAVE", 8);
+  header.write("fmt ", 12);
+  header.writeUInt32LE(formatBytes, 16);
+  header.writeUInt16LE(extensible ? 0xfffe : encoding, 20);
+  header.writeUInt16LE(channels, 22);
+  header.writeUInt32LE(rate, 24);
+  const blockAlign = channels * bits / 8;
+  header.writeUInt32LE(rate * blockAlign, 28);
+  header.writeUInt16LE(blockAlign, 32);
+  header.writeUInt16LE(bits, 34);
+  if (extensible) {
+    header.writeUInt16LE(22, 36);
+    header.writeUInt16LE(bits, 38);
+    header.writeUInt32LE(encoding, 44);
+    Buffer.from("00001000800000aa00389b71", "hex").copy(header, 48);
+  }
+  const junk = metadata ? Buffer.from([0x4a, 0x55, 0x4e, 0x4b, 3, 0, 0, 0, 1, 2, 3, 0]) : Buffer.alloc(0);
+  const data = Buffer.alloc(8 + Math.round(seconds * rate) * blockAlign);
+  data.write("data");
+  data.writeUInt32LE(data.length - 8, 4);
+  const buffer = Buffer.concat([header, junk, data]);
+  buffer.writeUInt32LE(buffer.length - 8, 4);
+  return buffer;
+}
+
+test("WAV 길이는 128kbps 추정이 아닌 실제 샘플 수다", () => {
+  for (const options of [
+    {},
+    { rate: 48000, channels: 2, bits: 24, metadata: true },
+    { rate: 44100, channels: 2, bits: 32, encoding: 3 },
+    { rate: 48000, channels: 2, bits: 24, extensible: true },
+    { rate: 8000, bits: 8 },
+  ]) {
+    assert.equal(wavDurationSec(makeWav(options)), 10, JSON.stringify(options));
+  }
+});
+
+test("WAV byteRate 자기신고 값으로 길이가 왜곡되지 않는다", () => {
+  const wav = makeWav();
+  wav.writeUInt32LE(16000, 28);
+  assert.equal(wavDurationSec(wav), 10);
+});
+
+test("실제 WAV 파일 자동 길이와 data URL MIME을 유지", (t) => {
+  const dir = mkdtempSync(path.join(tmpdir(), "aio-wav-duration-"));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  const file = path.join(dir, "ten-seconds.wav");
+  writeFileSync(file, makeWav());
+  assert.equal(audioDurationSecFromFile(file), 10);
+  assert.match(fileToDataUrl(file), /^data:audio\/wav;base64,/u);
+  const source = readFileSync(new URL("./cloud-tools.mjs", import.meta.url), "utf8");
+  assert.match(source, /import \{ audioDurationSecFromFile \} from "\.\/audio-duration\.mjs"/u);
+  assert.match(source, /ttsAudioPath \? audioDurationSecFromFile\(ttsAudioPath\)/u);
+  assert.match(source, /ttsAudioUrl: ttsAudioPath \? fileToDataUrl\(ttsAudioPath\) : ""/u);
+  assert.match(source, /bgmAudioUrl: bgmAudioPath \? fileToDataUrl\(bgmAudioPath\) : ""/u);
+});
+
+test("손상·미지원 WAV는 MP3 비트레이트로 잘못 추정하지 않는다", (t) => {
+  const dir = mkdtempSync(path.join(tmpdir(), "aio-invalid-wav-"));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  const file = path.join(dir, "unsupported.wav");
+  writeFileSync(file, makeWav({ encoding: 6 }));
+  assert.throws(() => audioDurationSecFromFile(file), /audioDurationSec/u);
+  assert.equal(wavDurationSec(Buffer.alloc(44)), 0);
+  assert.equal(wavDurationSec(makeWav().subarray(0, 30)), 0);
+});
+
+test("MP3 길이 프레임 파싱은 유지된다", (t) => {
+  const dir = mkdtempSync(path.join(tmpdir(), "aio-mp3-duration-"));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  const frame = Buffer.alloc(417);
+  Buffer.from([0xff, 0xfb, 0x90, 0]).copy(frame);
+  const file = path.join(dir, "audio.mp3");
+  writeFileSync(file, Buffer.concat(Array.from({ length: 100 }, () => frame)));
+  assert.equal(audioDurationSecFromFile(file), 2.61);
+});

package/lib/cloud-tools.mjs

@@ -9,8 +9,8 @@ import { AimakeallApiError } from "./api-client.mjs";
 import { extractCompanionAudio } from "./companion-client.mjs";
 import {
   ALLOWED_IMAGE_EXTS,
-  ALLOWED_VIDEO_EXTS,
   assertAllowedInputFile,
+  assertAllowedVideoUpload,
   encodedDataUrlBytes,
   fileToDataUrl,
   fileToImagePayload,
@@ -20,9 +20,10 @@ import {
   savePayloadHandle,
   SERVER_JSON_BODY_LIMIT_BYTES,
 } from "./media-store.mjs";
-import { mp3DurationSec } from "./mp3-duration.mjs";
+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 { loudnessDbfsFromWav, silenceRatioFromWav } from "./wav-dsp.mjs";
 import { trimWavToSeconds } from "./wav-trim.mjs";
 
@@ -74,18 +75,6 @@ function isSafePublicImageUrl(rawUrl) {
   }
 }
 
-// 실측 mp3 길이(초) — 파싱 실패 시에만 CBR-128 근사로 폴백.
-function audioDurationSecFromFile(filePath) {
-  try {
-    const real = mp3DurationSec(readFileSync(filePath));
-    if (real > 0) return real;
-  } catch {
-    // fall through
-  }
-  const size = statSync(filePath).size;
-  return Math.round((size * 8) / (128 * 1000) * 10) / 10;
-}
-
 // aimakeall.com 클라우드 툴 — PAT 필요. 기획·씬 생성·TTS·SUNO·스티치·퍼블리시.
 // 렌더는 여기 없다: 스티치가 만든 타임라인 페이로드를 render_start(로컬 컴패니언)로 넘긴다.
 // 대용량 산출물(오디오·매니페스트·base64 이미지)은 모델 컨텍스트로 돌려주지 않고
@@ -191,6 +180,64 @@ function trimAnalysis(analysis) {
 }
 
 export function registerCloudTools(server, config, api) {
+  async function completedGenerationResult(job, includePreview) {
+    const payload = job.result || {};
+    const resultBody = { generationJobId: job.id, status: job.status, kind: job.kind,
+      model: payload.model, taskId: payload.taskId, providerTasks: job.providerTasks };
+    if (job.kind === "image") {
+      resultBody.imageUrl = payload.imageUrl || undefined;
+      let inlineImage = null;
+      if (!payload.imageUrl && payload.imageDataUrl) {
+        const match = String(payload.imageDataUrl).match(/^data:([^;]+);base64,(.+)$/s);
+        if (match) {
+          const ext = match[1].includes("png") ? "png" : "jpg";
+          resultBody.savedPath = saveMediaBuffer(config.stateDir, `scene-image.${ext}`, Buffer.from(match[2], "base64")).filePath;
+          if (includePreview && ALLOWED_INLINE_IMAGE_MIME.has(match[1].toLowerCase()) && match[2].length <= MAX_INLINE_IMAGE_BYTES * 4 / 3) {
+            inlineImage = { base64: match[2], mimeType: match[1].toLowerCase() };
+          }
+        }
+      } else if (includePreview && payload.imageUrl) {
+        inlineImage = await downloadImageAsBase64(payload.imageUrl);
+      }
+      resultBody.qc = inlineImage ? "동봉 이미지를 확인한 뒤 다음 단계로 진행하세요."
+        : "verify_scene_image로 검증하세요. imageUrl이 없으면 savedPath를 imagePath로 넘기세요.";
+      return inlineImage ? jsonWithImagesResult(resultBody, [inlineImage]) : jsonResult(resultBody);
+    }
+    Object.assign(resultBody, { videoUrl: payload.videoUrl, durationLabel: payload.durationLabel, resolvedRouteLabel: payload.resolvedRouteLabel });
+    let frames = [];
+    if (includePreview && payload.videoUrl) {
+      try {
+        const response = await api.request("/api/tracker/video/frames", {
+          method: "POST", body: { count: 3, maxWidth: 480, videoUrl: payload.videoUrl }, timeoutMs: 20_000,
+        });
+        if (response?.ok && Array.isArray(response.frames)) frames = response.frames;
+      } catch { /* A preview failure must not hide the generated video. */ }
+    }
+    resultBody.qc = frames.length ? "동봉 프레임을 확인한 뒤 stitch_timeline으로 진행하세요." : "verify_scene_video로 영상 품질을 확인하세요.";
+    return frames.length ? jsonWithImagesResult(resultBody, frames) : jsonResult(resultBody);
+  }
+
+  server.tool(
+    "get_generation_job",
+    "generate_scene_image/video가 반환한 generationJobId의 상태·결과를 조회합니다. running이면 잠시 뒤 다시 조회하고, completed의 imageUrl/videoUrl로 다음 단계를 진행하세요. 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),
+      { isError: job.status === "failed" || job.status === "interrupted" });
+    }),
+  );
+
+  server.tool(
+    "list_generation_jobs",
+    "내 계정의 최근 이미지·영상 생성 작업 ID와 상태를 조회합니다. 연결이 끊기거나 MCP를 재시작했을 때 결과를 복구하고 중복 생성을 피하는 데 사용하세요.",
+    {},
+    wrapCloudHandler(config, async () => jsonResult(await api.request(GENERATION_JOB_PATH, { timeoutMs: 30_000 }))),
+  );
+
   server.tool(
     "get_usage",
     "내 플랜과 기능별 렌더 쿼터 현황을 조회합니다. 생성 작업 전에 확인하세요.",
@@ -446,8 +493,9 @@ export function registerCloudTools(server, config, api) {
 
   server.tool(
     "generate_scene_image",
-    "씬 이미지를 생성합니다 (기획 결과의 imagePrompt 사용). 반환된 imageUrl을 씬 영상 생성의 입력으로 쓰세요. 인물·제품 일관성은 이 참조 방식이 권장 경로입니다: 첫 씬(또는 캐릭터 시트/제품 사진)의 이미지를 referenceImageUrls·referenceImagePaths로 모든 씬에 앵커로 전달하세요. 결과에 이미지 블록이 동봉됩니다 — 반드시 직접 보고 QC(캐릭터 앵커·왜곡·지시 이행) 후 불합격 시 재생성하세요. 이미지를 볼 수 없으면 verify_scene_image 사용.",
+    "씬 이미지 생성 작업을 접수하고 즉시 generationJobId를 반환합니다. get_generation_job으로 completed 결과의 imageUrl을 받은 뒤 씬 영상 입력에 쓰세요. 첫 씬/캐릭터/제품 이미지를 referenceImageUrls·referenceImagePaths로 전달하면 일관성 유지에 도움이 됩니다. 완료 이미지는 직접 확인하거나 verify_scene_image로 검증하세요.",
     {
+      requestId: z.string().optional().describe("접수 응답 유실 후 같은 작업을 재확인할 때 기존 generationJobId를 지정합니다. 동일 ID·입력은 중복 생성하지 않습니다."),
       prompt: z.string().describe("이미지 프롬프트 (plan 결과의 imagePrompt)"),
       aspectRatio: z.string().optional().describe("기본 9:16"),
       model: z.enum(["gpt-image-2-beta", "gemini-3.1-flash-image-preview", "doubao-seedream-5.0-lite", "google-flow-nano-banana-pro", "kie-grok-imagine-image"]).optional().describe("이미지 모델, 기본 gpt-image-2-beta"),
@@ -457,7 +505,7 @@ export function registerCloudTools(server, config, api) {
       referenceImageUrls: z.array(z.string()).max(6).optional().describe("참조 이미지 URL (씬1 앵커 등)"),
       referenceImagePaths: z.array(z.string()).max(4).optional().describe("참조 이미지 로컬 경로 (제품 사진 등)"),
     },
-    wrapCloudHandler(config, async ({ prompt, aspectRatio = "9:16", model = "gpt-image-2-beta", resolution = "1K", referenceImageUrls = [], referenceImagePaths = [], returnImage = true, identityLock = "" }) => {
+    wrapCloudHandler(config, async ({ requestId, prompt, aspectRatio = "9:16", model = "gpt-image-2-beta", resolution = "1K", referenceImageUrls = [], referenceImagePaths = [], returnImage = true, identityLock = "" }) => {
       // identity_lock 리터럴 부착 — 이미 포함돼 있으면 재부착하지 않는다(멱등: 프롬프트 캐시 보존).
       const lock = String(identityLock || "").trim();
       if (lock && !prompt.includes(lock)) prompt = `${prompt.trim()}, ${lock}`;
@@ -471,8 +519,9 @@ export function registerCloudTools(server, config, api) {
         ...referenceImageUrls.map((url, index) => ({ name: `ref-${index + 1}`, previewUrl: url })),
       ].slice(0, 6);
 
-      const payload = await api.request("/api/tracker/gemini/storyboard-scene-image", {
-        body: {
+      return jsonResult(await submitGenerationJob(api, {
+        kind: "image", includePreview: returnImage, requestId,
+        input: {
           aspectRatio,
           model,
           prompt,
@@ -481,38 +530,7 @@ export function registerCloudTools(server, config, api) {
           resolution,
           webSearchEnabled: true,
         },
-        method: "POST",
-        timeoutMs: 240_000,
-      });
-
-      let imageUrl = String(payload?.imageUrl || "");
-      let savedPath = "";
-      let inlineImage = null;
-      if (!imageUrl && payload?.imageDataUrl) {
-        // URL 없이 base64만 온 경우 — 컨텍스트로 돌려주지 않고 파일로 저장.
-        const match = String(payload.imageDataUrl).match(/^data:([^;]+);base64,(.+)$/s);
-        if (match) {
-          const ext = match[1].includes("png") ? "png" : "jpg";
-          const saved = saveMediaBuffer(config.stateDir, `scene-image.${ext}`, Buffer.from(match[2], "base64"));
-          savedPath = saved.filePath;
-          const inlineMime = String(match[1]).toLowerCase();
-          if (returnImage && ALLOWED_INLINE_IMAGE_MIME.has(inlineMime) && match[2].length <= MAX_INLINE_IMAGE_BYTES * 4 / 3) {
-            inlineImage = { base64: match[2], mimeType: inlineMime };
-          }
-        }
-      } else if (imageUrl && returnImage) {
-        inlineImage = await downloadImageAsBase64(imageUrl);
-      }
-      const resultBody = {
-        imageUrl: imageUrl || undefined,
-        model: payload?.model,
-        qc: inlineImage
-          ? "동봉된 이미지를 직접 확인하세요: 캐릭터 앵커 일치·손가락/글자 왜곡·프롬프트 이행. 불합격이면 사유를 프롬프트에 반영해 재생성하세요. 이미지를 볼 수 없는 클라이언트라면 verify_scene_image 를 호출하세요."
-          : "이미지를 동봉하지 못했습니다 — verify_scene_image 로 서버측 검증을 수행하세요 (imageUrl 이 없으면 savedPath 를 imagePath 로 넘기세요).",
-        savedPath: savedPath || undefined,
-        taskId: payload?.taskId,
-      };
-      return inlineImage ? jsonWithImagesResult(resultBody, [inlineImage]) : jsonResult(resultBody);
+      }));
     }),
   );
 
@@ -559,8 +577,9 @@ export function registerCloudTools(server, config, api) {
 
   server.tool(
     "generate_scene_video",
-    "씬 영상을 생성합니다 (동기 호출, 최대 ~30분 — MCP 클라이언트의 툴 타임아웃(MCP_TIMEOUT)을 그 이상으로 늘려두세요. 타임아웃되면 이미 과금된 결과를 회수할 수 없으니 주의). 반환된 videoUrl을 stitch_timeline의 sceneVideos에 넣으세요. 결과에 대표 프레임 3장이 동봉됩니다 — 반드시 직접 보고 QC 후 불합격 시 재생성하세요. 볼 수 없으면 verify_scene_video 사용.",
+    "씬 영상 생성 작업을 접수하고 즉시 generationJobId를 반환합니다. get_generation_job으로 completed가 될 때까지 조회한 뒤 videoUrl을 stitch_timeline에 넣으세요. 접수만 된 상태에서 새로 생성하지 마세요.",
     {
+      requestId: z.string().optional().describe("접수 응답 유실 후 동일 입력을 재접수할 때 기존 generationJobId를 지정합니다."),
       prompt: z.string().describe("영상 프롬프트 (generate_scene_video_prompt의 videoPrompt)"),
       sceneImageUrl: z.string().optional().describe("씬 이미지 URL (i2v 입력)"),
       aspectRatio: z.string().optional().describe("기본 9:16"),
@@ -569,9 +588,10 @@ export function registerCloudTools(server, config, api) {
       quality: z.string().optional().describe("기본 720p"),
       returnFrames: z.boolean().optional().describe("기본 true — 결과 영상의 대표 프레임 3장을 직접 보고 QC 할 수 있게 이미지 블록으로 반환"),
     },
-    wrapCloudHandler(config, async ({ prompt, sceneImageUrl = "", aspectRatio = "9:16", durationSec = 8, modelId = "kie-grok-imagine", quality = "720p", returnFrames = true }) => {
-      const payload = await api.request("/api/tracker/gemini/storyboard-scene-video", {
-        body: {
+    wrapCloudHandler(config, async ({ requestId, prompt, sceneImageUrl = "", aspectRatio = "9:16", durationSec = 8, modelId = "kie-grok-imagine", quality = "720p", returnFrames = true }) => {
+      return jsonResult(await submitGenerationJob(api, {
+        kind: "video", includePreview: returnFrames, requestId,
+        input: {
           aspectRatio,
           durationLabel: `${Math.max(1, Math.ceil(durationSec))}s`,
           generationPlan: {
@@ -587,35 +607,7 @@ export function registerCloudTools(server, config, api) {
           selectedVideoModel: { id: modelId },
           videoGenerationSettings: { inputMode: sceneImageUrl ? "image" : "text", quality },
         },
-        method: "POST",
-        // 서버 최악 경로(KIE 900s + Evolink 폴백 3회×900s)를 넘겨 잡아 조기 abort 로 과금-미회수를 방지.
-        timeoutMs: 1_800_000,
-      });
-      // 대표 프레임 동봉(1층 QC) — 실패는 조용히 넘기고 verify_scene_video 안내로 대체.
-      let frames = [];
-      if (returnFrames && payload?.videoUrl) {
-        try {
-          const frameResp = await api.request("/api/tracker/video/frames", {
-            body: { count: 3, maxWidth: 480, videoUrl: payload.videoUrl },
-            method: "POST",
-            timeoutMs: 60_000, // 과금 완료된 결과를 오래 붙들지 않기 — 실패해도 verify 폴백 안내
-          });
-          if (frameResp?.ok && Array.isArray(frameResp?.frames)) frames = frameResp.frames;
-        } catch {
-          frames = [];
-        }
-      }
-      const resultBody = {
-        durationLabel: payload?.durationLabel,
-        model: payload?.model,
-        qc: frames.length
-          ? "동봉된 대표 프레임 3장을 직접 확인하세요: 캐릭터 붕괴·모션 파탄·왜곡. 불합격이면 프롬프트를 교정해 재생성하세요. 프레임을 볼 수 없는 클라이언트라면 verify_scene_video 를 호출하세요."
-          : "프레임을 동봉하지 못했습니다 — verify_scene_video 로 서버측 검증을 수행하세요.",
-        resolvedRouteLabel: payload?.resolvedRouteLabel,
-        taskId: payload?.taskId,
-        videoUrl: payload?.videoUrl,
-      };
-      return frames.length ? jsonWithImagesResult(resultBody, frames) : jsonResult(resultBody);
+      }));
     }),
   );
 
@@ -798,7 +790,7 @@ export function registerCloudTools(server, config, api) {
       const body = {
         aspectRatio,
         audioDurationSec: resolvedAudioDurationSec,
-        bgmAudioUrl: bgmAudioPath ? fileToDataUrl(bgmAudioPath, { mimeType: "audio/mpeg" }) : "",
+        bgmAudioUrl: bgmAudioPath ? fileToDataUrl(bgmAudioPath) : "",
         bgmVolume,
         featureKey,
         muteVideoAudio,
@@ -816,7 +808,7 @@ export function registerCloudTools(server, config, api) {
         subtitleLines,
         titleText,
         transitionMode,
-        ttsAudioUrl: ttsAudioPath ? fileToDataUrl(ttsAudioPath, { mimeType: "audio/mpeg" }) : "",
+        ttsAudioUrl: ttsAudioPath ? fileToDataUrl(ttsAudioPath) : "",
       };
       const response = await api.request("/api/tracker/commerce-video/stitch", {
         body,
@@ -895,8 +887,7 @@ export function registerCloudTools(server, config, api) {
       notifySubscribers: z.boolean().optional().describe("기본 true"),
     },
     wrapCloudHandler(config, async ({ videoPath, title, description = "", tags = [], categoryId = "", visibility = "private", madeForKids = false, notifySubscribers = true }) => {
-      assertAllowedInputFile(videoPath, ALLOWED_VIDEO_EXTS, { kind: "영상 파일" });
-      const stats = statSync(videoPath);
+      const stats = assertAllowedVideoUpload(videoPath);
       // 메타데이터가 쿼리스트링을 타므로 한국어 설명의 퍼센트 인코딩 팽창으로 헤더 상한(16KB)을
       // 넘지 않도록 보수적으로 제한한다.
       const safeTitle = title.slice(0, 100);

package/lib/companion-client.mjs

@@ -1,4 +1,5 @@
-import { createWriteStream, existsSync, mkdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { closeSync, createWriteStream, mkdirSync, openSync, renameSync, rmSync, statSync } from "node:fs";
 import path from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -157,20 +158,31 @@ export function parseContentDispositionFilename(headerValue) {
  * 성공 시 컴패니언이 파일을 삭제(1회성)하므로 저장 성공 후에만 소비된 것으로 본다.
  * 반환: { filePath, bytes } 또는 { error, status }
  */
-// 사용된 파일명이 이미 있으면 -2, -3 … 을 붙여 기존 출력을 덮어쓰지 않는다.
-function uniqueOutputPath(dir, fileName) {
+// wx 로 최종 경로를 먼저 예약한다. 존재 검사만 하면 여러 프로세스가 같은
+// 이름과 .part 파일을 골라 서로의 다운로드를 덮어쓴다.
+function reserveOutputPath(dir, fileName) {
   const ext = path.extname(fileName);
   const base = fileName.slice(0, fileName.length - ext.length);
   let candidate = path.join(dir, fileName);
   let counter = 2;
-  while (existsSync(candidate)) {
-    candidate = path.join(dir, `${base}-${counter}${ext}`);
-    counter += 1;
+  while (true) {
+    try {
+      closeSync(openSync(candidate, "wx", 0o600));
+      return candidate;
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+      candidate = path.join(dir, `${base}-${counter}${ext}`);
+      counter += 1;
+    }
   }
-  return candidate;
 }
 
 export async function downloadRenderOutput(companionUrl, jobId, outputDir, { suggestedName = "" } = {}) {
+  try {
+    mkdirSync(outputDir, { recursive: true });
+  } catch (error) {
+    return { error: `출력 폴더를 준비하지 못했습니다: ${String(error?.message || error)}`, status: 0 };
+  }
   let response;
   try {
     response = await fetch(
@@ -193,17 +205,20 @@ export async function downloadRenderOutput(companionUrl, jobId, outputDir, { sug
   const headerName = parseContentDispositionFilename(response.headers.get("content-disposition"));
   let fileName = sanitizeOutputFilename(suggestedName || headerName, `render-${jobId}.mp4`);
   if (!/\.[A-Za-z0-9]{1,5}$/u.test(fileName)) fileName += ".mp4"; // 확장자 없으면 mp4 보정
-  mkdirSync(outputDir, { recursive: true });
-  const finalPath = uniqueOutputPath(outputDir, fileName);
-  const partPath = `${finalPath}.part`;
-
+  let finalPath = "";
+  let partPath = "";
   try {
-    await pipeline(Readable.fromWeb(response.body), createWriteStream(partPath, { mode: 0o600 }));
+    finalPath = reserveOutputPath(outputDir, fileName);
+    partPath = `${finalPath}.${randomUUID()}.part`;
+    await pipeline(Readable.fromWeb(response.body), createWriteStream(partPath, { flags: "wx", mode: 0o600 }));
+    const bytes = statSync(partPath).size;
     renameSync(partPath, finalPath);
+    return { bytes, filePath: finalPath };
   } catch (error) {
     // 중단 시 부분 파일 정리 — 잡은 다운로드 실패로 남아 재시도 가능(네트워크 abort 시 서버가 복구).
-    try { rmSync(partPath, { force: true }); } catch { /* ignore */ }
+    await response.body?.cancel().catch(() => {});
+    if (partPath) { try { rmSync(partPath, { force: true }); } catch { /* ignore */ } }
+    if (finalPath) { try { rmSync(finalPath, { force: true }); } catch { /* ignore */ } }
     return { error: `출력 저장 중 오류: ${String(error?.message || error)} — render_status로 상태 확인 후 다시 시도하세요.`, status: 0 };
   }
-  return { bytes: statSync(finalPath).size, filePath: finalPath };
 }

package/lib/companion-client.test.mjs

@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { downloadRenderOutput } from "./companion-client.mjs";
+
+function fixture(t) {
+  const dir = mkdtempSync(path.join(tmpdir(), "aio-download-test-"));
+  const originalFetch = globalThis.fetch;
+  t.after(() => {
+    globalThis.fetch = originalFetch;
+    rmSync(dir, { recursive: true, force: true });
+  });
+  return dir;
+}
+
+test("동시 같은 이름 다운로드는 독립 파일로 저장하고 기존 출력도 보존", async (t) => {
+  const dir = fixture(t);
+  writeFileSync(path.join(dir, "same.mp4"), "EXISTING");
+  globalThis.fetch = async (url) => {
+    const text = String(url).includes("job-a/") ? "AAAACCCC" : "BBBBDDDD";
+    return new Response(new ReadableStream({
+      start(controller) {
+        controller.enqueue(Buffer.from(text.slice(0, 4)));
+        setTimeout(() => {
+          controller.enqueue(Buffer.from(text.slice(4)));
+          controller.close();
+        }, 20);
+      },
+    }), { headers: { "content-disposition": 'attachment; filename="same.mp4"' } });
+  };
+  const results = await Promise.all([
+    downloadRenderOutput("http://mock.invalid", "job-a", dir),
+    downloadRenderOutput("http://mock.invalid", "job-b", dir),
+  ]);
+  assert.ok(results.every((result) => !result.error), JSON.stringify(results));
+  assert.equal(new Set(results.map((result) => result.filePath)).size, 2);
+  assert.deepEqual(results.map((result) => readFileSync(result.filePath, "utf8")), ["AAAACCCC", "BBBBDDDD"]);
+  assert.deepEqual(results.map((result) => result.bytes), [8, 8]);
+  assert.equal(readFileSync(path.join(dir, "same.mp4"), "utf8"), "EXISTING");
+  assert.deepEqual(readdirSync(dir).sort(), ["same-2.mp4", "same-3.mp4", "same.mp4"]);
+});
+
+test("중단된 다운로드는 자기 임시 파일·예약만 정리한다", async (t) => {
+  const dir = fixture(t);
+  writeFileSync(path.join(dir, "same.mp4"), "EXISTING");
+  globalThis.fetch = async () => new Response(new ReadableStream({
+    start(controller) {
+      controller.enqueue(Buffer.from("partial"));
+      setTimeout(() => controller.error(new Error("fixture connection lost")), 10);
+    },
+  }));
+  const result = await downloadRenderOutput("http://mock.invalid", "job", dir, { suggestedName: "same.mp4" });
+  assert.match(result.error, /fixture connection lost/u);
+  assert.deepEqual(readdirSync(dir), ["same.mp4"]);
+  assert.equal(readFileSync(path.join(dir, "same.mp4"), "utf8"), "EXISTING");
+});
+
+test("출력 폴더 오류는 일회성 다운로드 요청 전에 반환", async (t) => {
+  const dir = fixture(t);
+  const notDirectory = path.join(dir, "file");
+  writeFileSync(notDirectory, "keep");
+  let called = false;
+  globalThis.fetch = async () => { called = true; throw new Error("must not fetch"); };
+  const result = await downloadRenderOutput("http://mock.invalid", "job", notDirectory);
+  assert.ok(result.error);
+  assert.equal(called, false);
+  assert.equal(readFileSync(notDirectory, "utf8"), "keep");
+});

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.9.1";
+export const MCP_PROXY_VERSION = "0.10.0";
 
 export const DEFAULT_API_BASE = "https://aimakeall.com";
 export const DEFAULT_COMPANION_URL = "http://127.0.0.1:9876";

package/lib/generation-jobs.mjs

@@ -0,0 +1,39 @@
+import { randomUUID } from "node:crypto";
+
+export const GENERATION_JOB_PATH = "/api/tracker/mcp/generation-jobs";
+const JOB_ID = /^[a-zA-Z0-9_-]{16,80}$/;
+
+export function assertGenerationJobId(id) {
+  if (!JOB_ID.test(String(id || ""))) throw new Error("유효한 generationJobId가 필요합니다.");
+  return id;
+}
+
+// Submission never waits for a provider. The server owns the long-running work;
+// both its result and accepted task IDs remain queryable after MCP restarts.
+export async function submitGenerationJob(api, { kind, input, requestId = randomUUID(), includePreview = true }) {
+  assertGenerationJobId(requestId);
+  try {
+    const response = await api.request(GENERATION_JOB_PATH, {
+      method: "POST", body: { id: requestId, kind, input, includePreview }, timeoutMs: 30_000,
+    });
+    if (response?.job?.id !== requestId) throw new Error("생성 작업 접수 응답을 확인할 수 없습니다.");
+    return { generationJobId: requestId, status: response.job.status, kind, includePreview,
+      existing: response.existing === true, nextTool: "get_generation_job",
+      guidance: "생성 작업을 접수했습니다. get_generation_job으로 조회해 completed 결과를 확인한 뒤 다음 단계로 진행하세요. 같은 장면을 다시 생성하지 마세요." };
+  } catch (error) {
+    if (Number(error?.status) >= 400 && Number(error?.status) < 500) throw error;
+    // A lost acceptance response does not establish failure: don't submit a new
+    // paid job. The caller retains the ID, and list_generation_jobs also recovers it.
+    return { generationJobId: requestId, status: "unknown", kind, includePreview,
+      nextTool: "get_generation_job",
+      guidance: "접수 응답이 끊겼습니다. 이 작업 ID 또는 list_generation_jobs로 먼저 확인하세요. 새 작업을 재생성하지 마세요.",
+      error: String(error?.message || error) };
+  }
+}
+
+export async function fetchGenerationJob(api, generationJobId) {
+  const id = assertGenerationJobId(generationJobId);
+  const response = await api.request(`${GENERATION_JOB_PATH}/${encodeURIComponent(id)}`, { timeoutMs: 30_000 });
+  if (!response?.job || response.job.id !== id) throw new Error("생성 작업 상태 응답이 올바르지 않습니다.");
+  return response.job;
+}

package/lib/generation-jobs.test.mjs

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { fetchGenerationJob, submitGenerationJob } from "./generation-jobs.mjs";
+
+const id = "generation-client-test-0001";
+test("submission returns a recoverable handle without waiting for a completed image or video", async () => {
+  const calls = [];
+  const api = { async request(route, options) { calls.push({ route, options }); return { job: { id, status: "running" } }; } };
+  const result = await submitGenerationJob(api, { requestId: id, kind: "image", input: { prompt: "rain" } });
+  assert.equal(result.generationJobId, id);
+  assert.equal(result.nextTool, "get_generation_job");
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].options.body.id, id);
+  assert.equal(calls[0].route, "/api/tracker/mcp/generation-jobs");
+});
+test("a lost acceptance response preserves the ID and never resubmits paid work automatically", async () => {
+  let attempts = 0;
+  const api = { async request() { attempts++; throw new TypeError("fetch failed"); } };
+  const result = await submitGenerationJob(api, { requestId: id, kind: "video", input: {} });
+  assert.equal(result.status, "unknown");
+  assert.equal(result.generationJobId, id);
+  assert.equal(attempts, 1);
+});
+test("authorization and capacity rejections remain actionable errors", async () => {
+  for (const status of [401, 403, 409, 429]) {
+    const error = Object.assign(new Error("rejected"), { status });
+    await assert.rejects(submitGenerationJob({ request: async () => { throw error; } }, { requestId: id, kind: "image", input: {} }), error);
+  }
+});
+test("polls retrieve completed results, check response identity and reject path injection", async () => {
+  assert.equal((await fetchGenerationJob({ request: async () => ({ job: { id, status: "completed", result: { videoUrl: "test" } } }) }, id)).result.videoUrl, "test");
+  await assert.rejects(fetchGenerationJob({ request: async () => ({ job: { id: "another" } }) }, id));
+  await assert.rejects(fetchGenerationJob({ request: async () => { throw new Error("must not call"); } }, "../background-jobs"), /generationJobId/);
+});

package/lib/media-store.mjs

@@ -42,7 +42,7 @@ export function encodedDataUrlBytes(sourceBytes, mimeType = "application/octet-s
 }
 
 // 입력 경로 검증 — 확장자 화이트리스트 + 존재 + 상한. 위반 시 한국어 예외.
-export function assertAllowedInputFile(filePath, allowedExts, { kind = "파일" } = {}) {
+export function assertAllowedInputFile(filePath, allowedExts, { kind = "파일", maxBytes = MAX_DATA_URL_SOURCE_BYTES } = {}) {
   const resolved = String(filePath || "").trim();
   if (!resolved) throw new Error(`${kind} 경로가 비어 있습니다.`);
   const ext = path.extname(resolved).toLowerCase();
@@ -52,14 +52,19 @@ export function assertAllowedInputFile(filePath, allowedExts, { kind = "파일"
   if (!existsSync(resolved)) throw new Error(`${kind}을(를) 찾을 수 없습니다: ${resolved}`);
   const stats = statSync(resolved);
   if (!stats.isFile()) throw new Error(`${kind}이(가) 일반 파일이 아닙니다: ${resolved}`);
-  if (stats.size > MAX_DATA_URL_SOURCE_BYTES) {
+  if (stats.size > maxBytes) {
     throw new Error(
-      `${kind}이(가) 너무 큽니다 (${Math.round(stats.size / 1024 / 1024)}MB > ${Math.round(MAX_DATA_URL_SOURCE_BYTES / 1024 / 1024)}MB): ${resolved}`,
+      `${kind}이(가) 너무 큽니다 (${Math.round(stats.size / 1024 / 1024)}MB > ${Math.round(maxBytes / 1024 / 1024)}MB): ${resolved}`,
     );
   }
   return { ext, size: stats.size };
 }
 
+// raw body 업로드는 base64/JSON 상한과 무관하다. 확장자·일반 파일 검증은 유지한다.
+export function assertAllowedVideoUpload(filePath) {
+  return assertAllowedInputFile(filePath, ALLOWED_VIDEO_EXTS, { kind: "영상 파일", maxBytes: Infinity });
+}
+
 export function saveMediaBuffer(stateDir, name, buffer, { contentType = "" } = {}) {
   const dir = mediaDir(stateDir);
   mkdirSync(dir, { recursive: true });

package/lib/media-store.test.mjs

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, writeFileSync, utimesSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync, utimesSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test, { after } from "node:test";
@@ -7,6 +7,7 @@ import test, { after } from "node:test";
 import {
   ALLOWED_IMAGE_EXTS,
   assertAllowedInputFile,
+  assertAllowedVideoUpload,
   encodedDataUrlBytes,
   fileToDataUrl,
   fileToImagePayload,
@@ -55,6 +56,25 @@ test("크기 상한 초과 파일은 거부", () => {
   assert.throws(() => fileToDataUrl(big), /너무 큽니다/u);
 });
 
+test("스트리밍 MP4는 17MiB를 넘어도 허용하되 파일 종류 검증은 유지", () => {
+  const big = saveMediaBuffer(scratch, "large.mp4", Buffer.alloc(MAX_DATA_URL_SOURCE_BYTES + 1)).filePath;
+  assert.equal(assertAllowedVideoUpload(big).size, MAX_DATA_URL_SOURCE_BYTES + 1);
+  assert.throws(() => assertAllowedVideoUpload(join(scratch, "id_rsa")), /허용되지 않은/u);
+  assert.throws(() => assertAllowedVideoUpload(join(scratch, "missing.mp4")), /찾을 수 없습니다/u);
+  assert.throws(() => fileToDataUrl(big), /허용되지 않은/u);
+  // The binary upload exception must never lift the data-URL audio/image limit.
+  const audio = saveMediaBuffer(scratch, "large.wav", Buffer.alloc(MAX_DATA_URL_SOURCE_BYTES + 1)).filePath;
+  assert.throws(() => fileToDataUrl(audio), /너무 큽니다/u);
+});
+
+test("publish_youtube는 스트리밍 전용 검사기를 사용한다", () => {
+  const source = readFileSync(new URL("./cloud-tools.mjs", import.meta.url), "utf8");
+  const publish = source.slice(source.indexOf('"publish_youtube"'), source.indexOf('"write_script"'));
+  assert.match(publish, /const stats = assertAllowedVideoUpload\(videoPath\)/u);
+  assert.doesNotMatch(publish, /assertAllowedInputFile\(/u);
+  assert.match(publish, /requestStreamUpload\(/u);
+});
+
 test("이미지 페이로드 변환 — {name, mimeType, base64}", () => {
   const imgPath = join(scratch, "product.png");
   writeFileSync(imgPath, Buffer.from([0x89, 0x50, 0x4e, 0x47]));

package/lib/render-job-store.mjs

@@ -1,10 +1,11 @@
-import { randomUUID } from "node:crypto";
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
 
 // 렌더 잡 영속화 — npx 프록시가 재시작돼도 jobId 를 잃지 않도록
-// ~/.aimakeall/render-jobs.json 에 기록한다. 컴패니언 잡 TTL(만료) 은 서버가 판정하므로
-// 여기서는 오래된 항목만 정리한다.
+// 잡별 디렉터리로 분리해 여러 프록시가 공유 배열을 read-modify-write 하며
+// 다른 잡을 잃어버리지 않게 한다. 구버전 render-jobs.json 은 계속 읽되 덮어쓰지 않는다.
+// 같은 잡의 서로 다른 필드도 별도 원자 파일로 저장해 동시 패치를 보존한다.
 
 const MAX_ENTRIES = 50;
 const ENTRY_TTL_MS = 24 * 60 * 60 * 1000;
@@ -13,55 +14,130 @@ export function renderJobStorePath(stateDir) {
   return path.join(stateDir, "render-jobs.json");
 }
 
-function readEntries(filePath) {
+export function renderJobRecordsDir(stateDir) {
+  return path.join(stateDir, "render-jobs");
+}
+
+function digest(value) {
+  return createHash("sha256").update(String(value)).digest("hex");
+}
+
+function jobDirectory(stateDir, jobId) {
+  return path.join(renderJobRecordsDir(stateDir), digest(jobId));
+}
+
+function readJson(filePath) {
   try {
-    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
-    return Array.isArray(parsed?.jobs) ? parsed.jobs : [];
+    return JSON.parse(readFileSync(filePath, "utf8"));
   } catch {
-    return [];
+    return null;
   }
 }
 
-function writeEntries(filePath, jobs) {
+function readDirectory(dir) {
+  try { return readdirSync(dir); } catch { return []; }
+}
+
+function writeJsonAtomic(filePath, value) {
   mkdirSync(path.dirname(filePath), { recursive: true });
-  // 여러 프록시 프로세스(세션마다 별도)가 같은 파일을 쓰므로 tmp 경로를 프로세스·uuid 로
-  // 유일하게 만들어 rename 레이스(ENOENT)를 막는다.
-  const tmpPath = `${filePath}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`;
-  writeFileSync(tmpPath, `${JSON.stringify({ jobs }, null, 2)}\n`, { mode: 0o600 });
-  renameSync(tmpPath, filePath);
+  const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(tmpPath, `${JSON.stringify(value)}\n`, { flag: "wx", mode: 0o600 });
+    renameSync(tmpPath, filePath);
+  } finally {
+    rmSync(tmpPath, { force: true });
+  }
 }
 
-function pruneEntries(jobs, now) {
-  return jobs
-    .filter((job) => job && job.jobId && now - (Number(job.createdAtMs) || 0) < ENTRY_TTL_MS)
-    .slice(-MAX_ENTRIES);
+const IDENTITY_FIELDS = new Set(["jobId", "createdAt", "createdAtMs"]);
+
+function readStoredJob(dir, fallback = null) {
+  const record = readJson(path.join(dir, "record.json"));
+  let job = record?.job?.jobId ? record.job : fallback;
+  if (!job?.jobId) return null;
+  for (const name of readDirectory(dir)) {
+    if (!/^[a-f0-9]{64}\.field\.json$/u.test(name)) continue;
+    const patch = readJson(path.join(dir, name));
+    if (typeof patch?.field !== "string" || IDENTITY_FIELDS.has(patch.field)) continue;
+    job = { ...job, [patch.field]: patch.value };
+  }
+  return { job, order: String(record?.order || "") };
+}
+
+function readAllJobs(stateDir) {
+  const legacy = readJson(renderJobStorePath(stateDir));
+  const entries = new Map();
+  for (const job of Array.isArray(legacy?.jobs) ? legacy.jobs : []) {
+    if (job?.jobId) entries.set(String(job.jobId), { job, order: "" });
+  }
+  for (const name of readDirectory(renderJobRecordsDir(stateDir))) {
+    if (!/^[a-f0-9]{64}$/u.test(name)) continue;
+    const dir = path.join(renderJobRecordsDir(stateDir), name);
+    const record = readJson(path.join(dir, "record.json"));
+    if (!record?.job?.jobId || digest(record.job.jobId) !== name) continue;
+    const entry = readStoredJob(dir);
+    if (entry) entries.set(String(entry.job.jobId), entry);
+  }
+  return [...entries.values()];
+}
+
+function isRecent(job, now) {
+  return Boolean(job?.jobId) && now - (Number(job.createdAtMs) || 0) < ENTRY_TTL_MS;
+}
+
+function pruneExpiredRecords(stateDir, now) {
+  for (const name of readDirectory(renderJobRecordsDir(stateDir))) {
+    if (!/^[a-f0-9]{64}$/u.test(name)) continue;
+    const dir = path.join(renderJobRecordsDir(stateDir), name);
+    const record = readJson(path.join(dir, "record.json"));
+    if (record?.job?.jobId && !isRecent(record.job, now)) {
+      rmSync(dir, { force: true, recursive: true });
+    }
+  }
 }
 
 export function recordRenderJob(stateDir, { jobId, projectTitle = "", statusUrl = "", outputUrl = "" }, now = Date.now()) {
-  const filePath = renderJobStorePath(stateDir);
-  const jobs = pruneEntries(readEntries(filePath), now);
-  jobs.push({
+  const job = {
     createdAt: new Date(now).toISOString(),
     createdAtMs: now,
     jobId: String(jobId || ""),
     outputUrl: String(outputUrl || ""),
     projectTitle: String(projectTitle || ""),
     statusUrl: String(statusUrl || ""),
+  };
+  if (!job.jobId) throw new Error("jobId가 필요합니다.");
+  pruneExpiredRecords(stateDir, now);
+  writeJsonAtomic(path.join(jobDirectory(stateDir, job.jobId), "record.json"), {
+    job,
+    order: process.hrtime.bigint().toString().padStart(24, "0"),
   });
-  writeEntries(filePath, jobs);
-  return jobs[jobs.length - 1];
+  return job;
 }
 
 export function listRenderJobs(stateDir, now = Date.now()) {
-  return pruneEntries(readEntries(renderJobStorePath(stateDir)), now).reverse();
+  return readAllJobs(stateDir)
+    .filter(({ job }) => isRecent(job, now))
+    .sort((left, right) => Number(left.job.createdAtMs) - Number(right.job.createdAtMs)
+      || left.order.localeCompare(right.order))
+    .slice(-MAX_ENTRIES)
+    .reverse()
+    .map(({ job }) => job);
 }
 
 export function updateRenderJob(stateDir, jobId, patch = {}, now = Date.now()) {
-  const filePath = renderJobStorePath(stateDir);
-  const jobs = pruneEntries(readEntries(filePath), now);
-  const index = jobs.findIndex((job) => job.jobId === String(jobId || ""));
-  if (index < 0) return null;
-  jobs[index] = { ...jobs[index], ...patch };
-  writeEntries(filePath, jobs);
-  return jobs[index];
+  const id = String(jobId || "");
+  const legacy = readJson(renderJobStorePath(stateDir));
+  const fallback = (Array.isArray(legacy?.jobs) ? legacy.jobs : []).find((job) => job?.jobId === id);
+  const dir = jobDirectory(stateDir, id);
+  const entry = readStoredJob(dir, fallback);
+  if (!entry || !isRecent(entry.job, now)) return null;
+  // Migrate only this legacy job; leave the original shared file untouched.
+  if (!readJson(path.join(dir, "record.json"))?.job?.jobId) {
+    writeJsonAtomic(path.join(dir, "record.json"), { job: entry.job, order: entry.order });
+  }
+  for (const [field, value] of Object.entries(patch)) {
+    if (IDENTITY_FIELDS.has(field)) continue;
+    writeJsonAtomic(path.join(dir, `${digest(field)}.field.json`), { field, value });
+  }
+  return readStoredJob(dir)?.job || null;
 }

package/lib/render-job-store.test.mjs

@@ -1,20 +1,26 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import test, { after } from "node:test";
+import test from "node:test";
 
 import {
   listRenderJobs,
   recordRenderJob,
+  renderJobRecordsDir,
   renderJobStorePath,
   updateRenderJob,
 } from "./render-job-store.mjs";
 
-const stateDir = mkdtempSync(join(tmpdir(), "aio-mcp-jobstore-"));
-after(() => rmSync(stateDir, { force: true, recursive: true }));
+function fixture(t) {
+  const stateDir = mkdtempSync(join(tmpdir(), "aio-mcp-jobstore-"));
+  t.after(() => rmSync(stateDir, { force: true, recursive: true }));
+  return stateDir;
+}
 
-test("기록 → 목록(최신순) → 갱신 roundtrip", () => {
+test("기록 → 목록(최신순) → 갱신 roundtrip", (t) => {
+  const stateDir = fixture(t);
   recordRenderJob(stateDir, { jobId: "job-1", projectTitle: "첫번째" });
   recordRenderJob(stateDir, { jobId: "job-2", projectTitle: "두번째", statusUrl: "/api/moviepy/render-jobs/job-2" });
 
@@ -29,18 +35,115 @@ test("기록 → 목록(최신순) → 갱신 roundtrip", () => {
   assert.equal(updateRenderJob(stateDir, "missing", { status: "x" }), null);
 });
 
-test("24시간 지난 항목은 정리된다", () => {
+test("24시간 지난 항목은 정리된다", (t) => {
+  const stateDir = fixture(t);
   const now = Date.now();
   recordRenderJob(stateDir, { jobId: "old-job" }, now - 25 * 60 * 60 * 1000);
   const jobs = listRenderJobs(stateDir, now);
   assert.equal(jobs.some((job) => job.jobId === "old-job"), false);
+  recordRenderJob(stateDir, { jobId: "new-job" }, now);
+  assert.equal(readdirSync(renderJobRecordsDir(stateDir)).length, 1);
 });
 
-test("손상된 저장 파일은 빈 목록으로 복구된다", () => {
-  const filePath = renderJobStorePath(stateDir);
-  assert.ok(readFileSync(filePath, "utf8").includes("job-2"));
-  rmSync(filePath);
+test("손상된 legacy 파일이나 잡 레코드는 다른 잡을 지우지 않는다", (t) => {
+  const stateDir = fixture(t);
+  writeFileSync(renderJobStorePath(stateDir), "invalid json");
   assert.deepEqual(listRenderJobs(stateDir), []);
-  recordRenderJob(stateDir, { jobId: "after-reset" });
-  assert.equal(listRenderJobs(stateDir)[0].jobId, "after-reset");
+  recordRenderJob(stateDir, { jobId: "broken" });
+  const firstDir = readdirSync(renderJobRecordsDir(stateDir))[0];
+  writeFileSync(join(renderJobRecordsDir(stateDir), firstDir, "record.json"), "invalid json");
+  recordRenderJob(stateDir, { jobId: "healthy" });
+  assert.deepEqual(listRenderJobs(stateDir).map((job) => job.jobId), ["healthy"]);
+});
+
+test("legacy 목록을 보존하면서 새 저장소에 갱신하고 중복 없이 병합", (t) => {
+  const stateDir = fixture(t);
+  const now = Date.now();
+  const legacy = JSON.stringify({ jobs: [
+    { jobId: "legacy-1", createdAtMs: now - 2, projectTitle: "old title" },
+    { jobId: "legacy-2", createdAtMs: now - 1 },
+  ] });
+  writeFileSync(renderJobStorePath(stateDir), legacy);
+  recordRenderJob(stateDir, { jobId: "new" }, now);
+  updateRenderJob(stateDir, "legacy-1", { status: "downloaded", filePath: "/tmp/kept.mp4" }, now);
+  const jobs = listRenderJobs(stateDir, now);
+  assert.equal(jobs.length, 3);
+  assert.equal(jobs.find((job) => job.jobId === "legacy-1").filePath, "/tmp/kept.mp4");
+  assert.equal(jobs.find((job) => job.jobId === "legacy-1").projectTitle, "old title");
+  assert.equal(readFileSync(renderJobStorePath(stateDir), "utf8"), legacy);
+  rmSync(renderJobStorePath(stateDir));
+  assert.equal(listRenderJobs(stateDir, now).find((job) => job.jobId === "legacy-1").status, "downloaded");
+});
+
+test("최신 50개 상한과 jobId 경로 격리를 유지", (t) => {
+  const stateDir = fixture(t);
+  const now = Date.now();
+  for (let i = 0; i < 55; i++) recordRenderJob(stateDir, { jobId: `../job-${i}` }, now + i);
+  const jobs = listRenderJobs(stateDir, now + 55);
+  assert.equal(jobs.length, 50);
+  assert.equal(jobs[0].jobId, "../job-54");
+  assert.equal(jobs.at(-1).jobId, "../job-5");
+  assert.ok(readdirSync(renderJobRecordsDir(stateDir)).every((name) => /^[a-f0-9]{64}$/u.test(name)));
+});
+
+// Start independent Node processes at the same barrier, not sequential promises
+// in one event loop (the old synchronous read-modify-write passed those tests).
+async function concurrentWorkers(t, stateDir, operation, count = 8) {
+  const moduleUrl = new URL("./render-job-store.mjs", import.meta.url).href;
+  const workers = Array.from({ length: count }, (_, index) => {
+    const source = `
+      import { recordRenderJob, updateRenderJob } from ${JSON.stringify(moduleUrl)};
+      const stateDir = ${JSON.stringify(stateDir)};
+      const worker = ${index};
+      process.stdin.once('data', () => {
+        ${operation}
+        process.stdin.destroy();
+      });
+      process.stdout.write('ready');
+    `;
+    const child = spawn(process.execPath, ["--input-type=module", "--eval", source], { stdio: ["pipe", "pipe", "pipe"] });
+    t.after(() => { if (child.exitCode === null) child.kill(); });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => { stderr += chunk; });
+    const ready = new Promise((resolve, reject) => {
+      child.stdout.once("data", resolve);
+      child.once("error", reject);
+      child.once("exit", (code) => { if (code !== 0) reject(new Error(stderr || `worker exit ${code}`)); });
+    });
+    const done = new Promise((resolve, reject) => {
+      child.once("error", reject);
+      child.once("exit", (code) => code === 0 ? resolve() : reject(new Error(stderr || `worker exit ${code}`)));
+    });
+    return { child, ready, done };
+  });
+  await Promise.all(workers.map(({ ready }) => ready));
+  for (const { child } of workers) child.stdin.end("go");
+  await Promise.all(workers.map(({ done }) => done));
+}
+
+test("8개 프로세스가 동시에 기록·갱신해도 모든 잡이 보존된다", async (t) => {
+  const stateDir = fixture(t);
+  await concurrentWorkers(t, stateDir, `
+    for (let i = 0; i < 4; i++) {
+      const jobId = 'worker-' + worker + '-job-' + i;
+      recordRenderJob(stateDir, { jobId });
+      updateRenderJob(stateDir, jobId, { status: 'succeeded' });
+    }
+  `);
+  const jobs = listRenderJobs(stateDir);
+  assert.equal(jobs.length, 32);
+  assert.equal(new Set(jobs.map((job) => job.jobId)).size, 32);
+  assert.ok(jobs.every((job) => job.status === "succeeded"));
+});
+
+test("같은 잡의 서로 다른 필드에 대한 프로세스 동시 패치를 보존", async (t) => {
+  const stateDir = fixture(t);
+  recordRenderJob(stateDir, { jobId: "shared" });
+  await concurrentWorkers(t, stateDir, `
+    updateRenderJob(stateDir, 'shared', { ['field-' + worker]: 'value-' + worker });
+  `);
+  const [job] = listRenderJobs(stateDir);
+  for (let i = 0; i < 8; i++) assert.equal(job[`field-${i}`], `value-${i}`);
+  updateRenderJob(stateDir, "shared", { status: "downloaded", filePath: "/tmp/shared.mp4", jobId: "other" });
+  assert.equal(listRenderJobs(stateDir)[0].jobId, "shared");
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aimakeall-mcp",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "AImakeAll MCP 서버 — Claude Code/Codex에서 자연어로 영상 기획·생성·렌더·퍼블리시 (렌더는 로컬 컴패니언)",
   "type": "module",
   "bin": {