@keepylabs/cutroom 0.5.7 → 0.7.1

package/README.md

@@ -3,25 +3,44 @@
 Write hooks and scripts with scoring. Break down any reel. Tear down a creator's reels against yours. Finish your own talking-head videos with captions, layouts and effects, checked before you post.
 
 ## Install (one command)
-In your terminal, with your key from the welcome email:
-
-    claude mcp add cutroom -s user -e CUTROOM_KEY=ck_yourkey -- npx -y @keepylabs/cutroom@latest
-
-Restart Claude Code and say "check Cutroom is ready". It checks ffmpeg and Node and installs them with your OK.
+In your terminal:
+
+    claude mcp add cutroom -s user -- npx -y @keepylabs/cutroom@latest
+
+Restart Claude Code and say "check my cutroom setup". Your browser opens Sign in with Whop: sign in with the Whop account you joined with. No key to copy. The check also makes your studio folders and tells you if ffmpeg, whisper or Node is missing.
+
+## Your studio
+Everything lives in the Cutroom folder in your home folder. Open Claude Code there.
+
+    Cutroom/
+      CLAUDE.md          how your studio works: approvals, rules
+      brand/             your colors, logo, frames you love
+      references/        your library: reel breakdowns and creator teardowns
+      inbox/             drop new raw videos here
+      videos/
+        2026-11-01-topic/
+          raw/           this video's footage
+          references/    what this video copies, with a why-it-works note
+          script.md      what you say, word for word
+          facts.md       every number on screen, with its source
+          plan.md        the edit plan and its status
+          renders/       previews and the final export
+          checks.md      what QA found and what got fixed
 
 ## Use
 - "give me hooks for <topic>"
 - "write a short script about <idea>"
 - "break down this reel: <link>"
 - "tear down @creator and compare to @me"
-- "finish this video: ~/Desktop/take3.mov"
+- "finish the video in my inbox"
+- "what videos are unfinished?"
 
-Results are saved in ~/Cutroom. The first video you finish downloads the free HyperFrames renderer and a speech-to-text model (a few hundred MB, once).
+The first video you finish downloads the free HyperFrames renderer and a speech-to-text model (a few hundred MB, once).
 
 ## What you need
-- Claude Code, macOS with Homebrew, Node 20 or newer, ffmpeg
-- A Keepy Labs membership key. No other account or API key.
+- Claude Code on macOS or Windows, Node 22 or newer, ffmpeg, whisper-cli
+- A Keepy Labs membership on Whop. No other account or API key.
 
 ## Privacy
-- Your membership key is the only thing we keep about you, to know your membership is active.
+- Signing in gives Cutroom your Whop name and the key that comes with your membership. The key is saved in your Cutroom folder, readable only by you.
 - Your videos stay on your computer and are rendered there. For breakdowns and QA we receive sampled still frames, and for finishing the transcript words; we use them for that request and keep nothing.

package/cutroom.mjs

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 
 // src/community/local/server.ts
 import { homedir as homedir3 } from "node:os";
-import { delimiter, join as join4 } from "node:path";
+import { delimiter, join as join6 } from "node:path";
 
 // src/community/local/proc.ts
 import { spawnSync } from "node:child_process";
@@ -20,7 +20,12 @@ function run(cmd, args, opt = {}) {
   return spawnSync(cmd, args, o);
 }
 var has = (bin) => spawnSync(WIN ? "where" : "which", [bin], { stdio: "ignore" }).status === 0;
-var installLine = (tool) => WIN ? { ffmpeg: "winget install --id Gyan.FFmpeg -e", node: "winget install --id OpenJS.NodeJS.LTS -e", "node-update": "winget upgrade --id OpenJS.NodeJS.LTS -e" }[tool] : { ffmpeg: "brew install ffmpeg", node: "brew install node", "node-update": "brew upgrade node" }[tool];
+var installLine = (tool) => WIN ? {
+  ffmpeg: "winget install --id Gyan.FFmpeg -e",
+  node: "winget install --id OpenJS.NodeJS.LTS -e",
+  "node-update": "winget upgrade --id OpenJS.NodeJS.LTS -e",
+  whisper: "Download whisper-bin-x64.zip from the latest release at github.com/ggml-org/whisper.cpp/releases, unzip its Release folder into a Cutroom\\whisper folder in the user's home folder, and add that folder to the user PATH"
+}[tool] : { ffmpeg: "brew install ffmpeg", node: "brew install node", "node-update": "brew upgrade node", whisper: "brew install whisper-cpp" }[tool];
 var NODE_MIN = 22;
 function nodeMajor() {
   const r = spawnSync("node", ["--version"], { encoding: "utf8", shell: WIN });
@@ -3467,7 +3472,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve3) {
+function isRecursive(inst, stack, resolve4) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -3477,7 +3482,7 @@ function isRecursive(inst, stack, resolve3) {
   let result2 = NONE;
   const check = (child) => {
     if (result2 !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve3);
+      const answer = isRecursive(child, stack, resolve4);
       if (answer > result2)
         result2 = answer;
     }
@@ -3488,7 +3493,7 @@ function isRecursive(inst, stack, resolve3) {
       const desc = Object.getOwnPropertyDescriptor(sh2, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve3) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve4) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -3552,7 +3557,7 @@ function isRecursive(inst, stack, resolve3) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve3 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve4 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -11244,14 +11249,14 @@ function inputRequiredRoundsExceededMessage(method, maxRounds) {
   return `Multi-round-trip request '${method}' still required input after ${maxRounds} rounds (inputRequired.maxRounds)`;
 }
 function sleep(ms, signal) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     if (signal?.aborted) {
       reject(signal.reason instanceof SdkError ? signal.reason : new SdkError(SdkErrorCode.RequestTimeout, String(signal.reason)));
       return;
     }
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve3();
+      resolve4();
     }, ms);
     const onAbort = () => {
       clearTimeout(timer);
@@ -12045,7 +12050,7 @@ var Protocol = class {
     const flowStartedAt = Date.now();
     let onAbort;
     let cleanupMessageId;
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -12114,7 +12119,7 @@ var Protocol = class {
         }
         if (decoded.kind === "invalid") return reject(decoded.error);
         if (decoded.kind === "input_required") {
-          if (options?.allowInputRequired === true) return resolve3(manualInputRequiredValue(decoded));
+          if (options?.allowInputRequired === true) return resolve4(manualInputRequiredValue(decoded));
           const flow = {
             codec,
             request,
@@ -12126,11 +12131,11 @@ var Protocol = class {
               params
             }, resultSchema, legOptions)
           };
-          return resolve3(this._resolveNonCompleteResult(decoded, flow));
+          return resolve4(this._resolveNonCompleteResult(decoded, flow));
         }
         const result2 = decoded.result;
         validateStandardSchema(resultSchema, result2).then((parseResult) => {
-          if (parseResult.success) resolve3(parseResult.data);
+          if (parseResult.success) resolve4(parseResult.data);
           else reject(new SdkError(SdkErrorCode.InvalidResult, `Invalid result for ${request.method}: ${parseResult.error}`));
         }, reject);
       });
@@ -15042,7 +15047,7 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
     ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
     const schOrFunc = root.refs[ref];
     if (schOrFunc) return schOrFunc;
-    let _sch = resolve3.call(this, root, ref);
+    let _sch = resolve4.call(this, root, ref);
     if (_sch === void 0) {
       const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
       const { schemaId } = this.opts;
@@ -15068,7 +15073,7 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve3(root, ref) {
+  function resolve4(root, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string") ref = sch;
     return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
@@ -15518,47 +15523,47 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
     else if (typeof uri === "object") uri = parse2(serialize(uri, options), options);
     return uri;
   }
-  function resolve3(baseURI, relativeURI, options) {
+  function resolve4(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const resolved = resolveComponent(parse2(baseURI, schemelessOptions), parse2(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
     return serialize(resolved, schemelessOptions);
   }
-  function resolveComponent(base, relative, options, skipNormalization) {
+  function resolveComponent(base, relative2, options, skipNormalization) {
     const target = {};
     if (!skipNormalization) {
       base = parse2(serialize(base, options), options);
-      relative = parse2(serialize(relative, options), options);
+      relative2 = parse2(serialize(relative2, options), options);
     }
     options = options || {};
-    if (!options.tolerant && relative.scheme) {
-      target.scheme = relative.scheme;
-      target.userinfo = relative.userinfo;
-      target.host = relative.host;
-      target.port = relative.port;
-      target.path = removeDotSegments(relative.path || "");
-      target.query = relative.query;
+    if (!options.tolerant && relative2.scheme) {
+      target.scheme = relative2.scheme;
+      target.userinfo = relative2.userinfo;
+      target.host = relative2.host;
+      target.port = relative2.port;
+      target.path = removeDotSegments(relative2.path || "");
+      target.query = relative2.query;
     } else {
-      if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
-        target.userinfo = relative.userinfo;
-        target.host = relative.host;
-        target.port = relative.port;
-        target.path = removeDotSegments(relative.path || "");
-        target.query = relative.query;
+      if (relative2.userinfo !== void 0 || relative2.host !== void 0 || relative2.port !== void 0) {
+        target.userinfo = relative2.userinfo;
+        target.host = relative2.host;
+        target.port = relative2.port;
+        target.path = removeDotSegments(relative2.path || "");
+        target.query = relative2.query;
       } else {
-        if (!relative.path) {
+        if (!relative2.path) {
           target.path = base.path;
-          if (relative.query !== void 0) target.query = relative.query;
+          if (relative2.query !== void 0) target.query = relative2.query;
           else target.query = base.query;
         } else {
-          if (relative.path[0] === "/") target.path = removeDotSegments(relative.path);
+          if (relative2.path[0] === "/") target.path = removeDotSegments(relative2.path);
           else {
-            if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) target.path = "/" + relative.path;
-            else if (!base.path) target.path = relative.path;
-            else target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
+            if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) target.path = "/" + relative2.path;
+            else if (!base.path) target.path = relative2.path;
+            else target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative2.path;
             target.path = removeDotSegments(target.path);
           }
-          target.query = relative.query;
+          target.query = relative2.query;
         }
         target.userinfo = base.userinfo;
         target.host = base.host;
@@ -15566,7 +15571,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
       }
       target.scheme = base.scheme;
     }
-    target.fragment = relative.fragment;
+    target.fragment = relative2.fragment;
     return target;
   }
   function equal(uriA, uriB, options) {
@@ -15692,7 +15697,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   const fastUri = {
     SCHEMES,
     normalize,
-    resolve: resolve3,
+    resolve: resolve4,
     resolveComponent,
     equal,
     serialize,
@@ -21125,7 +21130,7 @@ var StdioServerTransport = class {
   }
   send(message) {
     if (this._closed) return Promise.reject(/* @__PURE__ */ new Error("StdioServerTransport is closed"));
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const json = serializeMessage(message);
       let settled = false;
       const onError = (error2) => {
@@ -21140,14 +21145,14 @@ var StdioServerTransport = class {
         settled = true;
         this._stdout.off("error", onError);
         this._stdout.off("drain", onDrain);
-        resolve3();
+        resolve4();
       };
       this._stdout.once("error", onError);
       if (this._stdout.write(json)) {
         if (settled) return;
         settled = true;
         this._stdout.off("error", onError);
-        resolve3();
+        resolve4();
       } else if (!settled) this._stdout.once("drain", onDrain);
     });
   }
@@ -21201,14 +21206,14 @@ var StdioConnectionChannel = class {
   */
   async whenRequestsAnswered(timeoutMs) {
     if (this._closed || this._pendingRequests.size === 0) return true;
-    return await new Promise((resolve3) => {
+    return await new Promise((resolve4) => {
       const waiter = () => {
         clearTimeout(timer);
-        resolve3(true);
+        resolve4(true);
       };
       const timer = setTimeout(() => {
         this._drainWaiters = this._drainWaiters.filter((pending) => pending !== waiter);
-        resolve3(false);
+        resolve4(false);
       }, timeoutMs);
       this._drainWaiters.push(waiter);
     });
@@ -21550,13 +21555,13 @@ function toError(value) {
 }
 
 // src/community/local/server.ts
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync6 } from "node:fs";
 
 // src/community/local/render.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync3, renameSync, rmSync, statSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { basename, extname, join as join3, resolve as resolve2 } from "node:path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync5, mkdtempSync, readdirSync, readFileSync as readFileSync5, renameSync as renameSync2, rmSync as rmSync2, statSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir2, tmpdir } from "node:os";
+import { basename as basename2, extname, join as join5, resolve as resolve3 } from "node:path";
 
 // src/community/local/measure.ts
 import { execFileSync, spawnSync as spawnSync2 } from "node:child_process";
@@ -21652,18 +21657,143 @@ function technicalChecks(file) {
   return { ...p, lufs, black, freeze, silences, issues };
 }
 
+// src/community/local/studio.ts
+import { appendFileSync, copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename, isAbsolute, join as join4, relative, resolve as resolve2 } from "node:path";
+
 // src/community/local/tools.ts
-import { createWriteStream, existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { createWriteStream, existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir } from "node:os";
-import { join as join2, resolve } from "node:path";
+import { join as join3, resolve } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-var VERSION = "0.5.7";
+
+// src/community/local/signin.ts
+import { spawn } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, writeFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { join as join2 } from "node:path";
+var WHOP_APP = "app_bFhJFdBJn9jZ0v";
+var PORTS = [53171, 53172, 53173];
+var WAIT_MS = 5 * 6e4;
+var keyFile = () => join2(HOME(), ".cutroom-key");
+function currentKey() {
+  try {
+    const k = readFileSync2(keyFile(), "utf8").trim();
+    if (k) return k;
+  } catch {
+  }
+  const env = process.env.CUTROOM_KEY;
+  return env && !env.includes("${") ? env : null;
+}
+function saveKey(key) {
+  mkdirSync2(HOME(), { recursive: true });
+  writeFileSync(keyFile(), key, { mode: 384 });
+  try {
+    chmodSync(keyFile(), 384);
+  } catch {
+  }
+}
+var forgetKey = () => rmSync(keyFile(), { force: true });
+function openBrowser(url2) {
+  const [cmd, args] = process.platform === "darwin" ? ["open", [url2]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url2]] : ["xdg-open", [url2]];
+  try {
+    spawn(cmd, args, { stdio: "ignore", detached: true }).on("error", () => {
+    }).unref();
+  } catch {
+  }
+}
+var page = (title, line) => `<!doctype html><meta charset="utf-8"><title>${title}</title>
+<body style="margin:0;min-height:100vh;display:grid;place-items:center;background:#0A0A0A;color:#F7F3E8;font:16px/1.5 -apple-system,Segoe UI,sans-serif">
+<div style="max-width:420px;padding:24px;text-align:center"><h1 style="font-size:24px;margin:0 0 8px">${title}</h1><p style="color:#A39E93;margin:0">${line}</p></div>`;
+async function listen(handler) {
+  for (const port of PORTS) {
+    const servers = [];
+    try {
+      for (const host of ["127.0.0.1", "::1"]) {
+        const s = createServer(handler);
+        await new Promise((ok, fail) => {
+          s.once("error", fail);
+          s.listen(port, host, () => ok());
+        }).then(() => servers.push(s), (e) => {
+          if (host === "::1" && e?.code !== "EADDRINUSE") return;
+          throw e;
+        });
+      }
+      return { port, close: () => servers.forEach((s) => s.close()) };
+    } catch {
+      servers.forEach((s) => s.close());
+    }
+  }
+  throw new Error("Couldn't start the sign-in (ports 53171 to 53173 are busy). Close other apps and try again.");
+}
+async function signIn(deps = {}) {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const verifier = randomBytes(32).toString("base64url"), state = randomBytes(16).toString("base64url");
+  let done;
+  const result2 = new Promise((r) => done = r);
+  let redirect = "";
+  const server = await listen((req, res) => {
+    const url2 = new URL(req.url ?? "/", "http://localhost");
+    if (url2.pathname !== "/callback") {
+      res.writeHead(404).end();
+      return;
+    }
+    if (url2.searchParams.get("state") !== state) {
+      res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" }).end(page("That link is old", "Go back to Claude and ask it to sign in to Cutroom again."));
+      return;
+    }
+    const error2 = url2.searchParams.get("error");
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" }).end(error2 ? page("Sign-in cancelled", "Go back to Claude. You can sign in again any time.") : page("Signed in to Cutroom", "You can close this tab and go back to Claude."));
+    done(error2 ? { error: url2.searchParams.get("error_description") ?? error2 } : { code: url2.searchParams.get("code") ?? "" });
+  });
+  redirect = `http://localhost:${server.port}/callback`;
+  const authorize = `https://api.whop.com/oauth/authorize?${new URLSearchParams({
+    response_type: "code",
+    client_id: WHOP_APP,
+    redirect_uri: redirect,
+    scope: "openid profile email",
+    state,
+    nonce: randomBytes(16).toString("base64url"),
+    code_challenge: createHash("sha256").update(verifier).digest("base64url"),
+    code_challenge_method: "S256"
+  })}`;
+  process.stderr.write(`Cutroom: sign in with Whop in your browser. If it didn't open, go to:
+${authorize}
+`);
+  (deps.open ?? openBrowser)(authorize);
+  let timer;
+  try {
+    const got = await Promise.race([result2, new Promise((r) => {
+      timer = setTimeout(() => r({ error: "timeout" }), deps.waitMs ?? WAIT_MS);
+    })]);
+    if (got.error === "timeout") throw new Error("The Whop sign-in wasn't finished in 5 minutes. Run the setup check again to get a new sign-in page.");
+    if (got.error || !got.code) throw new Error(`Whop sign-in didn't finish (${got.error ?? "no code"}). Run the setup check again to retry.`);
+    const post = (url2, body2, offline) => fetchImpl(url2, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body2) }).catch(() => {
+      throw new Error(offline);
+    });
+    const tok = await post("https://api.whop.com/oauth/token", { grant_type: "authorization_code", code: got.code, redirect_uri: redirect, client_id: WHOP_APP, code_verifier: verifier }, "Can't reach Whop right now. Check your internet connection and run the setup check again.");
+    const t = await tok.json().catch(() => ({}));
+    if (!tok.ok || !t.access_token) throw new Error("Whop didn't accept the sign-in. Run the setup check again to retry.");
+    const res = await post(`${GATEWAY()}/signin`, { access_token: t.access_token }, "Can't reach Cutroom right now. Check your internet connection and run the setup check again.");
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok || !body.key) throw new Error(body?.error ?? `Cutroom sign-in failed (HTTP ${res.status}).`);
+    saveKey(String(body.key));
+    return { name: String(body.name ?? "member") };
+  } finally {
+    clearTimeout(timer);
+    server.close();
+  }
+}
+
+// src/community/local/tools.ts
+var VERSION = "0.7.1";
 var GATEWAY = () => (process.env.CUTROOM_GATEWAY || "https://keepylabs.com/api/cutroom").replace(/\/$/, "");
-var HOME = () => process.env.CUTROOM_HOME || join2(homedir(), "Cutroom");
+var HOME = () => process.env.CUTROOM_HOME || join3(homedir(), "Cutroom");
 async function call(op, body = {}, fetchImpl = fetch) {
-  const key = process.env.CUTROOM_KEY;
-  if (!key || key.includes("${")) throw new Error("No Cutroom key yet. Connect Cutroom with the install command from your welcome email (it includes your key).");
+  const key = currentKey();
+  if (!key) throw Object.assign(new Error("Not signed in to Cutroom yet. Run the setup check (cutroom_doctor): it opens the Whop sign-in."), { status: 401 });
   const send = () => fetchImpl(`${GATEWAY()}/v1/${op}`, { method: "POST", headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" }, body: JSON.stringify(body) });
   let res;
   try {
@@ -21677,7 +21807,7 @@ async function call(op, body = {}, fetchImpl = fetch) {
     }
   }
   const json = await res.json().catch(() => ({}));
-  if (!res.ok) throw new Error(json?.error ?? `Cutroom error (HTTP ${res.status}).`);
+  if (!res.ok) throw Object.assign(new Error(json?.error ?? `Cutroom error (HTTP ${res.status}).`), { status: res.status });
   return json;
 }
 var slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
@@ -21689,23 +21819,39 @@ async function download(url2, target) {
   if (!res.ok || !res.body) throw new Error(`Couldn't download the video (HTTP ${res.status}).`);
   await pipeline(Readable.fromWeb(res.body), createWriteStream(target));
 }
-async function doctor() {
+async function doctor(opts = {}) {
+  const studioFolder = ensureStudio();
   const checks = [
     { name: "ffmpeg", ok: has("ffmpeg") && has("ffprobe"), fix: installLine("ffmpeg") },
+    { name: "whisper (captions)", ok: has("whisper-cli"), fix: installLine("whisper") },
     (() => {
       const v = has("npx") ? nodeMajor() : 0;
       if (!v) return { name: "Node.js (for rendering)", ok: false, fix: installLine("node") };
       return v >= NODE_MIN ? { name: `Node.js ${v} (for rendering)`, ok: true } : { name: `Node.js ${v} is too old (rendering needs ${NODE_MIN} or newer)`, ok: false, fix: installLine("node-update") };
     })()
   ];
-  let member = null;
+  let member = null, signed_in_now = false;
   try {
-    member = await call("me");
-    checks.push({ name: "Cutroom membership key", ok: true });
+    const again = async () => {
+      forgetKey();
+      await signIn();
+      signed_in_now = true;
+      return call("me");
+    };
+    if (opts.fresh) member = await again();
+    else {
+      try {
+        member = await call("me");
+      } catch (e) {
+        if (e?.status !== 401) throw e;
+        member = await again();
+      }
+    }
+    checks.push({ name: "Cutroom membership (signed in with Whop)", ok: true });
   } catch (e) {
-    checks.push({ name: "Cutroom membership key", ok: false, fix: e.message });
+    checks.push({ name: "Cutroom membership (signed in with Whop)", ok: false, fix: e.message });
   }
-  return { ready: checks.every((c) => c.ok), helper_version: VERSION, checks, member, results_folder: HOME() };
+  return { ready: checks.every((c) => c.ok), helper_version: VERSION, checks, member, ...signed_in_now ? { signed_in_now } : {}, studio: studioFolder };
 }
 function approxWords(text, duration3) {
   const words = (text ?? "").split(/\s+/).filter(Boolean);
@@ -21724,7 +21870,7 @@ function localWords(file, dir) {
   try {
     const meta2 = JSON.parse(r.stdout.trim().split("\n").pop() ?? "{}");
     if (r.status !== 0 || !meta2.ok) return null;
-    const raw = JSON.parse(readFileSync2(meta2.transcriptPath ?? join2(dir, "transcript.json"), "utf8"));
+    const raw = JSON.parse(readFileSync3(meta2.transcriptPath ?? join3(dir, "transcript.json"), "utf8"));
     const words = raw.map((w) => ({ t: Math.round(w.start * 100) / 100, e: Math.round(w.end * 100) / 100, w: w.text.trim() })).filter((w) => w.w);
     return words.length ? words : null;
   } catch {
@@ -21748,18 +21894,18 @@ async function breakdownReel(input) {
     const r = await call("reel", { url: src });
     meta2 = r.meta;
     transcript = r.transcript;
-    const dir2 = join2(HOME(), "breakdowns", `${day()}-${slug(meta2.ownerUsername ?? "reel")}-${meta2.shortCode}`);
-    mkdirSync2(dir2, { recursive: true });
-    file = join2(dir2, "source.mp4");
-    if (!existsSync(file)) await download(meta2.videoUrl, file);
+    const dir2 = join3(studio.references(), `${day()}-${slug(meta2.ownerUsername ?? "reel")}-${meta2.shortCode}`);
+    mkdirSync3(dir2, { recursive: true });
+    file = join3(dir2, "source.mp4");
+    if (!existsSync2(file)) await download(meta2.videoUrl, file);
   } else {
     file = resolve(src.replace(/^~/, homedir()));
-    if (!existsSync(file)) throw new Error(`No such file: ${file}`);
+    if (!existsSync2(file)) throw new Error(`No such file: ${file}`);
   }
-  const dir = /^https?:/i.test(src) ? join2(file, "..") : join2(HOME(), "breakdowns", `${day()}-${slug(file.split("/").pop() ?? "video")}`);
-  mkdirSync2(dir, { recursive: true });
+  const dir = /^https?:/i.test(src) ? join3(file, "..") : join3(studio.references(), `${day()}-${slug(file.split(/[\\/]/).pop() ?? "video")}`);
+  mkdirSync3(dir, { recursive: true });
   const m = measure(file);
-  const { frames, interval } = sampleFrames(file, join2(dir, "frames"), m.duration, 1, 40);
+  const { frames, interval } = sampleFrames(file, join3(dir, "frames"), m.duration, 1, 40);
   const match = await call("match", { frames: frames.map(({ t, jpg_base64 }) => ({ t, jpg_base64 })), interval });
   const timed = localWords(file, dir);
   const words = timed ?? approxWords(transcript, m.duration);
@@ -21799,9 +21945,9 @@ async function breakdownReel(input) {
     transcript ?? "(none)",
     ""
   ].join("\n");
-  writeFileSync(join2(dir, "breakdown.md"), md);
-  const out = { folder: dir, report: join2(dir, "breakdown.md"), hook, measure: m, look: s, beats: bs, words_timing: timed ? "measured" : transcript ? "approximate" : "none", transcript, meta: meta2, next: "Get the 'breakdown_writeup' method with get_method and follow it." };
-  writeFileSync(join2(dir, "breakdown.json"), JSON.stringify(out, null, 2));
+  writeFileSync2(join3(dir, "breakdown.md"), md);
+  const out = { folder: dir, report: join3(dir, "breakdown.md"), hook, measure: m, look: s, beats: bs, words_timing: timed ? "measured" : transcript ? "approximate" : "none", transcript, meta: meta2, next: "Get the 'breakdown_writeup' method with get_method and follow it." };
+  writeFileSync2(join3(dir, "breakdown.json"), JSON.stringify(out, null, 2));
   return out;
 }
 function ctaKeyword(caption) {
@@ -21810,15 +21956,15 @@ function ctaKeyword(caption) {
 }
 async function teardownOne(handle, limit) {
   const { reels } = await call("reels", { handle, limit });
-  const dir = join2(HOME(), "teardowns", `${day()}-${slug(handle)}`);
-  mkdirSync2(join2(dir, "raw"), { recursive: true });
+  const dir = join3(studio.references(), `${day()}-${slug(handle)}-creator`);
+  mkdirSync3(join3(dir, "raw"), { recursive: true });
   const rows = [];
   for (const [i, r] of reels.entries()) {
     try {
-      const file = join2(dir, "raw", `${String(i + 1).padStart(2, "0")}-${r.shortCode}.mp4`);
-      if (!existsSync(file)) await download(r.videoUrl, file);
+      const file = join3(dir, "raw", `${String(i + 1).padStart(2, "0")}-${r.shortCode}.mp4`);
+      if (!existsSync2(file)) await download(r.videoUrl, file);
       const m = measure(file);
-      const { frames, interval } = sampleFrames(file, join2(dir, "frames", r.shortCode), m.duration, 2, 20);
+      const { frames, interval } = sampleFrames(file, join3(dir, "frames", r.shortCode), m.duration, 2, 20);
       const [match, tr] = await Promise.all([call("match", { frames: frames.map(({ t, jpg_base64 }) => ({ t, jpg_base64 })), interval }), call("transcript", { url: r.url }).catch(() => ({ transcript: null }))]);
       const top = (o) => Object.keys(o)[0] ?? null;
       rows.push({ code: r.shortCode, url: r.url, posted: String(r.timestamp ?? "").slice(0, 10), plays: r.videoPlayCount ?? null, duration_s: Math.round(m.duration * 10) / 10, cuts_per_min: m.cuts_per_min, layout: top(match.summary.layout_share), caption: top(match.summary.caption_share), effects: match.summary.effects.filter((e) => e.share >= 0.1 || e.frames >= 2).map((e) => e.title), off_menu: match.summary.effects.filter((e) => e.in_menu === false).map((e) => e.title), hook: tr.transcript ? String(tr.transcript).split(/(?<=[.!?])\s/)[0] : null, cta: ctaKeyword(r.caption) });
@@ -21890,24 +22036,121 @@ async function creatorTeardown(input) {
     ...a.rows.map((x) => x.error ? `| ${x.posted} | ${x.plays ?? ""} | | | failed: ${String(x.error).slice(0, 60)} | | |` : `| [${x.posted}](${x.url}) | ${x.plays ?? ""} | ${x.duration_s} | ${x.cuts_per_min} | ${x.layout ?? ""} | ${x.effects.join(", ")} | ${(x.hook ?? "").replace(/\|/g, "/").slice(0, 90)} |`),
     ""
   ].join("\n");
-  writeFileSync(join2(a.dir, "teardown.md"), md);
-  const out = { folder: a.dir, report: join2(a.dir, "teardown.md"), rollup: r, compare: cmp, rows: a.rows, next: "Get the 'teardown_writeup' method with get_method and follow it." };
-  writeFileSync(join2(a.dir, "teardown.json"), JSON.stringify(out, null, 2));
+  writeFileSync2(join3(a.dir, "teardown.md"), md);
+  const out = { folder: a.dir, report: join3(a.dir, "teardown.md"), rollup: r, compare: cmp, rows: a.rows, next: "Get the 'teardown_writeup' method with get_method and follow it." };
+  writeFileSync2(join3(a.dir, "teardown.json"), JSON.stringify(out, null, 2));
   return out;
 }
 
+// src/community/local/studio.ts
+var studio = {
+  brand: () => join4(HOME(), "brand"),
+  references: () => join4(HOME(), "references"),
+  inbox: () => join4(HOME(), "inbox"),
+  videos: () => join4(HOME(), "videos")
+};
+var CLAUDE_MD = `# My Cutroom studio
+
+Everything for my videos lives in this folder. Open Claude Code here so it can see it all.
+
+## Where things go
+- inbox/: drop new raw videos here. When a video starts, its clip moves into that video's raw/ folder.
+- videos/<date>-<topic>/: one folder per video, with everything for it:
+  - raw/: the footage
+  - references/: only what this video copies (Pinterest images, the reel it matches), each with a one-line "why it works" in references/notes.md
+  - script.md: what I say, word for word
+  - facts.md: every number or claim on screen, with its source
+  - plan.md: the edit plan and a status line (footage ready, plan ready, preview, final, posted)
+  - renders/: previews and the final export
+  - checks.md: what QA found and what got fixed
+- brand/: my colors (brand.json), logo and a few frames I love.
+- references/: my library of reels and creators I study across videos, each with a breakdown of why it works.
+
+## Rules
+- Three stops: I approve the script, then the plan, then the preview. Nothing final renders before that.
+- Never invent a number. Every figure on screen goes in facts.md with its source.
+- Other creators' reels are for study only: never reuse their words, footage or branding.
+- When QA catches a mistake, add a rule here so it doesn't happen again.
+
+## My rules
+`;
+function ensureStudio() {
+  for (const d of Object.values(studio)) mkdirSync4(d(), { recursive: true });
+  const claude = join4(HOME(), "CLAUDE.md");
+  if (!existsSync3(claude)) writeFileSync3(claude, CLAUDE_MD);
+  const oldBrand = join4(HOME(), "brand.json"), newBrand = join4(studio.brand(), "brand.json");
+  if (existsSync3(oldBrand) && !existsSync3(newBrand)) renameSync(oldBrand, newBrand);
+  return HOME();
+}
+var inside = (child, parent) => {
+  const r = relative(parent, child);
+  return !!r && !r.startsWith("..") && !isAbsolute(r);
+};
+function takeRaw(source, folder) {
+  const raw = join4(folder, "raw");
+  const file = resolve2(source);
+  if (inside(file, raw)) return { file, how: "already here" };
+  mkdirSync4(raw, { recursive: true });
+  let target = join4(raw, basename(file));
+  for (let n = 2; existsSync3(target); n++) target = join4(raw, basename(file).replace(/(\.[^.]*)?$/, `-${n}$1`));
+  if (inside(file, studio.inbox())) {
+    try {
+      renameSync(file, target);
+      return { file: target, how: "moved from inbox" };
+    } catch {
+    }
+  }
+  copyFileSync(file, target);
+  return { file: target, how: "copied" };
+}
+function setStatus(folder, status, plan) {
+  const file = join4(folder, "plan.md");
+  const name = basename(folder);
+  const current = existsSync3(file) ? readFileSync4(file, "utf8") : `# ${name}
+
+status: 
+`;
+  const withStatus = /^status:.*$/m.test(current) ? current.replace(/^status:.*$/m, `status: ${status}`) : current.replace(/^(# .*\n)/, `$1
+status: ${status}
+`);
+  writeFileSync3(file, plan === void 0 ? withStatus : `${withStatus.split(/\n## Plan\n/)[0].trimEnd()}
+
+## Plan
+${plan}
+`);
+}
+function startVideoNotes(folder, transcript) {
+  const script = join4(folder, "script.md"), facts = join4(folder, "facts.md"), notes = join4(folder, "references", "notes.md");
+  mkdirSync4(join4(folder, "references"), { recursive: true });
+  if (!existsSync3(notes)) writeFileSync3(notes, "# References for this video\n\nWhat this video copies and why it works, one line each.\n\n");
+  if (!existsSync3(script)) writeFileSync3(script, `# Script
+
+What I say, word for word (from the footage; fix any misheard words here).
+
+${transcript}
+`);
+  if (!existsSync3(facts)) writeFileSync3(facts, "# Facts\n\nEvery number or claim that shows on screen, with where it comes from.\n\n| on screen | source |\n| - | - |\n");
+}
+function addCheck(folder, entry) {
+  const file = join4(folder, "checks.md");
+  if (!existsSync3(file)) writeFileSync3(file, "# Checks\n\nWhat QA found on each render, and what got fixed.\n");
+  appendFileSync(file, `
+${entry.trim()}
+`);
+}
+
 // src/community/local/render.ts
 var HF = "hyperframes@0.8.99";
 var day2 = () => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 var slug2 = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "reel";
 var sh = (cmd, args, cwd) => run(cmd, args, { cwd, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
 var tail = (s) => (s ?? "").trim().split("\n").slice(-6).join("\n");
-var projectFile = (folder) => join3(folder, ".cutroom", "project.json");
+var projectFile = (folder) => join5(folder, ".cutroom", "project.json");
 var resolveProject = (p) => {
-  const folder = resolve2(p.replace(/^~/, homedir2()));
-  const file = existsSync2(projectFile(folder)) ? projectFile(folder) : existsSync2(join3(HOME(), "renders", p, ".cutroom", "project.json")) ? join3(HOME(), "renders", p, ".cutroom", "project.json") : null;
+  const folder = resolve3(p.replace(/^~/, homedir2()));
+  const file = [folder, join5(studio.videos(), p), join5(HOME(), "renders", p)].map(projectFile).find((f) => existsSync4(f)) ?? null;
   if (!file) throw new Error(`No prepared footage at ${p}. Run prepare_footage first.`);
-  return JSON.parse(readFileSync3(file, "utf8"));
+  return JSON.parse(readFileSync5(file, "utf8"));
 };
 function cutAndNormalize(src, out, segments) {
   const parts = segments.map(([s, e], i) => `[0:v]trim=${s}:${e},setpts=PTS-STARTPTS[v${i}];[0:a]atrim=${s}:${e},asetpts=PTS-STARTPTS[a${i}];`).join("");
@@ -21922,19 +22165,21 @@ function looksLikeSpeech(words, duration3) {
   return readable.length >= Math.max(3, duration3 * 0.6) && readable.length >= words.length * 0.8;
 }
 async function prepareFootage(input) {
-  const source = resolve2(input.video.replace(/^~/, homedir2()));
-  if (!existsSync2(source)) throw new Error(`No such file: ${source}`);
+  const source = resolve3(input.video.replace(/^~/, homedir2()));
+  if (!existsSync4(source)) throw new Error(`No such file: ${source}`);
   const p = probe(source);
   if (!p.has_audio) throw new Error("That video has no sound. Cutroom finishing needs you talking to camera.");
   if (p.duration > 180) throw new Error("Keep it under 3 minutes for one reel.");
-  const name = slug2(input.name ?? basename(source, extname(source)));
-  const folder = join3(HOME(), "renders", `${day2()}-${name}`);
-  const work = join3(folder, ".cutroom");
-  mkdirSync3(work, { recursive: true });
-  const segments = input.cut_pauses === false ? [[0, p.duration]] : keepSegments(p.duration, parseSilences(silenceLog(source), p.duration));
+  const name = slug2(input.name ?? basename2(source, extname(source)));
+  ensureStudio();
+  const folder = join5(studio.videos(), `${day2()}-${name}`);
+  const work = join5(folder, ".cutroom");
+  mkdirSync5(work, { recursive: true });
+  const clip = takeRaw(source, folder);
+  const segments = input.cut_pauses === false ? [[0, p.duration]] : keepSegments(p.duration, parseSilences(silenceLog(clip.file), p.duration));
   if (!segments.length) throw new Error("Couldn't find any speech in that video.");
-  const footage = join3(work, "footage.mp4");
-  cutAndNormalize(source, footage, segments);
+  const footage = join5(work, "footage.mp4");
+  cutAndNormalize(clip.file, footage, segments);
   const duration3 = probe(footage).duration;
   const lang = (input.language ?? "en").toLowerCase().slice(0, 5);
   const t = sh("npx", ["--yes", HF, "transcribe", "footage.mp4", "--json", "-d", ".", ...lang === "en" ? [] : ["--language", lang, "-m", "large-v3"]], work);
@@ -21947,31 +22192,34 @@ async function prepareFootage(input) {
   })();
   if (t.status !== 0 || !meta2.ok) throw new Error(`Transcription failed. Run cutroom_doctor.
 ${meta2.error ?? tail(t.stderr)}`);
-  const raw = JSON.parse(readFileSync3(meta2.transcriptPath ?? join3(work, "transcript.json"), "utf8"));
+  const raw = JSON.parse(readFileSync5(meta2.transcriptPath ?? join5(work, "transcript.json"), "utf8"));
   const words = raw.map((w) => ({ t: Math.round(w.start * 100) / 100, e: Math.round(w.end * 100) / 100, w: w.text.trim() })).filter((w) => w.w);
   if (!looksLikeSpeech(words, duration3)) throw new Error(lang === "en" ? "I couldn't hear anyone talking in this video (it sounds like music or silence). Cutroom finishing needs you talking to camera. If you speak another language, tell me which one and I'll try again." : `I couldn't make out the speech in this video, even in that language. Check the sound is you talking to camera.`);
-  const project = { name, folder, source, footage, duration: Math.round(duration3 * 100) / 100, words, removed_s: Math.round((p.duration - duration3) * 10) / 10, segments };
-  writeFileSync2(projectFile(folder), JSON.stringify(project, null, 2));
+  const project = { name, folder, source: clip.file, footage, duration: Math.round(duration3 * 100) / 100, words, removed_s: Math.round((p.duration - duration3) * 10) / 10, segments };
+  writeFileSync4(projectFile(folder), JSON.stringify(project, null, 2));
+  startVideoNotes(folder, words.map((w) => w.w).join(" "));
+  setStatus(folder, "footage ready");
   const landscape = (p.width ?? 0) > (p.height ?? 0) * 1.05;
   return {
     project: folder,
+    raw: `${clip.file} (${clip.how})`,
     duration: project.duration,
     pauses_removed_s: project.removed_s,
     ...landscape ? { warning: "This video is landscape (wide). Cutroom crops the middle of it to make it vertical, so anything off-center gets cut, and an already-edited video (split screen, titles, captions burned in) will look wrong. Tell the user plainly and ask for the raw vertical take of them talking; continue only if they say this one is fine." } : {},
     transcript: words.map((w) => `${w.t.toFixed(2)} ${w.w}`).join("\n"),
-    next: "Check the transcript for misheard words (pass them as fixes). Then plan: list_styles, get_method('edit_plan') and follow it, then plan_reel to show the storyboard. Nothing renders until the user says go."
+    next: "Check the transcript for misheard words (pass them as fixes). References for this video go in its references/ folder. Then plan: list_styles, get_method('edit_plan') and follow it, then plan_reel to show the storyboard. Nothing renders until the user says go."
   };
 }
 async function ensureFonts(work) {
-  const cache = join3(HOME(), ".kit", "fonts");
+  const cache = join5(HOME(), ".kit", "fonts");
   const need = ["Inter-Regular.woff2", "Inter-SemiBold.woff2", "RobotoMono-Bold.ttf", "InstrumentSerif-Italic.ttf"];
-  if (!need.every((f) => existsSync2(join3(cache, f)))) {
+  if (!need.every((f) => existsSync4(join5(cache, f)))) {
     const { fonts } = await call("fonts");
-    mkdirSync3(cache, { recursive: true });
-    for (const [f, b64] of Object.entries(fonts)) writeFileSync2(join3(cache, basename(f)), Buffer.from(b64, "base64"));
+    mkdirSync5(cache, { recursive: true });
+    for (const [f, b64] of Object.entries(fonts)) writeFileSync4(join5(cache, basename2(f)), Buffer.from(b64, "base64"));
   }
-  mkdirSync3(join3(work, "fonts"), { recursive: true });
-  for (const f of need) writeFileSync2(join3(work, "fonts", f), readFileSync3(join3(cache, f)));
+  mkdirSync5(join5(work, "fonts"), { recursive: true });
+  for (const f of need) writeFileSync4(join5(work, "fonts", f), readFileSync5(join5(cache, f)));
 }
 function applyFixes(words, fixes = []) {
   return words.map((w) => {
@@ -21979,46 +22227,48 @@ function applyFixes(words, fixes = []) {
     return f ? { ...w, w: f.to } : w;
   }).filter((w) => w.w);
 }
-var brandFile = () => join3(HOME(), "brand.json");
+var brandFile = () => join5(studio.brand(), "brand.json");
 function getBrand() {
-  try {
-    return JSON.parse(readFileSync3(brandFile(), "utf8"));
-  } catch {
-    return null;
+  for (const f of [brandFile(), join5(HOME(), "brand.json")]) {
+    try {
+      return JSON.parse(readFileSync5(f, "utf8"));
+    } catch {
+    }
   }
+  return null;
 }
 async function setBrand(input) {
   if (input.reset) {
-    rmSync(brandFile(), { force: true });
+    rmSync2(brandFile(), { force: true });
     return { brand: null, saved: "Back to the default look." };
   }
   const { reset, ...fields } = input;
   const next = { ...getBrand() ?? {}, ...Object.fromEntries(Object.entries(fields).filter(([, v]) => v)) };
   await call("compose", { duration: 2, words: [], brand: next, check_only: true });
-  mkdirSync3(HOME(), { recursive: true });
-  writeFileSync2(brandFile(), JSON.stringify(next, null, 2));
+  ensureStudio();
+  writeFileSync4(brandFile(), JSON.stringify(next, null, 2));
   return { brand: next, saved: brandFile(), next: "Every render now uses these. Render a draft to see them." };
 }
 var PICTURE = /\.(jpe?g|png|webp)$/i;
 function safeAssetName(file, i) {
-  const m = basename(file).match(PICTURE);
+  const m = basename2(file).match(PICTURE);
   if (!m) throw new Error(`Pictures must be jpg, png or webp: ${file}`);
   const ext = m[1].toLowerCase() === "jpeg" ? "jpg" : m[1].toLowerCase();
-  return `${i + 1}-${slug2(basename(file, extname(file)))}.${ext}`;
+  return `${i + 1}-${slug2(basename2(file, extname(file)))}.${ext}`;
 }
 function localImages(work, layoutImages, effects) {
   const names = /* @__PURE__ */ new Map();
-  const dir = join3(work, "assets");
+  const dir = join5(work, "assets");
   const swap = (v) => {
     const raw = String(v ?? "").trim();
-    if (/^assets\/[\w.-]+$/.test(raw) && existsSync2(join3(work, raw))) return raw;
-    const file = resolve2(raw.replace(/^~(?=$|\/)/, homedir2()));
+    if (/^assets\/[\w.-]+$/.test(raw) && existsSync4(join5(work, raw))) return raw;
+    const file = resolve3(raw.replace(/^~(?=$|\/)/, homedir2()));
     if (!names.has(file)) {
-      if (!existsSync2(file) || !statSync(file).isFile()) throw new Error(`Can't find the picture ${raw}. Use the full path of a jpg, png or webp file on this computer.`);
+      if (!existsSync4(file) || !statSync(file).isFile()) throw new Error(`Can't find the picture ${raw}. Use the full path of a jpg, png or webp file on this computer.`);
       if (names.size >= 8) throw new Error("8 pictures at most per reel.");
       const name = safeAssetName(file, names.size);
-      mkdirSync3(dir, { recursive: true });
-      copyFileSync(file, join3(dir, name));
+      mkdirSync5(dir, { recursive: true });
+      copyFileSync2(file, join5(dir, name));
       names.set(file, `assets/${name}`);
     }
     return names.get(file);
@@ -22055,40 +22305,40 @@ function headTop(work, duration3) {
   return tops.length ? tops[Math.floor(tops.length / 2)] : void 0;
 }
 function ensureCutout(work, duration3) {
-  const footage = join3(work, "footage.mp4"), cut = join3(work, "cut.webm"), stamp = join3(work, "cut.json"), still = join3(work, "assets", "still.jpg");
+  const footage = join5(work, "footage.mp4"), cut = join5(work, "cut.webm"), stamp = join5(work, "cut.json"), still = join5(work, "assets", "still.jpg");
   const st = statSync(footage);
   const key = { size: st.size, mtime: Math.round(st.mtimeMs) };
   let cached2 = null;
   try {
-    cached2 = JSON.parse(readFileSync3(stamp, "utf8"));
+    cached2 = JSON.parse(readFileSync5(stamp, "utf8"));
   } catch {
   }
   let made_s = 0;
-  if (!(cached2 && cached2.size === key.size && cached2.mtime === key.mtime && existsSync2(cut))) {
+  if (!(cached2 && cached2.size === key.size && cached2.mtime === key.mtime && existsSync4(cut))) {
     const started = Date.now();
     const r = sh("npx", ["--yes", HF, "remove-background", "footage.mp4", "-o", "cut.webm", "--json"], work);
-    if (r.status !== 0 || !existsSync2(cut)) throw new Error(`Couldn't cut you out of the background. Run cutroom_doctor.
+    if (r.status !== 0 || !existsSync4(cut)) throw new Error(`Couldn't cut you out of the background. Run cutroom_doctor.
 ${tail(r.stderr) || tail(r.stdout)}`);
     made_s = Math.round((Date.now() - started) / 100) / 10;
     cached2 = { ...key, head: headTop(work, duration3), made_s };
-    writeFileSync2(stamp, JSON.stringify(cached2));
+    writeFileSync4(stamp, JSON.stringify(cached2));
   }
-  if (!existsSync2(still)) {
-    mkdirSync3(join3(work, "assets"), { recursive: true });
+  if (!existsSync4(still)) {
+    mkdirSync5(join5(work, "assets"), { recursive: true });
     sh("ffmpeg", ["-nostdin", "-v", "error", "-y", "-ss", (duration3 / 3).toFixed(2), "-i", "footage.mp4", "-frames:v", "1", "-q:v", "3", still], work);
   }
   return { head: cached2.head, made_s };
 }
-var planFile = (folder) => join3(folder, ".cutroom", "plan.json");
+var planFile = (folder) => join5(folder, ".cutroom", "plan.json");
 async function composition(input) {
   const pj = resolveProject(input.project);
-  const work = join3(pj.folder, ".cutroom");
+  const work = join5(pj.folder, ".cutroom");
   const words = applyFixes(pj.words, input.fixes);
   const local = localImages(work, input.images, input.effects ?? []);
   const cutout = await wantsCutout(input.layout, local.effects) ? ensureCutout(work, pj.duration) : null;
   const { html } = await call("compose", { duration: pj.duration, words, layout: input.layout, caption: input.caption, effects: local.effects, images: local.images, emphasis: input.emphasis, brand: getBrand() ?? void 0, ...cutout ? { cutout: true, head: cutout.head } : {} });
   await ensureFonts(work);
-  writeFileSync2(join3(work, "meta.json"), JSON.stringify({ id: pj.name, name: pj.name }));
+  writeFileSync4(join5(work, "meta.json"), JSON.stringify({ id: pj.name, name: pj.name }));
   return { pj, work, html, cutout, words };
 }
 var fmtT = (t) => `${t.toFixed(1)}s`;
@@ -22102,7 +22352,7 @@ async function planReel(input) {
     const at = f.slug === "frame-rip" ? d * 0.5 : Math.max(d * 0.5, d - (f.slug === "comment-dm" ? 0.32 : 0.55));
     return Math.min(pj.duration - 0.1, Number(f.start) + at);
   };
-  const plainAt = effects.length && Number(effects[0].start) > 2 ? 1.2 : null;
+  const plainAt = !effects.length ? Math.min(1.2, pj.duration / 2) : Number(effects[0].start) > 2 ? 1.2 : null;
   const styles = await call("styles");
   const title = (list, slug3) => (list.find((x) => x.slug === slug3)?.title ?? String(slug3)).replace(/\s*\(.*\)$/, "");
   const sentences = words.reduce((out, w, k) => {
@@ -22132,37 +22382,37 @@ async function planReel(input) {
   };
   const ends = effects.map((f, k) => Math.min(effects[k + 1] ? Number(effects[k + 1].start) : pj.duration, Number(f.start) + Math.min(Math.max(Number(f.dur) || 2.5, 1.2), 5)));
   const moments = [
-    ...plainAt !== null ? [{ t: 0, end: Number(effects[0].start), what: "just you and the captions", tag: "you + captions", at: plainAt }] : [],
+    ...plainAt !== null ? [{ t: 0, end: effects.length ? Number(effects[0].start) : pj.duration, what: "just you and the captions", tag: "you + captions", at: plainAt }] : [],
     ...effects.map((f, k) => {
       const name = title(styles.effects, f.slug);
       return { t: Number(f.start), end: ends[k], what: `${name}${fxLine(f) ? `: ${fxLine(f)}` : ""}`, tag: name, at: peak(f) };
     })
   ];
-  const shots = join3(work, "storyboard");
-  rmSync(shots, { recursive: true, force: true });
-  writeFileSync2(join3(work, "index.html"), html);
+  const shots = join5(work, "storyboard");
+  rmSync2(shots, { recursive: true, force: true });
+  writeFileSync4(join5(work, "index.html"), html);
   let r;
   try {
     r = sh("npx", ["--yes", HF, "snapshot", "--at", moments.map((m) => m.at.toFixed(2)).join(","), "--no-end", "--describe", "false", "-o", "storyboard", "."], work);
   } finally {
-    rmSync(join3(work, "index.html"), { force: true });
+    rmSync2(join5(work, "index.html"), { force: true });
   }
-  const pngs = existsSync2(shots) ? readdirSync(shots).filter((f) => f.endsWith(".png")).sort() : [];
+  const pngs = existsSync4(shots) ? readdirSync(shots).filter((f) => f.endsWith(".png")).sort() : [];
   if (r.status !== 0 || pngs.length < moments.length) throw new Error(`Couldn't make the storyboard. Run cutroom_doctor.
 ${tail(r.stderr) || tail(r.stdout)}`);
-  const board = join3(pj.folder, `${pj.name}-storyboard.jpg`);
+  const board = join5(pj.folder, "storyboard.jpg");
   const cols = Math.min(4, moments.length);
   const label = (s) => s.replace(/[\\':%,]/g, " ").slice(0, 42);
-  const inputs = pngs.slice(0, moments.length).flatMap((f) => ["-i", join3(shots, f)]);
+  const inputs = pngs.slice(0, moments.length).flatMap((f) => ["-i", join5(shots, f)]);
   const cells = moments.map((m, k) => `[${k}:v]scale=270:480,pad=270:540:0:0:#0A0A0A,drawtext=text='${label(`${fmtT(m.t)}  ${m.tag}`)}':x=10:y=496:fontsize=18:fontcolor=#F7F3E8[c${k}]`).join(";");
   const layoutXY = moments.map((_, k) => `${k % cols * 270}_${Math.floor(k / cols) * 540}`).join("|");
   const stack = moments.length === 1 ? `[c0]copy[out]` : `${moments.map((_, k) => `[c${k}]`).join("")}xstack=inputs=${moments.length}:layout=${layoutXY}:fill=#0A0A0A[out]`;
   const t = sh("ffmpeg", ["-nostdin", "-v", "error", "-y", ...inputs, "-filter_complex", `${cells};${stack}`, "-map", "[out]", "-frames:v", "1", "-q:v", "3", board]);
   if (t.status !== 0) throw new Error(`Couldn't tile the storyboard.
 ${tail(t.stderr)}`);
-  rmSync(shots, { recursive: true, force: true });
+  rmSync2(shots, { recursive: true, force: true });
   const plan = { layout: input.layout ?? "full-frame", caption: input.caption ?? "two-tier", effects, images: input.images, emphasis: input.emphasis, fixes: input.fixes };
-  writeFileSync2(planFile(pj.folder), JSON.stringify(plan, null, 2));
+  writeFileSync4(planFile(pj.folder), JSON.stringify(plan, null, 2));
   const text = [
     `Plan for ${pj.name} (${pj.duration.toFixed(1)}s). Layout: ${title(styles.layouts, plan.layout)}. Captions: ${title(styles.captions, plan.caption)}.${cutout ? " You are cut out of the background for this one (done)." : ""}`,
     "",
@@ -22172,38 +22422,41 @@ ${tail(t.stderr)}`);
     "",
     `Storyboard: ${board}`
   ].join("\n");
+  setStatus(pj.folder, "plan ready (waiting for your go)", text.replace(board, "storyboard.jpg"));
   return { text, storyboard: board, plan, words_used: words.length, next: "Show this table as it is (plain words, no effect codes) and the storyboard. On changes, plan_reel again with the new choice. On a go, render_reel with plan:true and draft:true." };
 }
 async function renderReel(input) {
   if (input.plan) {
     const folder = resolveProject(input.project).folder;
-    if (!existsSync2(planFile(folder))) throw new Error("No plan yet for this project. Make one with plan_reel first.");
-    input = { ...JSON.parse(readFileSync3(planFile(folder), "utf8")), project: input.project, draft: input.draft };
+    if (!existsSync4(planFile(folder))) throw new Error("No plan yet for this project. Make one with plan_reel first.");
+    input = { ...JSON.parse(readFileSync5(planFile(folder), "utf8")), project: input.project, draft: input.draft };
   }
   const { pj, work, html, cutout } = await composition(input);
-  const out = join3(pj.folder, `${pj.name}${input.draft ? "-draft" : ""}.mp4`);
-  const tmp = join3(work, "render.mp4");
-  writeFileSync2(join3(work, "index.html"), html);
+  mkdirSync5(join5(pj.folder, "renders"), { recursive: true });
+  const out = join5(pj.folder, "renders", `${pj.name}${input.draft ? "-draft" : ""}.mp4`);
+  const tmp = join5(work, "render.mp4");
+  writeFileSync4(join5(work, "index.html"), html);
   const started = Date.now();
   let r;
   try {
     r = sh("npx", ["--yes", HF, "render", "-q", input.draft ? "draft" : "delivery", "-o", "render.mp4", "."], work);
   } finally {
-    rmSync(join3(work, "index.html"), { force: true });
+    rmSync2(join5(work, "index.html"), { force: true });
   }
-  if (r.status !== 0 || !existsSync2(tmp)) throw new Error(`Render failed. Run cutroom_doctor.
+  if (r.status !== 0 || !existsSync4(tmp)) throw new Error(`Render failed. Run cutroom_doctor.
 ${tail(r.stderr) || tail(r.stdout)}`);
-  renameSync(tmp, out);
+  renameSync2(tmp, out);
   const render_s = Math.round((Date.now() - started) / 100) / 10;
-  const qa = await qaVideo({ video: out, write_report: true, layout: input.layout });
+  const { report: checks, ...qa } = await qaVideo({ video: out, layout: input.layout });
+  addCheck(pj.folder, checks);
+  setStatus(pj.folder, input.draft ? "preview" : "final");
   return { video: out, render_s, ...cutout?.made_s ? { cutout_s: cutout.made_s } : {}, qa, next: qa.passed ? "Watch it once, then it's ready to post." : qa.technical?.length ? "Fix the technical issues listed, then render again." : "Look at each flagged spot yourself (grab the frame) and tell the user which are real problems, with the fix, and which are the design." };
 }
 async function qaVideo(input) {
-  const file = resolve2(input.video.replace(/^~/, homedir2()));
-  if (!existsSync2(file)) throw new Error(`No such file: ${file}`);
+  const file = resolve3(input.video.replace(/^~/, homedir2()));
+  if (!existsSync4(file)) throw new Error(`No such file: ${file}`);
   const tech = technicalChecks(file);
-  const dir = join3(file, "..", ".cutroom", "qa-frames");
-  rmSync(dir, { recursive: true, force: true });
+  const dir = mkdtempSync(join5(tmpdir(), "cutroom-qa-"));
   const { frames } = sampleFrames(file, dir, tech.duration, Math.max(1, Math.round(tech.duration / 20 * 10) / 10), 20);
   let flags = [];
   let judged = 0, judge_error = null;
@@ -22214,7 +22467,7 @@ async function qaVideo(input) {
   } catch (e) {
     judge_error = e.message;
   }
-  rmSync(dir, { recursive: true, force: true });
+  rmSync2(dir, { recursive: true, force: true });
   const look = flags.map((f) => `${f.t.toFixed(1)}s: ${f.text} (${Math.round(f.p_yes * 100)}%)`);
   const passed = !tech.issues.length && !flags.length && !judge_error;
   const report = {
@@ -22225,31 +22478,28 @@ async function qaVideo(input) {
     judge_error,
     measured: { duration: Math.round(tech.duration * 10) / 10, size: `${tech.width}x${tech.height}`, lufs: tech.lufs }
   };
-  if (input.write_report) {
-    writeFileSync2(file.replace(/\.mp4$/i, ".qa.md"), [
-      `# QA: ${basename(file)}`,
-      "",
-      passed ? "Passed." : "Needs a look.",
-      "",
-      "## Technical",
-      ...tech.issues.length ? tech.issues.map((i) => `- ${i}`) : ["- clean"],
-      "",
-      `## Frames (${judged} judged)`,
-      ...judge_error ? [`- not judged: ${judge_error}`] : look.length ? look.map((l) => `- ${l}`) : ["- nothing flagged"],
-      ""
-    ].join("\n"));
-  }
-  return report;
+  const md = [
+    `## ${basename2(file)}, ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ")}`,
+    "",
+    passed ? "Passed." : "Needs a look.",
+    "",
+    "Technical:",
+    ...tech.issues.length ? tech.issues.map((i) => `- ${i}`) : ["- clean"],
+    "",
+    `Frames (${judged} judged):`,
+    ...judge_error ? [`- not judged: ${judge_error}`] : look.length ? look.map((l) => `- ${l}`) : ["- nothing flagged"]
+  ].join("\n");
+  return { ...report, report: md };
 }
 
 // src/community/local/server.ts
-process.env.PATH = (WIN ? [process.env.PATH, join4(process.env.LOCALAPPDATA ?? join4(homedir3(), "AppData", "Local"), "Microsoft", "WinGet", "Links"), "C:\\Program Files\\nodejs"] : [process.env.PATH, "/opt/homebrew/bin", "/usr/local/bin", join4(homedir3(), ".local", "bin")]).filter(Boolean).join(delimiter);
+process.env.PATH = (WIN ? [process.env.PATH, join6(process.env.LOCALAPPDATA ?? join6(homedir3(), "AppData", "Local"), "Microsoft", "WinGet", "Links"), "C:\\Program Files\\nodejs"] : [process.env.PATH, "/opt/homebrew/bin", "/usr/local/bin", join6(homedir3(), ".local", "bin")]).filter(Boolean).join(delimiter);
 var result = (value) => ({ content: [{ type: "text", text: typeof value === "string" ? value : JSON.stringify(value, null, 2) }] });
 var failure2 = (error2) => ({ isError: true, content: [{ type: "text", text: error2 instanceof Error ? error2.message : String(error2) }] });
 var safe = (op) => Promise.resolve().then(op).then(result).catch(failure2);
 var INSTRUCTIONS = `Cutroom: short-form video help. Speak plainly; the user is not technical. Never show tool or effect codes; use plain names.
 
-Setup or any failure: cutroom_doctor, then a short checklist. Missing ffmpeg or Node.js: ask, then run the fix line cutroom_doctor gives (brew on a Mac, winget on Windows). Key problem: reconnect Cutroom with their key from the Cutroom key space on Whop; never ask them to paste the key into the chat.
+Setup or any failure: cutroom_doctor, then a short checklist. If they aren't signed in it opens "Sign in with Whop" in their browser and waits: before calling it, tell them a Whop sign-in page will open and to sign in with the Whop account they joined with. Never ask for a key; signing in is the only way in. Wrong account or a membership problem: cutroom_sign_in to sign in again. Missing ffmpeg, whisper or Node.js: ask, then run the fix cutroom_doctor gives, and tell them to restart the Claude app afterwards so it sees the new tools.
 
 Finish a video (a raw video of them talking: edit it, captions, effects, make it a reel): get_method('finish_video') first and follow it step by step. Nothing renders until they approve the plan.
 
@@ -22261,13 +22511,17 @@ Before a first render: show_brand; if none, offer set_brand (from colors, a webs
 
 QA flags are spots to check: look at each flagged frame yourself and say which are real problems (with the fix) and which are the design.
 
-Results are saved in ~/Cutroom. Other creators' reels are for study only: never reuse their words, footage or branding.`;
+Their studio is the Cutroom folder in their home folder (cutroom_doctor returns the path): inbox/ for new raw videos (look there first when they say "my video" without a path), videos/<date>-<topic>/ with everything for one video (raw/, references/, script.md, facts.md, plan.md with its status line, renders/, checks.md), brand/, references/ as the library for breakdowns and teardowns, and CLAUDE.md with their rules. When they give a reference for one video (an image, a link, a reel to match), save it in that video's references/ and add a line to its references/notes.md saying what it is and why it works; pictures for plan_reel and render_reel can come from there. breakdown_reel and creator_teardown still go to the top-level references/ library. Put every number shown on screen in that video's facts.md with its source; when QA finds a real mistake, offer to add a rule to their CLAUDE.md. To list videos or what's unfinished, read the status lines in videos/*/plan.md. Other creators' reels are for study only: never reuse their words, footage or branding.`;
 await serveStdio(() => {
   const server = new McpServer({ name: "cutroom", version: VERSION }, { instructions: INSTRUCTIONS });
   server.registerTool("cutroom_doctor", {
-    description: "Check Cutroom is ready: ffmpeg on this computer and an active membership key. Returns each check with the exact fix. Run it first, and whenever a tool fails.",
+    description: "Check Cutroom is ready: makes their studio folders, checks ffmpeg, whisper and Node.js on this computer, and the membership. If they aren't signed in, opens Sign in with Whop in their browser and waits up to 5 minutes. Returns each check with the exact fix. Run it first, and whenever a tool fails.",
     inputSchema: object({})
   }, async () => safe(() => doctor()));
+  server.registerTool("cutroom_sign_in", {
+    description: "Sign in to Cutroom again with Whop (another Whop account, or a membership that was renewed). Opens the Whop sign-in in their browser and waits up to 5 minutes, then runs the setup check.",
+    inputSchema: object({})
+  }, async () => safe(() => doctor({ fresh: true })));
   server.registerTool("list_methods", {
     description: "List the Cutroom writing methods available to members (hooks, short script, caption and CTA, and how to write up breakdowns and teardowns).",
     inputSchema: object({})
@@ -22290,11 +22544,11 @@ ${m.text}`;
     inputSchema: object({ script: string2().min(1), audience: string2().optional() })
   }, async ({ script, audience }) => safe(() => call("score", { kind: "script", texts: [script], audience })));
   server.registerTool("breakdown_reel", {
-    description: "Break down one reel (Instagram link, or a video file on this computer) into a blueprint: hook, pacing, cuts, the look (layouts, caption styles, effects with timestamps) and beats. Saves breakdown.md in ~/Cutroom/breakdowns. Then use get_method('breakdown_writeup'). Study only: never reuse the creator's words, footage or assets.",
+    description: "Break down one reel (Instagram link, or a video file on this computer) into a blueprint: hook, pacing, cuts, the look (layouts, caption styles, effects with timestamps) and beats. Saves breakdown.md in a folder in their studio's references/. Then use get_method('breakdown_writeup'). Study only: never reuse the creator's words, footage or assets.",
     inputSchema: object({ source: string2().min(1).describe("Instagram reel link or a local video file path.") })
   }, async (input) => safe(() => breakdownReel(input)));
   server.registerTool("creator_teardown", {
-    description: "Tear down an Instagram creator's latest reels (profile Reels tab; trial reels are not included): their layouts, captions, effects, pacing, hooks and CTA keywords, what their top quarter by plays does differently, and with compare_to (the user's own handle) the gap. Takes a few minutes. Saves teardown.md in ~/Cutroom/teardowns. Then use get_method('teardown_writeup').",
+    description: "Tear down an Instagram creator's latest reels (profile Reels tab; trial reels are not included): their layouts, captions, effects, pacing, hooks and CTA keywords, what their top quarter by plays does differently, and with compare_to (the user's own handle) the gap. Takes a few minutes. Saves teardown.md in a folder in their studio's references/. Then use get_method('teardown_writeup').",
     inputSchema: object({ handle: string2().min(1), limit: number2().int().min(1).max(30).default(12), compare_to: string2().optional() })
   }, async (input) => safe(() => creatorTeardown(input)));
   server.registerTool("list_styles", {
@@ -22318,16 +22572,16 @@ ${m.text}`;
     inputSchema: object({})
   }, async () => safe(() => getBrand() ?? "No brand kit set: renders use the default look. Set one with set_brand."));
   server.registerTool("prepare_footage", {
-    description: "Step 1 of finishing a talking-head video on this computer: cuts long pauses, fits it to 1080x1920, and transcribes it with word timings. Returns the project folder and the timed transcript to plan captions and effects from. Takes about a minute.",
+    description: "Step 1 of finishing a talking-head video on this computer: makes the video's folder (videos/<date>-<name>/ in their studio) and puts the clip in its raw/ (moved from inbox/, copied from anywhere else), cuts long pauses, fits it to 1080x1920, and transcribes it with word timings (also saved as script.md). Returns the project folder and the timed transcript to plan captions and effects from. Takes about a minute.",
     inputSchema: object({
-      video: string2().min(1).describe("Path to the raw video file on this computer."),
+      video: string2().min(1).describe("Path to the raw video file on this computer (often in their studio's inbox/)."),
       name: string2().optional().describe("Short name for the output, e.g. 'trial-loop'."),
       cut_pauses: boolean2().default(true).describe("Cut pauses longer than about half a second."),
       language: string2().optional().describe("Spoken language code if not English, e.g. ko, es, ja (uses a larger model, downloaded once).")
     })
   }, async (input) => safe(() => prepareFootage(input)));
   server.registerTool("plan_reel", {
-    description: "Step 2: the plan before anything renders. Takes the same choice as render_reel (layout, caption, effects with times, images) and returns the plan as lines plus a storyboard image: one real frame of the user's video per moment, with the effect on it, in their brand. About 10 to 20 seconds (plus the one-time cut-out if the choice needs it). Saves the plan so render_reel with plan:true renders exactly this. Show the storyboard and get a go before rendering.",
+    description: "Step 2: the plan before anything renders. Takes the same choice as render_reel (layout, caption, effects with times, images) and returns the plan as lines plus a storyboard image: one real frame of the user's video per moment, with the effect on it, in their brand. About 10 to 20 seconds (plus the one-time cut-out if the choice needs it). Saves the plan (plan.md in the video's folder, status plan ready) so render_reel with plan:true renders exactly this. Show the storyboard and get a go before rendering.",
     inputSchema: object({
       project: string2().min(1).describe("The project folder returned by prepare_footage."),
       layout: string2().default("full-frame"),
@@ -22342,13 +22596,13 @@ ${m.text}`;
       const r = await planReel(input);
       return { content: [{ type: "text", text: `${r.text}
 
-${r.next}` }, { type: "image", data: readFileSync4(r.storyboard).toString("base64"), mimeType: "image/jpeg" }] };
+${r.next}` }, { type: "image", data: readFileSync6(r.storyboard).toString("base64"), mimeType: "image/jpeg" }] };
     } catch (e) {
       return failure2(e);
     }
   });
   server.registerTool("render_reel", {
-    description: "Step 3: render the prepared footage in a Cutroom layout with a caption style and effects, on this computer, then QA it (technical checks plus every sampled frame judged). Saves <name>.mp4 and <name>.qa.md in the project folder. Use draft:true for a fast preview. Effect times are seconds in the prepared (trimmed) video. Layouts and effects that cut the speaker out of the background (see needs in list_styles) run a one-time cut-out first: about 5 to 6 seconds per second of footage, reused for later renders of the same project.",
+    description: "Step 3: render the prepared footage in a Cutroom layout with a caption style and effects, on this computer, then QA it (technical checks plus every sampled frame judged). Saves the video in the project's renders/ folder and the QA result in its checks.md, and sets plan.md's status to preview (draft) or final. Use draft:true for a fast preview. Effect times are seconds in the prepared (trimmed) video. Layouts and effects that cut the speaker out of the background (see needs in list_styles) run a one-time cut-out first: about 5 to 6 seconds per second of footage, reused for later renders of the same project.",
     inputSchema: object({
       project: string2().min(1).describe("The project folder returned by prepare_footage."),
       layout: string2().default("full-frame"),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@keepylabs/cutroom",
-  "version": "0.5.7",
-  "description": "Cutroom for Claude Code: hooks and scripts with scoring, reel breakdowns, creator teardowns, and finishing your own videos with QA. Needs a Keepy Labs membership key.",
+  "version": "0.7.1",
+  "description": "Cutroom for Claude Code: hooks and scripts with scoring, reel breakdowns, creator teardowns, and finishing your own videos with QA. Sign in with your Keepy Labs membership on Whop.",
   "type": "module",
   "bin": {
     "cutroom": "cutroom.mjs"
@@ -11,7 +11,7 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "license": "UNLICENSED",
   "homepage": "https://keepylabs.com",