@vocoder/cli 0.14.1 → 0.16.0

package/dist/bin.mjs

@@ -6,22 +6,22 @@ import {
   VocoderAPIError,
   buildInstallCommand,
   clearAuthData,
+  computeFingerprint,
   detectLocalEcosystem,
   getPackagesToInstall,
-  getSetupSnippets,
   loadVocoderConfig,
   readAuthData,
   verifyStoredAuth,
   writeAuthData
-} from "./chunk-LLEMSC3X.mjs";
+} from "./chunk-IK4ZCESQ.mjs";
 
 // src/bin.ts
 import { Command } from "commander";
 
 // src/commands/init.ts
-import * as p5 from "@clack/prompts";
+import * as p6 from "@clack/prompts";
 import { execSync as execSync3, spawn as spawn2 } from "child_process";
-import { existsSync as existsSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync, writeFileSync as writeFileSync2 } from "fs";
 
 // src/utils/write-config.ts
 import { existsSync, writeFileSync } from "fs";
@@ -41,18 +41,21 @@ function writeVocoderConfig(options) {
   const {
     targetBranches = ["main"],
     useTypeScript = true,
-    cwd = process.cwd()
+    cwd = process.cwd(),
+    appId
   } = options;
   if (findExistingConfig(cwd)) return null;
   const ext = useTypeScript ? "ts" : "js";
   const configPath = join(cwd, `vocoder.config.${ext}`);
   const branchesStr = targetBranches.map((b) => `'${b}'`).join(", ");
   const includes = ["**/*.{tsx,jsx,ts,js}"];
-  const includesStr = includes.map((p14) => `'${p14}'`).join(", ");
+  const includesStr = includes.map((p15) => `'${p15}'`).join(", ");
+  const appIdLine = appId ? `  appId: '${appId}',
+` : "";
   const content = `import { defineConfig } from '@vocoder/config'
 
 export default defineConfig({
-  targetBranches: [${branchesStr}],
+${appIdLine}  targetBranches: [${branchesStr}],
   include: [${includesStr}],
 })
 `;
@@ -80,13 +83,18 @@ var highlight = hex(PINK);
 var info = hex(BLUE);
 var active = hex(ORANGE);
 
+// src/commands/init.ts
+import { join as join2, resolve as resolve2 } from "path";
+
 // src/utils/project-create.ts
-import * as p2 from "@clack/prompts";
+import * as p3 from "@clack/prompts";
 import chalk2 from "chalk";
 
-// src/utils/branch-select.ts
-import { execSync } from "child_process";
+// src/utils/app-dir-select.ts
+import { existsSync as existsSync2, statSync } from "fs";
+import { resolve } from "path";
 import { isCancel, Prompt } from "@clack/core";
+import * as p from "@clack/prompts";
 var S_BAR = "\u2502";
 var S_BAR_END = "\u2514";
 var S_ACTIVE = "\u25C6";
@@ -105,6 +113,195 @@ function symbol(state) {
       return active(S_ACTIVE);
   }
 }
+function validateAppDirPath(val, existing, opts = {}) {
+  if (val.startsWith("/")) return "Must be a relative path (e.g. apps/web)";
+  if (val.includes("..")) return "Path traversal not allowed";
+  const hasWholeRepo = existing.includes("");
+  const hasScoped = existing.some((d) => d !== "");
+  if (val === "" && hasScoped) return "Cannot add whole-repo scope to a monorepo project";
+  if (val !== "" && hasWholeRepo) return "Cannot add a scoped directory to a whole-repo project";
+  if (existing.includes(val)) return `Already added: ${val}`;
+  const nested = existing.find(
+    (d) => d !== "" && (val.startsWith(d + "/") || d.startsWith(val + "/"))
+  );
+  if (nested) return `"${val}" overlaps with already-added "${nested}"`;
+  if (val !== "") {
+    const abs = resolve(opts.cwd ?? process.cwd(), val);
+    if (!existsSync2(abs)) return `Directory not found: ${val}`;
+    if (!statSync(abs).isDirectory()) return `Not a directory: ${val}`;
+  }
+  return null;
+}
+async function collectAppDirs(opts = {}) {
+  const added = [];
+  let filter = "";
+  let cursor = 0;
+  let addCursor = false;
+  const isNewDir = () => {
+    const t = filter.trim();
+    return t.length > 0 && !added.includes(t);
+  };
+  const clampCursor = () => {
+    const max = added.length - 1;
+    if (cursor > max) cursor = Math.max(0, max);
+  };
+  const prompt = new Prompt(
+    {
+      validate() {
+        return void 0;
+      },
+      render() {
+        const trimmed = filter.trim();
+        const hdr = `${dim(S_BAR)}
+${symbol(this.state)}  App directories
+`;
+        switch (this.state) {
+          case "submit": {
+            const summary = added.length > 0 ? bld(added.join(", ")) : dim("none (single-app project)");
+            return `${hdr}${dim(S_BAR)}  ${summary}`;
+          }
+          case "cancel":
+            return `${hdr}${dim(S_BAR)}`;
+          default: {
+            const inputHint = filter.length > 0 ? filter : added.length === 0 ? dim("e.g. apps/web") : dim("e.g. apps/api");
+            const lines = [
+              hdr.trimEnd(),
+              `${info(S_BAR)}  ${dim("/")} ${inputHint}`,
+              info(S_BAR)
+            ];
+            for (let i = 0; i < added.length; i++) {
+              const isCursor = i === cursor && !addCursor;
+              const icon = active("\u25FC");
+              const label = isCursor ? bld(added[i]) : added[i];
+              lines.push(`${info(S_BAR)}  ${icon}  ${label}`);
+            }
+            const atLimit = opts.maxDirs !== void 0 && added.length >= opts.maxDirs;
+            if (atLimit) {
+              lines.push(`${info(S_BAR)}  ${dim(`App limit reached (${added.length}/${opts.maxDirs} on your plan)`)}`);
+            } else if (isNewDir()) {
+              const err = validateAppDirPath(trimmed, added, opts);
+              const icon = addCursor ? active("\u25FB") : dim("\u25FB");
+              const label = err ? `${ylw("+")}  ${dim(`"${trimmed}" \u2014 ${err}`)}` : `${grn("+")}  Add "${trimmed}"`;
+              lines.push(`${info(S_BAR)}  ${icon}  ${label}`);
+            }
+            lines.push(info(S_BAR));
+            if (atLimit) {
+              lines.push(dim(`${S_BAR}  \u2191\u2193 to select, Space to remove  \xB7  Enter to confirm`));
+            } else if (added.length === 0 && !isNewDir()) {
+              lines.push(dim(`${S_BAR}  Monorepo? Type each app's subdirectory path and press Space.`));
+              lines.push(dim(`${S_BAR}  Single app? Press Enter to skip this step.`));
+            } else if (added.length > 0) {
+              lines.push(dim(`${S_BAR}  ${added.length} added  \xB7  \u2191\u2193 to select, Space to remove  \xB7  Enter to confirm`));
+            }
+            const barEnd = this.state === "error" ? ylw(S_BAR_END) : info(S_BAR_END);
+            if (this.state === "error") {
+              lines.push(`${ylw(S_BAR_END)}  ${ylw(this.error)}`);
+            } else {
+              lines.push(barEnd);
+            }
+            lines.push("");
+            return lines.join("\n");
+          }
+        }
+      }
+    },
+    false
+  );
+  prompt.on("key", (key) => {
+    if (!key || key === " ") return;
+    const cp = key.codePointAt(0) ?? 0;
+    if (cp === 127 || cp === 8) {
+      filter = filter.slice(0, -1);
+      addCursor = false;
+    } else if (cp >= 32 && cp !== 127) {
+      filter += key;
+      cursor = 0;
+      addCursor = false;
+    }
+  });
+  prompt.on("cursor", (action) => {
+    switch (action) {
+      case "up":
+        if (addCursor) {
+          addCursor = false;
+          cursor = Math.max(0, added.length - 1);
+        } else {
+          cursor = Math.max(0, cursor - 1);
+        }
+        break;
+      case "down":
+        if (!addCursor && cursor >= added.length - 1 && isNewDir()) {
+          addCursor = true;
+        } else if (!addCursor) {
+          cursor = Math.min(added.length - 1, cursor + 1);
+        }
+        break;
+      case "space": {
+        if (addCursor || filter.trim().length > 0 && isNewDir()) {
+          if (opts.maxDirs !== void 0 && added.length >= opts.maxDirs) break;
+          const trimmed = filter.trim();
+          const err = validateAppDirPath(trimmed, added, opts);
+          if (!err) {
+            added.push(trimmed);
+            filter = "";
+            addCursor = false;
+            cursor = 0;
+          }
+        } else if (added.length > 0 && !isNewDir()) {
+          clampCursor();
+          added.splice(cursor, 1);
+          if (cursor >= added.length) cursor = Math.max(0, added.length - 1);
+        }
+        break;
+      }
+    }
+  });
+  prompt.on("finalize", () => {
+    if (prompt.state === "submit") {
+      prompt.value = [...added];
+    }
+  });
+  const result = await prompt.prompt();
+  if (isCancel(result)) return null;
+  return result;
+}
+async function promptSingleAppDir(params) {
+  const { existingDirs, cwd } = params;
+  const input = await p.text({
+    message: "App directory to add",
+    placeholder: "apps/web",
+    validate(val) {
+      const err = validateAppDirPath(val ?? "", existingDirs, { cwd });
+      if (err) return err;
+      if (!val) return "Directory is required";
+      return void 0;
+    }
+  });
+  if (p.isCancel(input)) return null;
+  return input;
+}
+
+// src/utils/branch-select.ts
+import { execSync } from "child_process";
+import { isCancel as isCancel3, Prompt as Prompt2 } from "@clack/core";
+var S_BAR2 = "\u2502";
+var S_BAR_END2 = "\u2514";
+var S_ACTIVE2 = "\u25C6";
+var S_SUBMIT2 = "\u25C6";
+var S_CANCEL2 = "\u25A0";
+var S_ERROR2 = "\u25B2";
+function symbol2(state) {
+  switch (state) {
+    case "submit":
+      return grn(S_SUBMIT2);
+    case "cancel":
+      return red(S_CANCEL2);
+    case "error":
+      return ylw(S_ERROR2);
+    default:
+      return active(S_ACTIVE2);
+  }
+}
 function detectGitBranches(cwd) {
   const workDir = cwd ?? process.cwd();
   try {
@@ -168,36 +365,30 @@ function filterItems(items, query) {
   const lower = query.toLowerCase();
   return items.filter((i) => i.value.toLowerCase().includes(lower));
 }
-function buildList(filtered, cursor, scrollOffset, selected, filter, customPatterns, addCursor, optional = false, excludedPatterns = /* @__PURE__ */ new Set()) {
-  const lines = [];
+function buildList(filtered, cursor, scrollOffset, selected, filter, customPatterns, addCursor, excludedPatterns = /* @__PURE__ */ new Set()) {
+  const lines = [info(S_BAR2)];
   const end = Math.min(filtered.length, scrollOffset + MAX_VISIBLE);
   for (let i = scrollOffset; i < end; i++) {
     const item = filtered[i];
     const isCursor = i === cursor && !addCursor;
     const isChecked = selected.has(item.value);
-    const icon = isChecked ? isCursor ? info("\u25FC") : info("\u25FC") : isCursor ? active("\u25FB") : dim("\u25FB");
+    const icon = isChecked ? active("\u25FC") : isCursor ? active("\u25FB") : dim("\u25FB");
     let label = item.isCustom ? `${item.label} ${dim("(custom)")}` : item.label;
     if (isCursor) label = bld(label);
-    lines.push(`${info(S_BAR)}  ${icon}  ${label}`);
+    lines.push(`${info(S_BAR2)}  ${icon}  ${label}`);
   }
   const trimmed = filter.trim();
-  const allItems = [...filtered];
-  const isNewPattern = trimmed.length > 0 && !allItems.some((i) => i.value === trimmed) && !customPatterns.includes(trimmed);
+  const isNewPattern = trimmed.length > 0 && !filtered.some((i) => i.value === trimmed) && !customPatterns.includes(trimmed);
   if (isNewPattern) {
     const err = validateBranchPattern(trimmed) ?? (excludedPatterns.has(trimmed) ? "Already used for automatic translation" : null);
     const icon = addCursor ? active("\u25FB") : dim("\u25FB");
     const label = err ? `${ylw("+")}  ${dim(`"${trimmed}" \u2014 ${err}`)}` : `${grn("+")}  Add "${trimmed}" as branch pattern`;
-    lines.push(`${info(S_BAR)}  ${icon}  ${label}`);
+    lines.push(`${info(S_BAR2)}  ${icon}  ${label}`);
   } else if (filtered.length === 0 && trimmed.length === 0) {
-    lines.push(dim(`${S_BAR}  No branches detected`));
+    lines.push(dim(`${S_BAR2}  No branches detected`));
   }
   const hidden = filtered.length - (end - scrollOffset);
-  if (hidden > 0) lines.push(dim(`${S_BAR}  ${hidden} more`));
-  if (selected.size > 0) {
-    lines.push(dim(`${S_BAR}  ${selected.size} selected \u2014 Enter to confirm`));
-  } else if (optional) {
-    lines.push(dim(`${S_BAR}  Enter to skip`));
-  }
+  if (hidden > 0) lines.push(dim(`${S_BAR2}  ${hidden} more \u2014 keep typing to narrow`));
   return lines.join("\n");
 }
 async function filterableBranchSelect(params) {
@@ -228,7 +419,7 @@ async function filterableBranchSelect(params) {
       if (scrollOffset < 0) scrollOffset = 0;
     }
   };
-  const prompt = new Prompt(
+  const prompt = new Prompt2(
     {
       validate() {
         if (!optional && selected.size === 0)
@@ -238,51 +429,43 @@ async function filterableBranchSelect(params) {
       render() {
         const filtered = getFiltered();
         clampCursor(filtered);
-        const hdr = `${dim(S_BAR)}
-${symbol(this.state)}  ${message}
+        const hdr = `${dim(S_BAR2)}
+${symbol2(this.state)}  ${message}
 `;
-        const hint = filter.length > 0 ? filter : dim("type to filter or add pattern, \u2191\u2193 navigate, space select");
+        const inputHint = filter.length > 0 ? filter : dim("type to filter  \xB7  type a custom pattern to add it");
+        const trimmedFilter = filter.trim();
+        const footer = (() => {
+          if (trimmedFilter.length > 0 && isNewPattern()) {
+            return dim(`${S_BAR2}  Space to add "${trimmedFilter}"  \xB7  \u2191\u2193 navigate  \xB7  Enter to confirm`);
+          }
+          if (selected.size > 0) {
+            return dim(`${S_BAR2}  ${selected.size} selected  \xB7  \u2191\u2193 navigate  \xB7  Space to select  \xB7  Enter to confirm`);
+          }
+          return optional ? dim(`${S_BAR2}  \u2191\u2193 navigate  \xB7  Space to select  \xB7  Enter to skip`) : dim(`${S_BAR2}  \u2191\u2193 navigate  \xB7  Space to select  \xB7  Enter to confirm`);
+        })();
         switch (this.state) {
           case "submit": {
             const summary = selected.size > 0 ? bld(Array.from(selected).join(", ")) : dim("none");
-            return `${hdr}${dim(S_BAR)}  ${summary}`;
+            return `${hdr}${dim(S_BAR2)}  ${summary}`;
           }
           case "cancel":
-            return `${hdr}${dim(S_BAR)}`;
+            return `${hdr}${dim(S_BAR2)}`;
           case "error":
             return [
               hdr.trimEnd(),
-              `${ylw(S_BAR)}  ${dim("/")} ${hint}`,
-              buildList(
-                filtered,
-                cursor,
-                scrollOffset,
-                selected,
-                filter,
-                customPatterns,
-                addCursor,
-                optional,
-                excludedSet
-              ),
-              `${ylw(S_BAR_END)}  ${ylw(this.error)}`,
+              `${ylw(S_BAR2)}  ${dim("/")} ${inputHint}`,
+              buildList(filtered, cursor, scrollOffset, selected, filter, customPatterns, addCursor, excludedSet),
+              footer,
+              `${ylw(S_BAR_END2)}  ${ylw(this.error)}`,
               ""
             ].join("\n");
           default:
             return [
               hdr.trimEnd(),
-              `${info(S_BAR)}  ${dim("/")} ${hint}`,
-              buildList(
-                filtered,
-                cursor,
-                scrollOffset,
-                selected,
-                filter,
-                customPatterns,
-                addCursor,
-                optional,
-                excludedSet
-              ),
-              `${info(S_BAR_END)}`,
+              `${info(S_BAR2)}  ${dim("/")} ${inputHint}`,
+              buildList(filtered, cursor, scrollOffset, selected, filter, customPatterns, addCursor, excludedSet),
+              footer,
+              `${info(S_BAR_END2)}`,
               ""
             ].join("\n");
         }
@@ -304,6 +487,9 @@ ${symbol(this.state)}  ${message}
       scrollOffset = 0;
       addCursor = false;
     }
+    if (isNewPattern()) {
+      addCursor = true;
+    }
   });
   prompt.on("cursor", (action) => {
     const filtered = getFiltered();
@@ -320,9 +506,9 @@ ${symbol(this.state)}  ${message}
           addCursor = true;
         else if (!addCursor) cursor = Math.min(filtered.length - 1, cursor + 1);
         break;
-      case "space":
-        if (addCursor) {
-          const t = filter.trim();
+      case "space": {
+        const t = filter.trim();
+        if (addCursor || t.length > 0 && isNewPattern()) {
           const err = validateBranchPattern(t) ?? (excludedSet.has(t) ? "Already used for automatic translation" : null);
           if (!err) {
             customPatterns.push(t);
@@ -340,6 +526,7 @@ ${symbol(this.state)}  ${message}
           }
         }
         break;
+      }
     }
   });
   prompt.on("finalize", () => {
@@ -348,29 +535,29 @@ ${symbol(this.state)}  ${message}
     }
   });
   const result = await prompt.prompt();
-  if (isCancel(result)) return null;
+  if (isCancel3(result)) return null;
   return result;
 }
 
 // src/utils/locale-search.ts
-import { isCancel as isCancel2, Prompt as Prompt2 } from "@clack/core";
-import * as p from "@clack/prompts";
-var S_BAR2 = "\u2502";
-var S_BAR_END2 = "\u2514";
-var S_ACTIVE2 = "\u25C6";
-var S_SUBMIT2 = "\u25C6";
-var S_CANCEL2 = "\u25A0";
-var S_ERROR2 = "\u25B2";
-function symbol2(state) {
+import { isCancel as isCancel4, Prompt as Prompt3 } from "@clack/core";
+import * as p2 from "@clack/prompts";
+var S_BAR3 = "\u2502";
+var S_BAR_END3 = "\u2514";
+var S_ACTIVE3 = "\u25C6";
+var S_SUBMIT3 = "\u25C6";
+var S_CANCEL3 = "\u25A0";
+var S_ERROR3 = "\u25B2";
+function symbol3(state) {
   switch (state) {
     case "submit":
-      return grn(S_SUBMIT2);
+      return grn(S_SUBMIT3);
     case "cancel":
-      return red(S_CANCEL2);
+      return red(S_CANCEL3);
     case "error":
-      return ylw(S_ERROR2);
+      return ylw(S_ERROR3);
     default:
-      return active(S_ACTIVE2);
+      return active(S_ACTIVE3);
   }
 }
 var MAX_VISIBLE2 = 12;
@@ -384,25 +571,19 @@ function filterLocales(options, query) {
 function buildList2(filtered, cursor, scrollOffset, selected) {
   const isMulti = selected !== null;
   const end = Math.min(filtered.length, scrollOffset + MAX_VISIBLE2);
-  const visibleLines = [];
+  const visibleLines = [info(S_BAR3)];
   for (let i = scrollOffset; i < end; i++) {
     const opt = filtered[i];
     const isCursor = i === cursor;
     const isChecked = isMulti && selected.has(opt.bcp47);
-    const icon = isMulti ? isChecked ? isCursor ? info("\u25FC") : info("\u25FC") : isCursor ? active("\u25FB") : dim("\u25FB") : isCursor ? active("\u25CF") : dim("\u25CB");
+    const icon = isMulti ? isChecked ? active("\u25FC") : isCursor ? active("\u25FB") : dim("\u25FB") : isCursor ? active("\u25CF") : dim("\u25CB");
     visibleLines.push(
-      `${info(S_BAR2)}  ${icon}  ${isCursor ? bld(opt.label) : opt.label}`
+      `${info(S_BAR3)}  ${icon}  ${isCursor ? bld(opt.label) : opt.label}`
     );
   }
   const hidden = filtered.length - (end - scrollOffset);
-  if (hidden > 0)
-    visibleLines.push(dim(`${S_BAR2}  ${hidden} more \u2014 keep typing to narrow`));
-  if (filtered.length === 0) visibleLines.push(dim(`${S_BAR2}  No matches`));
-  if (isMulti && selected.size > 0) {
-    visibleLines.push(
-      dim(`${S_BAR2}  ${selected.size} selected \u2014 Enter to confirm`)
-    );
-  }
+  if (hidden > 0) visibleLines.push(dim(`${S_BAR3}  ${hidden} more \u2014 keep typing to narrow`));
+  if (filtered.length === 0) visibleLines.push(dim(`${S_BAR3}  No matches`));
   return visibleLines.join("\n");
 }
 async function runFilterablePrompt(opts) {
@@ -423,7 +604,7 @@ async function runFilterablePrompt(opts) {
       scrollOffset = cursor - MAX_VISIBLE2 + 1;
     if (scrollOffset < 0) scrollOffset = 0;
   };
-  const prompt = new Prompt2(
+  const prompt = new Prompt3(
     {
       initialValue: !multi ? options[cursor]?.bcp47 ?? null : null,
       validate() {
@@ -436,43 +617,34 @@ async function runFilterablePrompt(opts) {
       render() {
         const filtered = getFiltered();
         clampCursor(filtered);
-        const hdr = `${dim(S_BAR2)}
-${symbol2(this.state)}  ${message}
+        const hdr = `${dim(S_BAR3)}
+${symbol3(this.state)}  ${message}
 `;
-        const hint = filter.length > 0 ? filter : dim(
-          `type to filter, \u2191\u2193 navigate${multi ? ", space select" : ""}`
-        );
+        const inputHint = filter.length > 0 ? filter : dim("type to filter");
+        const footer = multi ? selected.size > 0 ? dim(`${S_BAR3}  ${selected.size} selected  \xB7  \u2191\u2193 navigate  \xB7  Space to select  \xB7  Enter to confirm`) : dim(`${S_BAR3}  \u2191\u2193 navigate  \xB7  Space to select  \xB7  Enter to confirm`) : dim(`${S_BAR3}  \u2191\u2193 navigate  \xB7  Enter to confirm`);
         switch (this.state) {
           case "submit": {
             const val = multi ? Array.from(selected).map((id) => options.find((o) => o.bcp47 === id)?.label ?? id).join(", ") : options.find((o) => o.bcp47 === this.value)?.label ?? "";
-            return `${hdr}${dim(S_BAR2)}  ${bld(val || dim("none"))}`;
+            return `${hdr}${dim(S_BAR3)}  ${bld(val || dim("none"))}`;
           }
           case "cancel":
-            return `${hdr}${dim(S_BAR2)}`;
+            return `${hdr}${dim(S_BAR3)}`;
           case "error":
             return [
               hdr.trimEnd(),
-              `${ylw(S_BAR2)}  ${dim("/")} ${hint}`,
-              buildList2(
-                filtered,
-                cursor,
-                scrollOffset,
-                multi ? selected : null
-              ),
-              `${ylw(S_BAR_END2)}  ${ylw(this.error)}`,
+              `${ylw(S_BAR3)}  ${dim("/")} ${inputHint}`,
+              buildList2(filtered, cursor, scrollOffset, multi ? selected : null),
+              footer,
+              `${ylw(S_BAR_END3)}  ${ylw(this.error)}`,
               ""
             ].join("\n");
           default:
             return [
               hdr.trimEnd(),
-              `${info(S_BAR2)}  ${dim("/")} ${hint}`,
-              buildList2(
-                filtered,
-                cursor,
-                scrollOffset,
-                multi ? selected : null
-              ),
-              `${info(S_BAR_END2)}`,
+              `${info(S_BAR3)}  ${dim("/")} ${inputHint}`,
+              buildList2(filtered, cursor, scrollOffset, multi ? selected : null),
+              footer,
+              `${info(S_BAR_END3)}`,
               ""
             ].join("\n");
         }
@@ -529,7 +701,7 @@ ${symbol2(this.state)}  ${message}
     }
   });
   const result = await prompt.prompt();
-  if (isCancel2(result)) return null;
+  if (isCancel4(result)) return null;
   return result;
 }
 async function searchSelectLocale(options, message, initialValue) {
@@ -551,7 +723,7 @@ async function searchMultiSelectLocales(options, message, initialValues) {
   if (result === null) return null;
   const picks = result;
   if (picks.length === 0) {
-    p.log.warn(
+    p2.log.warn(
       "At least one target language is required. Please select at least one."
     );
     return searchMultiSelectLocales(options, message, initialValues);
@@ -579,22 +751,23 @@ function buildLanguageOptions(locales) {
   return Array.from(byFamily.values());
 }
 async function runProjectCreate(params) {
-  const { api, userToken, organizationId, repoCanonical } = params;
+  const { api, userToken, organizationId, repoCanonical, repoRoot } = params;
   const projectName = (params.defaultName ?? "my-project").trim();
-  p2.log.success(`Project: ${chalk2.bold(projectName)}`);
+  p3.log.success(`Project: ${chalk2.bold(projectName)}`);
   let sourceLocales;
   try {
     ({ sourceLocales } = await api.listLocales(userToken));
   } catch {
-    p2.log.error(
+    p3.log.error(
       "Failed to fetch supported locales. Check your connection and try again."
     );
     return null;
   }
   const languageOptions = buildLanguageOptions(sourceLocales);
-  const appDir = params.defaultAppDir ?? "";
-  if (appDir) {
-    p2.log.success(`App directory: ${chalk2.bold(appDir)}`);
+  const appDirs = await collectAppDirs({ cwd: repoRoot, maxDirs: params.maxAppDirs });
+  if (appDirs === null) return null;
+  if (appDirs.length > 0) {
+    p3.log.success(`App directories: ${appDirs.map((d) => chalk2.bold(d)).join(", ")}`);
   }
   const sourceLocale = await searchSelectLocale(
     languageOptions,
@@ -606,7 +779,7 @@ async function runProjectCreate(params) {
   try {
     compatibleTargets = await api.listCompatibleLocales(userToken, sourceLocale);
   } catch {
-    p2.log.error(
+    p3.log.error(
       "Failed to fetch compatible target locales. Check your connection and try again."
     );
     return null;
@@ -621,7 +794,7 @@ async function runProjectCreate(params) {
   );
   if (targetLocales === null) return null;
   if (targetLocales.length === 0) {
-    p2.log.warn(
+    p3.log.warn(
       "No target languages selected \u2014 you can add them later from the dashboard."
     );
   }
@@ -631,63 +804,64 @@ async function runProjectCreate(params) {
   {
     let initial = initialBranches;
     while (pushBranches.length === 0) {
-      const result = await filterableBranchSelect({
+      const result2 = await filterableBranchSelect({
         message: "Which branches should trigger translations?",
         branches: detected.branches,
         defaultBranch: detected.defaultBranch,
         initialValues: initial
       });
-      if (result === null) return null;
-      if (result.length === 0) {
-        p2.log.warn(
+      if (result2 === null) return null;
+      if (result2.length === 0) {
+        p3.log.warn(
           "At least one branch is required. Please select at least one."
         );
         initial = [detected.defaultBranch];
       } else {
-        pushBranches = result;
+        pushBranches = result2;
       }
     }
   }
   const targetBranches = pushBranches;
-  try {
-    const result = await api.createProject(userToken, {
-      organizationId,
-      name: projectName,
-      sourceLocale,
-      targetLocales,
-      targetBranches,
-      appDirs: appDir ? [appDir] : [],
-      repoCanonical
-    });
-    p2.log.success(`Project ${chalk2.bold(result.projectName)} created!`);
-    return result;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    p2.log.error(`Failed to create project: ${message}`);
-    return null;
-  }
+  const result = await api.createProject(userToken, {
+    organizationId,
+    name: projectName,
+    sourceLocale,
+    targetLocales,
+    targetBranches,
+    appDirs,
+    repoCanonical
+  });
+  p3.log.success(`Project ${chalk2.bold(result.projectName)} created!`);
+  return {
+    projectId: result.projectId,
+    projectName: result.projectName,
+    apiKey: result.apiKey,
+    sourceLocale,
+    targetLocales,
+    targetBranches,
+    repositoryBound: result.repositoryBound,
+    configureUrl: result.configureUrl,
+    apps: result.apps
+  };
 }
 async function runAppCreate(params) {
   const { api, userToken, projectId, projectName, repoCanonical } = params;
-  const existingScopes = new Set(params.existingApps.map((a) => a.appDir));
+  const existingDirs = params.existingApps.map((a) => a.appDir);
+  const appDir = await promptSingleAppDir({ existingDirs });
+  if (appDir === null) return null;
+  if (appDir) {
+    p3.log.success(`App directory: ${chalk2.bold(appDir)}`);
+  }
   let sourceLocales;
   try {
     ({ sourceLocales } = await api.listLocales(userToken));
   } catch {
-    p2.log.error(
+    p3.log.error(
       "Failed to fetch supported locales. Check your connection and try again."
     );
     return null;
   }
   const languageOptions = buildLanguageOptions(sourceLocales);
-  const appDir = params.defaultAppDir ?? "";
-  if (existingScopes.has(appDir)) {
-    p2.log.error(`App directory "${appDir}" is already configured for this project.`);
-    return null;
-  }
-  if (appDir) {
-    p2.log.success(`App directory: ${chalk2.bold(appDir)}`);
-  }
   const sourceLocale = await searchSelectLocale(
     languageOptions,
     "Source language",
@@ -698,7 +872,7 @@ async function runAppCreate(params) {
   try {
     compatibleTargets = await api.listCompatibleLocales(userToken, sourceLocale);
   } catch {
-    p2.log.error(
+    p3.log.error(
       "Failed to fetch compatible target locales. Check your connection and try again."
     );
     return null;
@@ -712,7 +886,7 @@ async function runAppCreate(params) {
   );
   if (targetLocales === null) return null;
   if (targetLocales.length === 0) {
-    p2.log.warn(
+    p3.log.warn(
       "No target languages selected \u2014 you can add them later from the dashboard."
     );
   }
@@ -721,60 +895,54 @@ async function runAppCreate(params) {
   {
     let initial = [detectedApp.defaultBranch];
     while (appPushBranches.length === 0) {
-      const result = await filterableBranchSelect({
+      const result2 = await filterableBranchSelect({
         message: "Which branches should trigger translations?",
         branches: detectedApp.branches,
         defaultBranch: detectedApp.defaultBranch,
         initialValues: initial
       });
-      if (result === null) return null;
-      if (result.length === 0) {
-        p2.log.warn("At least one branch is required.");
+      if (result2 === null) return null;
+      if (result2.length === 0) {
+        p3.log.warn("At least one branch is required.");
         initial = [detectedApp.defaultBranch];
       } else {
-        appPushBranches = result;
+        appPushBranches = result2;
       }
     }
   }
   const targetBranches = appPushBranches;
-  try {
-    const result = await api.createProject(userToken, {
-      projectId,
-      appDir,
-      sourceLocale,
-      targetLocales,
-      targetBranches,
-      repoCanonical: repoCanonical ?? ""
-    });
-    p2.log.success(
-      `App ${chalk2.bold(appDir)} added to ${chalk2.bold(projectName)}!`
-    );
-    return {
-      projectId: result.projectId,
-      projectName: result.projectName,
-      apiKey: result.apiKey,
-      appDir: result.appDir,
-      sourceLocale,
-      targetLocales,
-      targetBranches
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    p2.log.error(`Failed to add app: ${message}`);
-    return null;
-  }
+  const result = await api.createApp(userToken, {
+    projectId,
+    appDir,
+    sourceLocale,
+    targetLocales,
+    targetBranches,
+    repoCanonical: repoCanonical ?? ""
+  });
+  p3.log.success(
+    `App ${chalk2.bold(appDir || "(root)")} added to ${chalk2.bold(projectName)}!`
+  );
+  return {
+    projectId: result.projectId,
+    projectName: result.projectName,
+    appDir: result.appDir,
+    appId: result.appId,
+    sourceLocale,
+    targetLocales,
+    targetBranches
+  };
 }
 
 // src/utils/github-connect.ts
-import { spawn } from "child_process";
-import * as p3 from "@clack/prompts";
+import * as p4 from "@clack/prompts";
 import chalk3 from "chalk";
+import { spawn } from "child_process";
 
 // src/utils/local-server.ts
 import { createServer } from "http";
 import { URL as URL2 } from "url";
 function startCallbackServer() {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let settled = false;
     let callbackResolve = null;
     let callbackReject = null;
@@ -825,7 +993,7 @@ function startCallbackServer() {
       if (settled) return;
       settled = true;
       const port = server.address().port;
-      resolve2({
+      resolve3({
         port,
         waitForCallback: () => callbackPromise,
         close: () => server.close()
@@ -852,7 +1020,7 @@ async function tryOpenBrowser(url) {
     command = "xdg-open";
     args = [url];
   }
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     try {
       const child = spawn(command, args, {
         detached: true,
@@ -864,20 +1032,20 @@ async function tryOpenBrowser(url) {
         if (settled) return;
         settled = true;
         child.unref();
-        resolve2(true);
+        resolve3(true);
       });
       child.once("error", () => {
         if (settled) return;
         settled = true;
-        resolve2(false);
+        resolve3(false);
       });
       setTimeout(() => {
         if (settled) return;
         settled = true;
-        resolve2(false);
+        resolve3(false);
       }, 300);
     } catch {
-      resolve2(false);
+      resolve3(false);
     }
   });
 }
@@ -894,24 +1062,23 @@ async function runGitHubInstallFlow(params) {
       callbackPort: server?.port
     }
   );
-  p3.log.info("Opening GitHub to install the Vocoder App...");
-  p3.note(installUrl, "Install URL");
+  p4.log.info("Opening GitHub to install the Vocoder App...");
   if (process.stdin.isTTY && process.stdout.isTTY && process.env.CI !== "true") {
-    const shouldOpen = params.yes ? true : await p3.confirm({ message: "Open in your browser?" });
-    if (p3.isCancel(shouldOpen)) {
+    const shouldOpen = params.yes ? true : await p4.confirm({ message: "Open in your browser?" });
+    if (p4.isCancel(shouldOpen)) {
       server?.close();
       return null;
     }
     if (shouldOpen) {
       const opened = await tryOpenBrowser(installUrl);
       if (!opened) {
-        p3.log.info(
+        p4.log.info(
           "Could not open a browser automatically. Use the URL above."
         );
       }
     }
   }
-  const connectSpinner = p3.spinner();
+  const connectSpinner = p4.spinner();
   connectSpinner.start("Waiting for GitHub App installation...");
   if (server) {
     try {
@@ -919,26 +1086,26 @@ async function runGitHubInstallFlow(params) {
       const callbackParams = await Promise.race([
         server.waitForCallback(),
         new Promise(
-          (resolve2) => setTimeout(() => resolve2(null), params_timeout)
+          (resolve3) => setTimeout(() => resolve3(null), params_timeout)
         )
       ]);
       server.close();
       if (!callbackParams) {
         connectSpinner.stop("GitHub App installation timed out");
-        p3.log.error(
+        p4.log.error(
           "The installation flow timed out. Run `vocoder init` again."
         );
         return null;
       }
       if (callbackParams.error) {
         connectSpinner.stop("GitHub App installation failed");
-        p3.log.error(callbackParams.error);
+        p4.log.error(callbackParams.error);
         return null;
       }
       const { organizationId, connectionLabel, workspace_created } = callbackParams;
       if (!organizationId || !connectionLabel) {
         connectSpinner.stop("GitHub App installation incomplete");
-        p3.log.error("Missing organization or connection data from callback.");
+        p4.log.error("Missing organization or connection data from callback.");
         return null;
       }
       connectSpinner.stop(
@@ -957,7 +1124,7 @@ async function runGitHubInstallFlow(params) {
     }
   }
   connectSpinner.stop("Could not detect GitHub App installation automatically");
-  p3.log.warn(
+  p4.log.warn(
     "Complete the installation in your browser, then run `vocoder init` again."
   );
   return null;
@@ -972,22 +1139,21 @@ async function runGitHubDiscoveryFlow(params) {
     organizationId: params.organizationId,
     callbackPort: server?.port
   });
-  p3.log.info("Opening GitHub to authorize your account...");
-  p3.note("Complete authorization in your browser.");
+  p4.log.info("Opening GitHub to authorize your account...");
   if (process.stdin.isTTY && process.stdout.isTTY && process.env.CI !== "true") {
-    const shouldOpen = params.yes ? true : await p3.confirm({ message: "Open in your browser?" });
-    if (p3.isCancel(shouldOpen)) {
+    const shouldOpen = params.yes ? true : await p4.confirm({ message: "Open in your browser?" });
+    if (p4.isCancel(shouldOpen)) {
       server?.close();
       return null;
     }
     if (shouldOpen) {
       const opened = await tryOpenBrowser(oauthUrl);
       if (!opened) {
-        p3.log.info(`Could not open browser automatically. Visit: ${oauthUrl}`);
+        p4.log.info(`Could not open browser automatically. Visit: ${oauthUrl}`);
       }
     }
   }
-  const oauthSpinner = p3.spinner();
+  const oauthSpinner = p4.spinner();
   oauthSpinner.start("Waiting for GitHub authorization...");
   if (server) {
     try {
@@ -995,7 +1161,7 @@ async function runGitHubDiscoveryFlow(params) {
       const callbackParams = await Promise.race([
         server.waitForCallback(),
         new Promise(
-          (resolve2) => setTimeout(() => resolve2(null), timeoutMs)
+          (resolve3) => setTimeout(() => resolve3(null), timeoutMs)
         )
       ]);
       server.close();
@@ -1005,7 +1171,7 @@ async function runGitHubDiscoveryFlow(params) {
       }
       if (callbackParams.error) {
         oauthSpinner.stop("GitHub authorization failed");
-        p3.log.error(callbackParams.error);
+        p4.log.error(callbackParams.error);
         return null;
       }
     } catch {
@@ -1025,7 +1191,7 @@ async function selectGitHubInstallation(installations, canInstallNew) {
     value: String(inst.installationId),
     label: inst.accountLogin,
     hint: [
-      inst.accountType === "Organization" ? "organization" : "personal",
+      inst.accountType === "Organization" ? "GitHub org" : "personal account",
       inst.conflictLabel ? `connected to ${inst.conflictLabel}` : "",
       inst.isSuspended ? "suspended" : ""
     ].filter(Boolean).join(" \xB7 ") || void 0
@@ -1033,26 +1199,24 @@ async function selectGitHubInstallation(installations, canInstallNew) {
   if (canInstallNew) {
     options.push({
       value: "install_new",
-      label: `Install on a new account ${chalk3.dim("(creates a new personal workspace)")}`
+      label: `Install on a new account ${chalk3.dim("(creates a new workspace)")}`
     });
   }
-  const selected = await p3.select({
-    message: "Select a GitHub installation",
+  const selected = await p4.select({
+    message: "Which GitHub account should this workspace connect to?",
     options
   });
-  if (p3.isCancel(selected)) return null;
+  if (p4.isCancel(selected)) return null;
   if (selected === "install_new") return "install_new";
   return Number(selected);
 }
 
 // src/commands/init.ts
 import chalk5 from "chalk";
-import { join as join2 } from "path";
 import { config as loadEnv } from "dotenv";
 
 // src/utils/git-identity.ts
 import { execSync as execSync2 } from "child_process";
-import { relative, resolve } from "path";
 var SHA_REGEX = /^[0-9a-f]{40}$/i;
 function detectCommitSha() {
   if (process.env.VOCODER_COMMIT_SHA && SHA_REGEX.test(process.env.VOCODER_COMMIT_SHA)) {
@@ -1130,21 +1294,13 @@ function resolveGitRepositoryIdentity() {
   if (!parsed) {
     return null;
   }
-  const repositoryRoot = safeExec("git rev-parse --show-toplevel");
-  const currentDirectory = process.cwd();
-  let repoAppDir = "";
-  if (repositoryRoot) {
-    const relativePath = relative(
-      resolve(repositoryRoot),
-      resolve(currentDirectory)
-    ).replace(/\\/g, "/").trim();
-    if (relativePath && relativePath !== "." && !relativePath.startsWith("..")) {
-      repoAppDir = relativePath;
-    }
+  const repoRoot = safeExec("git rev-parse --show-toplevel");
+  if (!repoRoot) {
+    return null;
   }
   return {
     repoCanonical: toCanonical(parsed.host, parsed.ownerRepoPath),
-    repoAppDir
+    repoRoot
   };
 }
 function resolveGitContext() {
@@ -1158,47 +1314,47 @@ function resolveGitContext() {
   return { identity, warnings };
 }
 
-// src/utils/workspace.ts
-import * as p4 from "@clack/prompts";
+// src/utils/organization.ts
+import * as p5 from "@clack/prompts";
 import chalk4 from "chalk";
-async function selectWorkspace(result) {
-  const { workspaces, canCreateWorkspace } = result;
-  if (workspaces.length === 0) {
+async function selectOrganization(result) {
+  const { organizations, canCreateOrganization } = result;
+  if (organizations.length === 0) {
     return { action: "create" };
   }
-  const options = workspaces.map((ws) => ({
-    value: ws.id,
-    label: ws.name,
+  const options = organizations.map((org) => ({
+    value: org.id,
+    label: org.name,
     hint: [
-      ws.projectCount > 0 ? `${ws.projectCount} project${ws.projectCount !== 1 ? "s" : ""}` : "",
-      ws.connectionLabel ? `GitHub: ${ws.connectionLabel}` : ""
+      org.projectCount > 0 ? `${org.projectCount} project${org.projectCount !== 1 ? "s" : ""}` : "",
+      org.connectionLabel ? `GitHub: ${org.connectionLabel}` : ""
     ].filter(Boolean).join(" \xB7 ") || void 0
   }));
-  if (canCreateWorkspace) {
+  if (canCreateOrganization) {
     options.push({ value: "create", label: "Create new workspace" });
   }
-  const selected = await p4.select({
+  const selected = await p5.select({
     message: "Select workspace",
     options
   });
-  if (p4.isCancel(selected)) {
+  if (p5.isCancel(selected)) {
     return { action: "cancelled" };
   }
   if (selected === "create") {
     return { action: "create" };
   }
-  const workspace = workspaces.find((ws) => ws.id === selected);
-  if (!workspace) {
+  const organization = organizations.find((org) => org.id === selected);
+  if (!organization) {
     return { action: "cancelled" };
   }
-  return { action: "use", workspace };
+  return { action: "use", organization };
 }
 
 // src/commands/init.ts
 loadEnv();
 var SUBSCRIPTION_SETTINGS_PATH = "/dashboard/workspace/settings?tab=subscription";
 async function sleep(ms) {
-  await new Promise((resolve2) => setTimeout(resolve2, ms));
+  await new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function tryOpenBrowser2(url) {
   if (!process.stdout.isTTY || process.env.CI === "true") {
@@ -1216,7 +1372,7 @@ async function tryOpenBrowser2(url) {
     command = "xdg-open";
     args = [url];
   }
-  return await new Promise((resolve2) => {
+  return await new Promise((resolve3) => {
     try {
       const child = spawn2(command, args, {
         detached: true,
@@ -1228,20 +1384,20 @@ async function tryOpenBrowser2(url) {
         if (settled) return;
         settled = true;
         child.unref();
-        resolve2(true);
+        resolve3(true);
       });
       child.once("error", () => {
         if (settled) return;
         settled = true;
-        resolve2(false);
+        resolve3(false);
       });
       setTimeout(() => {
         if (settled) return;
         settled = true;
-        resolve2(false);
+        resolve3(false);
       }, 300);
     } catch {
-      resolve2(false);
+      resolve3(false);
     }
   });
 }
@@ -1253,24 +1409,24 @@ function getSubscriptionSettingsUrl(apiUrl) {
   return new URL(SUBSCRIPTION_SETTINGS_PATH, apiUrl).toString();
 }
 function printPlanLimitMessage(apiUrl, message) {
-  p5.log.error(`You are over your plan limits.
+  p6.log.error(`You are over your plan limits.
    ${message}`);
-  p5.log.info(`Manage subscription: ${getSubscriptionSettingsUrl(apiUrl)}`);
+  p6.log.info(`Manage subscription: ${getSubscriptionSettingsUrl(apiUrl)}`);
 }
 function runScaffold(params) {
-  const { sourceLocale, targetBranches, appDir } = params;
+  const { targetBranches } = params;
   const detection = detectLocalEcosystem();
   const useTypeScript = detection.isTypeScript;
   if (detection.ecosystem) {
     const frameworkLabel = detection.framework ?? detection.ecosystem;
     const pmLabel = detection.packageManager;
-    p5.log.info(`Detected:  ${chalk5.bold(frameworkLabel)} (${pmLabel})`);
+    p6.log.info(`Detected:  ${chalk5.bold(frameworkLabel)} (${pmLabel})`);
   }
   const { devPackages, runtimePackages } = getPackagesToInstall(detection);
   const allPackages = [...devPackages, ...runtimePackages];
   if (allPackages.length > 0) {
-    p5.log.info("");
-    const installSpinner = p5.spinner();
+    p6.log.info("");
+    const installSpinner = p6.spinner();
     installSpinner.start(`Installing ${allPackages.join(", ")}...`);
     try {
       if (devPackages.length > 0) {
@@ -1290,70 +1446,25 @@ function runScaffold(params) {
       installSpinner.stop("Package installation failed");
       const cmds = [
         devPackages.length > 0 ? buildInstallCommand(detection.packageManager, devPackages, true) : null,
-        runtimePackages.length > 0 ? buildInstallCommand(detection.packageManager, runtimePackages, false) : null
+        runtimePackages.length > 0 ? buildInstallCommand(
+          detection.packageManager,
+          runtimePackages,
+          false
+        ) : null
       ].filter(Boolean).join(" && ");
-      p5.log.warn(`Run manually: ${highlight(cmds)}`);
+      p6.log.warn(`Run manually: ${highlight(cmds)}`);
     }
   } else if (detection.ecosystem) {
-    p5.log.info(`Packages:  ${chalk5.green("already installed")}`);
-  }
-  const snippets = getSetupSnippets({
-    framework: detection.framework,
-    ecosystem: detection.ecosystem,
-    sourceLocale,
-    targetBranches,
-    appDir
-  });
-  const steps = [];
-  if (snippets.pluginStep) {
-    steps.push({
-      label: snippets.pluginStep.file,
-      hint: "register the build plugin so Vocoder can extract your strings",
-      code: snippets.pluginStep.code
-    });
-  }
-  if (snippets.providerStep) {
-    steps.push({
-      label: snippets.providerStep.file,
-      hint: "wrap your app so translations load at runtime",
-      code: snippets.providerStep.code
-    });
-  }
-  steps.push({
-    label: "wrap translatable text",
-    hint: "mark strings for extraction \u2014 Vocoder picks these up on push",
-    code: snippets.wrapStep.code
-  });
-  p5.log.message("");
-  p5.log.message(chalk5.bold("Finish setup in your code"));
-  p5.log.message("");
-  for (let i = 0; i < steps.length; i++) {
-    const step = steps[i];
-    p5.log.step(
-      `${chalk5.bold(step.label)}  ${chalk5.dim(`\u2014 ${step.hint}`)}`
-    );
-    printCodeBlock(step.code);
-    if (i < steps.length - 1) p5.log.message("");
-  }
-  const written = writeVocoderConfig({ targetBranches, useTypeScript });
-  if (written) {
-    p5.log.success(`Created ${highlight(written)}`);
-  } else if (!findExistingConfig(process.cwd())) {
-    const ext = useTypeScript ? "ts" : "js";
-    p5.log.warn(
-      `Could not write vocoder.config.${ext} \u2014 create it manually with your extraction patterns.`
-    );
+    p6.log.info(`Packages:  ${chalk5.green("already installed")}`);
   }
-  p5.log.message("");
   const branchList = targetBranches.length > 0 ? targetBranches.map((b) => highlight(b)).join(" or ") : highlight("your target branch");
-  p5.log.success(
-    `Push to ${branchList} to trigger your first translation run.`
-  );
-  p5.log.message(info("  Docs: https://vocoder.app/docs/getting-started"));
+  p6.log.message("");
+  p6.log.success(`Push to ${branchList} to trigger your first translation run.`);
+  p6.log.message(info("  Docs: https://vocoder.app/docs/getting-started"));
 }
-function writeApiKeyToEnv(apiKey) {
-  const envPath = join2(process.cwd(), ".env");
-  if (!existsSync2(envPath)) return false;
+function writeApiKeyToEnv(apiKey, repoRoot) {
+  const envPath = join2(repoRoot ?? process.cwd(), ".env");
+  if (!existsSync3(envPath)) return false;
   try {
     const content = readFileSync(envPath, "utf-8");
     const keyLine = `VOCODER_API_KEY=${apiKey}`;
@@ -1371,39 +1482,132 @@ function writeApiKeyToEnv(apiKey) {
     return false;
   }
 }
-function printApiKey(apiKey) {
-  const saved = writeApiKeyToEnv(apiKey);
-  p5.log.message("");
-  p5.log.message(chalk5.bold("Your API Key"));
+function printApiKey(apiKey, repoRoot) {
+  const saved = writeApiKeyToEnv(apiKey, repoRoot);
+  p6.log.message("");
+  p6.log.message(chalk5.bold("Your API Key"));
   printCodeBlock(`VOCODER_API_KEY=${apiKey}`);
   if (saved) {
-    p5.log.success(chalk5.dim("Saved to .env"));
+    p6.log.success(chalk5.dim("Saved to .env"));
   } else {
-    p5.log.message(chalk5.dim("  Add the above to your .env file"));
+    p6.log.message(chalk5.dim("  Add the above to your .env file"));
   }
 }
-function printCodeBlock(code) {
-  const lines = code.split("\n");
-  const maxLen = lines.reduce(
-    (max, line) => Math.max(max, line.length),
-    0
+function writeAppConfigs(apps, targetBranches, useTypeScript, repoRoot) {
+  const base = repoRoot ?? process.cwd();
+  for (const app of apps) {
+    const dir = app.appDir ? resolve2(base, app.appDir) : base;
+    const written = writeVocoderConfig({
+      targetBranches,
+      appId: app.appId,
+      cwd: dir,
+      useTypeScript
+    });
+    if (written) {
+      const displayPath = app.appDir ? `${app.appDir}/${written}` : written;
+      p6.log.success(`Created ${highlight(displayPath)}`);
+    } else if (!findExistingConfig(dir)) {
+      const ext = useTypeScript ? "ts" : "js";
+      p6.log.warn(
+        `Could not write ${app.appDir ? `${app.appDir}/` : ""}vocoder.config.${ext} \u2014 create it manually.`
+      );
+    }
+  }
+}
+var MCP_DOCS_URL = "https://vocoder.app/docs/mcp";
+function mcpServerJson(apiKey) {
+  return JSON.stringify(
+    {
+      mcpServers: {
+        vocoder: {
+          type: "stdio",
+          command: "npx",
+          args: ["-y", "@vocoder/mcp"],
+          env: { VOCODER_API_KEY: apiKey }
+        }
+      }
+    },
+    null,
+    2
   );
-  const bar = chalk5.gray("\u2502");
-  const pad = (s) => s + " ".repeat(maxLen - s.length);
-  process.stdout.write(`${chalk5.gray("\u2502")}
+}
+async function runMcpSetup(apiKey) {
+  const tool = await p6.select({
+    message: "Which AI editor?",
+    options: [
+      { value: "claude", label: "Claude Code" },
+      { value: "cursor", label: "Cursor" },
+      { value: "windsurf", label: "Windsurf" },
+      { value: "vscode", label: "VS Code (GitHub Copilot)" },
+      { value: "other", label: "Other \u2014 show the config JSON" }
+    ]
+  });
+  if (p6.isCancel(tool)) return;
+  if (tool === "claude") {
+    try {
+      execSync3(
+        `claude mcp add --scope user --transport stdio --env VOCODER_API_KEY=${apiKey} vocoder -- npx -y @vocoder/mcp`,
+        { stdio: "pipe" }
+      );
+      p6.log.success("Vocoder MCP server registered in Claude Code.");
+    } catch {
+      p6.log.message("Run this to register the MCP server:");
+      printCommand(
+        `claude mcp add --scope user --transport stdio --env VOCODER_API_KEY=${apiKey} vocoder -- npx -y @vocoder/mcp`
+      );
+      p6.log.message(info(`  Docs: ${MCP_DOCS_URL}`));
+    }
+    return;
+  }
+  const configPaths = {
+    cursor: { path: "~/.cursor/mcp.json", merge: true },
+    windsurf: { path: "~/.codeium/windsurf/mcp_config.json", merge: true },
+    vscode: { path: ".vscode/mcp.json", merge: true },
+    other: { path: ".mcp.json", merge: false }
+  };
+  const { path: configPath, merge } = configPaths[tool];
+  const mergeNote = merge ? chalk5.dim(`  Merge into ${highlight(configPath)} (create if missing):`) : chalk5.dim(`  Add to ${highlight(configPath)}:`);
+  p6.log.message(mergeNote);
+  printCodeBlock(mcpServerJson(apiKey));
+  p6.log.message(info(`  Docs: ${MCP_DOCS_URL}`));
+}
+function tryClipboard(text2) {
+  const tools = [
+    { cmd: "pbcopy" },
+    { cmd: "xclip", args: ["-selection", "clipboard"] },
+    { cmd: "xsel", args: ["--clipboard", "--input"] },
+    { cmd: "wl-copy" },
+    { cmd: "clip" }
+  ];
+  for (const { cmd, args = [] } of tools) {
+    try {
+      execSync3([cmd, ...args].join(" "), {
+        input: text2,
+        stdio: ["pipe", "ignore", "ignore"]
+      });
+      return true;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+function printCommand(cmd) {
+  const copied = tryClipboard(cmd);
+  process.stdout.write("\n");
+  process.stdout.write(`  ${chalk5.dim("$")} ${chalk5.cyan(cmd)}
 `);
-  process.stdout.write(
-    `${chalk5.gray("\u2502")}  ${chalk5.gray(`\u250C${"\u2500".repeat(maxLen + 2)}\u2510`)}
-`
-  );
-  for (const line of lines) {
-    process.stdout.write(`${chalk5.gray("\u2502")}  ${bar} ${pad(line)} ${bar}
+  if (copied) process.stdout.write(`  ${chalk5.dim("\u2191 copied to clipboard")}
+`);
+  process.stdout.write("\n");
+}
+function printCodeBlock(code) {
+  process.stdout.write("\n");
+  for (const line of code.split("\n")) {
+    process.stdout.write(`  ${line}
 `);
   }
-  process.stdout.write(
-    `${chalk5.gray("\u2502")}  ${chalk5.gray(`\u2514${"\u2500".repeat(maxLen + 2)}\u2518`)}
-`
-  );
+  process.stdout.write("\n");
 }
 async function runAuthFlow(api, options, reauth = false, repoCanonical) {
   let server = null;
@@ -1416,7 +1620,7 @@ async function runAuthFlow(api, options, reauth = false, repoCanonical) {
   const session = await api.startCliAuthSession(server?.port, repoCanonical);
   const browserUrl = reauth ? session.verificationUrl : session.installUrl ?? session.verificationUrl;
   const expiresAt = new Date(session.expiresAt).getTime();
-  p5.log.info(browserUrl);
+  p6.log.info(browserUrl);
   if (options.ci) {
     process.stdout.write(`VOCODER_AUTH_URL: ${browserUrl}
 `);
@@ -1425,23 +1629,23 @@ async function runAuthFlow(api, options, reauth = false, repoCanonical) {
   } else if (process.stdin.isTTY && process.stdout.isTTY && process.env.CI !== "true") {
     if (reauth) {
       if (!options.yes) {
-        const shouldOpen = await p5.confirm({
+        const shouldOpen = await p6.confirm({
           message: "Open your browser to sign in again?"
         });
-        if (p5.isCancel(shouldOpen)) {
+        if (p6.isCancel(shouldOpen)) {
           server?.close();
-          p5.cancel("Setup cancelled.");
+          p6.cancel("Setup cancelled.");
           return null;
         }
         if (!shouldOpen) {
           server?.close();
-          p5.cancel("Setup cancelled.");
+          p6.cancel("Setup cancelled.");
           return null;
         } else {
           const opened = await tryOpenBrowser2(browserUrl);
           if (!opened) {
-            p5.note(browserUrl, "Sign In");
-            p5.log.info("Open the URL above manually to continue.");
+            p6.note(browserUrl, "Sign In");
+            p6.log.info("Open the URL above manually to continue.");
           }
         }
       } else {
@@ -1450,20 +1654,24 @@ async function runAuthFlow(api, options, reauth = false, repoCanonical) {
     } else {
       let isLinkFlow = false;
       if (!options.yes) {
-        const connectChoice = await p5.select({
+        const connectChoice = await p6.select({
           message: "Vocoder needs to be installed on your GitHub account to get started",
           options: [
             {
               value: "install",
               label: "Install GitHub App",
-              hint: "recommended"
+              hint: "new user"
             },
-            { value: "link", label: "Already installed? Link your account" }
+            {
+              value: "link",
+              label: "Already installed? Link your account",
+              hint: "returning user"
+            }
           ]
         });
-        if (p5.isCancel(connectChoice)) {
+        if (p6.isCancel(connectChoice)) {
           server?.close();
-          p5.cancel("Setup cancelled.");
+          p6.cancel("Setup cancelled.");
           return null;
         }
         isLinkFlow = connectChoice === "link";
@@ -1482,13 +1690,13 @@ async function runAuthFlow(api, options, reauth = false, repoCanonical) {
       }
       const opened = await tryOpenBrowser2(urlToOpen);
       if (!opened) {
-        p5.log.warn("Could not open your browser automatically.");
-        p5.note(urlToOpen, "GitHub");
-        p5.log.info("Open the URL above to continue.");
+        p6.log.warn("Could not open your browser automatically.");
+        p6.note(urlToOpen, "GitHub");
+        p6.log.info("Open the URL above to continue.");
       }
     }
   }
-  const authSpinner = p5.spinner();
+  const authSpinner = p6.spinner();
   authSpinner.start("Waiting for GitHub authorization...");
   let rawToken = null;
   let callbackOrganizationId;
@@ -1509,19 +1717,19 @@ async function runAuthFlow(api, options, reauth = false, repoCanonical) {
     }
     return null;
   })();
-  const winner = await new Promise((resolve2) => {
+  const winner = await new Promise((resolve3) => {
     let done = false;
     serverCallback.then((params) => {
       if (done || params === null || typeof params.token !== "string") return;
       done = true;
-      resolve2({ kind: "server", params });
+      resolve3({ kind: "server", params });
     }).catch(() => {
     });
     sessionPoll.then((result) => {
       if (done || result === null) return;
       if (result.status === "complete" || result.status === "failed") {
         done = true;
-        resolve2({
+        resolve3({
           kind: "poll",
           result
         });
@@ -1532,7 +1740,7 @@ async function runAuthFlow(api, options, reauth = false, repoCanonical) {
       () => {
         if (!done) {
           done = true;
-          resolve2(null);
+          resolve3(null);
         }
       },
       Math.max(0, deadline - Date.now())
@@ -1556,13 +1764,13 @@ async function runAuthFlow(api, options, reauth = false, repoCanonical) {
       }
     } else {
       authSpinner.stop();
-      p5.log.error(winner.result.reason);
+      p6.log.error(winner.result.reason);
       return null;
     }
   }
   if (!rawToken) {
     authSpinner.stop();
-    p5.log.error("The authentication link expired. Run `vocoder init` again.");
+    p6.log.error("The authentication link expired. Run `vocoder init` again.");
     return null;
   }
   const userInfo = await api.getCliUserInfo(rawToken);
@@ -1576,34 +1784,44 @@ async function runAuthFlow(api, options, reauth = false, repoCanonical) {
 }
 async function init(options = {}) {
   const apiUrl = options.apiUrl || process.env.VOCODER_API_URL || "https://vocoder.app";
-  p5.intro(chalk5.bold("Vocoder Setup"));
+  p6.intro(chalk5.bold("Vocoder Setup"));
   try {
     const gitContext = resolveGitContext();
     const identity = gitContext.identity;
     if (gitContext.warnings.length > 0) {
       for (const warning of gitContext.warnings) {
-        p5.log.warn(warning);
+        p6.log.warn(warning);
       }
     }
     let existingAppsForRepo = [];
     let repoProjectId = null;
     let repoProjectName = null;
+    let lookup = null;
     if (identity) {
       const anonApi = new VocoderAPI({ apiUrl, apiKey: "" });
-      const lookup = await anonApi.lookupAppByRepo({
+      lookup = await anonApi.lookupAppByRepo({
         repoCanonical: identity.repoCanonical,
-        appDir: identity.repoAppDir
+        appDir: ""
       });
-      if (lookup.exactMatch) {
-        const { exactMatch } = lookup;
-        p5.log.success(`Project: ${chalk5.bold(exactMatch.projectName)}`);
-        p5.log.info(
-          `Branches: ${highlight((exactMatch.targetBranches ?? ["main"]).join(", "))}`
+      if (lookup.existingApps.length > 0) {
+        const allApps = lookup.existingApps;
+        const firstApp = allApps[0];
+        p6.log.success(`Project: ${chalk5.bold(firstApp.projectName)}`);
+        p6.log.info(
+          `Configured apps: ${allApps.map((a) => highlight(a.appDir || "(entire repo)")).join(", ")}`
         );
-        const needsKey = await p5.confirm({
-          message: "Need to regenerate your API key?"
+        const routeAction = await p6.select({
+          message: "This repo is already set up. What would you like to do?",
+          options: [
+            { value: "key", label: "Get an API key for this project" },
+            { value: "add", label: "Add a new app directory" }
+          ]
         });
-        if (!p5.isCancel(needsKey) && needsKey) {
+        if (p6.isCancel(routeAction)) {
+          p6.cancel("Setup cancelled.");
+          return 1;
+        }
+        if (routeAction === "key") {
           const anonApi2 = new VocoderAPI({ apiUrl, apiKey: "" });
           const authResult = await runAuthFlow(
             anonApi2,
@@ -1612,44 +1830,37 @@ async function init(options = {}) {
             true
           );
           if (!authResult) return 1;
-          const spinner7 = p5.spinner();
-          spinner7.start("Generating new API key...");
+          const spinner7 = p6.spinner();
+          spinner7.start("Generating API key...");
+          let apiKey;
           try {
-            const { apiKey } = await anonApi2.regenerateProjectApiKey(
+            ({ apiKey } = await anonApi2.regenerateProjectApiKey(
               authResult.token,
-              exactMatch.projectId
-            );
-            spinner7.stop("New API key generated");
-            printApiKey(apiKey);
+              firstApp.projectId
+            ));
+            spinner7.stop("API key ready");
           } catch (err) {
             spinner7.stop("Failed to generate key");
             const msg = err instanceof Error ? err.message : String(err);
-            p5.log.error(`Could not generate API key: ${msg}`);
-            p5.log.info("Try again or generate one from the dashboard.");
+            p6.log.error(`Could not generate API key: ${msg}`);
+            p6.log.info("Try again or generate one from the dashboard.");
             return 1;
           }
-        }
-        const isTs = detectLocalEcosystem().isTypeScript;
-        const written = writeVocoderConfig({ targetBranches: exactMatch.targetBranches ?? ["main"], useTypeScript: isTs });
-        if (written) p5.log.success(`Created ${highlight(written)}`);
-        p5.outro("Vocoder is already set up for this repository.");
-        return 0;
-      }
-      if (lookup.hasWholeRepoApp) {
-        const wholeRepo = lookup.existingApps.find((a) => a.appDir === "");
-        if (wholeRepo) {
-          p5.log.success(`Project: ${chalk5.bold(wholeRepo.projectName)}`);
-          const isTs = detectLocalEcosystem().isTypeScript;
-          const written = writeVocoderConfig({ targetBranches: ["main"], useTypeScript: isTs });
-          if (written) p5.log.success(`Created ${highlight(written)}`);
-          p5.outro("Vocoder is already set up for this repository.");
+          printApiKey(apiKey, identity.repoRoot);
+          const detection2 = detectLocalEcosystem();
+          const targetBranches = lookup.exactMatch?.targetBranches ?? ["main"];
+          writeAppConfigs(
+            allApps.map((a) => ({ appDir: a.appDir, appId: a.appId })),
+            targetBranches,
+            detection2.isTypeScript,
+            identity.repoRoot
+          );
+          p6.outro("Vocoder is set up for this repository.");
           return 0;
         }
-      }
-      if (lookup.existingApps.length > 0) {
-        existingAppsForRepo = lookup.existingApps;
-        repoProjectId = lookup.existingApps[0]?.projectId ?? null;
-        repoProjectName = lookup.existingApps[0]?.projectName ?? null;
+        existingAppsForRepo = allApps;
+        repoProjectId = firstApp.projectId;
+        repoProjectName = firstApp.projectName;
       }
     }
     const api = new VocoderAPI({ apiUrl, apiKey: "" });
@@ -1659,16 +1870,16 @@ async function init(options = {}) {
     let authOrganizationId;
     const storedAuth = await verifyStoredAuth(api);
     if (storedAuth.status === "valid") {
-      p5.log.success(`Authenticated as ${chalk5.bold(storedAuth.email)}`);
+      p6.log.success(`Authenticated as ${chalk5.bold(storedAuth.email)}`);
       userToken = storedAuth.token;
       userEmail = storedAuth.email;
       userName = storedAuth.name;
     } else {
       const reauth = storedAuth.status === "expired";
       if (reauth) {
-        p5.log.warn("Stored credentials expired \u2014 signing in again");
+        p6.log.warn("Stored credentials expired \u2014 signing in again");
       } else if (storedAuth.status === "gone") {
-        p5.log.warn("Account not found \u2014 starting fresh setup");
+        p6.log.warn("Account not found \u2014 starting fresh setup");
       }
       const authResult = await runAuthFlow(
         api,
@@ -1689,101 +1900,57 @@ async function init(options = {}) {
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
-    let selectedWorkspaceId;
-    let selectedWorkspaceName;
+    let selectedOrganizationId;
+    let selectedOrganizationName;
+    const repoOrgContext = identity ? lookup?.organizationContext ?? null : null;
     if (authOrganizationId) {
-      const workspaceData = await api.listWorkspaces(userToken);
-      const ws = workspaceData.workspaces.find(
+      const organizationData = await api.listOrganizations(userToken);
+      const ws = organizationData.organizations.find(
         (w) => w.id === authOrganizationId
       );
-      selectedWorkspaceId = authOrganizationId;
-      selectedWorkspaceName = ws?.name ?? userEmail;
-      p5.log.success(
-        `Connected as ${chalk5.bold(userEmail)} \u2014 workspace: ${chalk5.bold(selectedWorkspaceName)}`
+      selectedOrganizationId = authOrganizationId;
+      selectedOrganizationName = ws?.name ?? userEmail;
+      p6.log.success(
+        `Connected as ${chalk5.bold(userEmail)} \u2014 workspace: ${chalk5.bold(selectedOrganizationName)}`
       );
+    } else if (repoOrgContext && !repoProjectId) {
+      selectedOrganizationId = repoOrgContext.organizationId;
+      selectedOrganizationName = repoOrgContext.organizationName;
+      p6.log.success(`Workspace: ${chalk5.bold(selectedOrganizationName)}`);
     } else {
-      const discoveryResult = await api.getCliGitHubDiscovery(userToken).catch(() => null);
-      const cachedInstallations = discoveryResult?.installations ?? [];
-      if (cachedInstallations.length > 0) {
-        if (identity?.repoCanonical) {
-          const repoOwner = identity.repoCanonical.split(":")[1]?.split("/")[0]?.toLowerCase();
-          if (repoOwner) {
-            const hasMatchingAccount = cachedInstallations.some(
-              (i) => i.accountLogin.toLowerCase() === repoOwner
-            );
-            if (!hasMatchingAccount) {
-              p5.log.warn(
-                `None of your GitHub App installations belong to "${repoOwner}", the account that owns this repository.
-  The project will be created but translations won't trigger automatically.
-  To fix: install the Vocoder GitHub App on "${repoOwner}" instead.`
-              );
-            }
-          }
-        }
-        const validInstallations = cachedInstallations.filter(
-          (i) => !i.isSuspended && !i.conflictLabel
-        );
-        let selectedInstallationId = null;
-        if (validInstallations.length === 1 && cachedInstallations.length === 1) {
-          selectedInstallationId = validInstallations[0].installationId;
-        } else {
-          selectedInstallationId = await selectGitHubInstallation(
-            cachedInstallations.map((inst) => ({
-              installationId: inst.installationId,
-              accountLogin: inst.accountLogin,
-              accountType: inst.accountType,
-              isSuspended: inst.isSuspended,
-              conflictLabel: inst.conflictLabel
-            })),
-            false
-          );
-        }
-        if (selectedInstallationId === null || selectedInstallationId === "install_new") {
-          p5.cancel(
-            "Setup cancelled. Re-run `vocoder init` and choose Install GitHub App."
-          );
-          return 1;
-        }
-        const claimResult = await api.claimCliGitHubInstallation(userToken, {
-          installationId: String(selectedInstallationId),
-          organizationId: null
-        });
-        selectedWorkspaceId = claimResult.organizationId;
-        selectedWorkspaceName = claimResult.organizationName;
-        p5.log.success(`Workspace: ${chalk5.bold(selectedWorkspaceName)}`);
-      } else {
-        const workspaceData = await api.listWorkspaces(userToken, {
-          repo: identity?.repoCanonical
-        });
+      const organizationData = await api.listOrganizations(userToken, {
+        repo: identity?.repoCanonical
+      });
+      {
         const repoCanonical = identity?.repoCanonical ?? null;
-        const covering = repoCanonical ? workspaceData.workspaces.filter((w) => w.coversRepo === true) : [];
-        const connected = workspaceData.workspaces.filter(
+        const covering = repoCanonical ? organizationData.organizations.filter((w) => w.coversRepo === true) : [];
+        const connected = organizationData.organizations.filter(
           (w) => w.hasGitHubConnection
         );
         if (repoCanonical && covering.length === 1) {
           const ws = covering[0];
-          selectedWorkspaceId = ws.id;
-          selectedWorkspaceName = ws.name;
-          p5.log.success(`Workspace: ${chalk5.bold(selectedWorkspaceName)}`);
+          selectedOrganizationId = ws.id;
+          selectedOrganizationName = ws.name;
+          p6.log.success(`Workspace: ${chalk5.bold(selectedOrganizationName)}`);
         } else if (repoCanonical && covering.length > 1) {
-          const choice = await p5.select({
+          const choice = await p6.select({
             message: "Select workspace for this repo",
             options: covering.map((w) => ({
               value: w.id,
-              label: `${w.name}  ${chalk5.dim(`(${w.projectCount} project${w.projectCount !== 1 ? "s" : ""})`)}`
+              label: `${w.name}  ${chalk5.dim(`(${w.appCount} app${w.appCount !== 1 ? "s" : ""})`)}`
             }))
           });
-          if (p5.isCancel(choice)) {
-            p5.cancel("Setup cancelled.");
+          if (p6.isCancel(choice)) {
+            p6.cancel("Setup cancelled.");
             return 1;
           }
           const ws = covering.find((w) => w.id === choice);
-          selectedWorkspaceId = ws.id;
-          selectedWorkspaceName = ws.name;
-          p5.log.success(`Workspace: ${chalk5.bold(selectedWorkspaceName)}`);
+          selectedOrganizationId = ws.id;
+          selectedOrganizationName = ws.name;
+          p6.log.success(`Workspace: ${chalk5.bold(selectedOrganizationName)}`);
         } else if (repoCanonical && covering.length === 0 && connected.length > 0) {
           const shortRepo = repoCanonical.split(":")[1] ?? repoCanonical;
-          p5.log.warn(
+          p6.log.warn(
             `${chalk5.bold(shortRepo)} isn't accessible from your Vocoder installation.
   Grant access to this repository or install on the account that owns it.`
           );
@@ -1801,18 +1968,18 @@ async function init(options = {}) {
             label: `Install on a different GitHub account ${chalk5.dim("(creates a new personal workspace)")}`
           });
           fixOptions.push({ value: "cancel", label: "Cancel" });
-          const fix = await p5.select({
+          const fix = await p6.select({
             message: "How would you like to fix this?",
             options: fixOptions
           });
-          if (p5.isCancel(fix) || fix === "cancel") {
-            p5.cancel("Setup cancelled.");
+          if (p6.isCancel(fix) || fix === "cancel") {
+            p6.cancel("Setup cancelled.");
             return 1;
           }
           if (fix.startsWith("grant:")) {
             const ws = connected.find((w) => `grant:${w.id}` === fix);
             await tryOpenBrowser2(ws.installationConfigureUrl);
-            p5.cancel(
+            p6.cancel(
               `Grant access to ${chalk5.bold(shortRepo)} in your browser,
   then re-run ${chalk5.bold("vocoder init")}.`
             );
@@ -1824,40 +1991,94 @@ async function init(options = {}) {
             yes: options.yes
           });
           if (!connectResult) {
-            p5.log.error(
+            p6.log.error(
               "GitHub App installation did not complete. Run `vocoder init` again."
             );
             return 1;
           }
-          selectedWorkspaceId = connectResult.organizationId;
-          selectedWorkspaceName = connectResult.organizationName;
-          p5.log.success(`Workspace: ${chalk5.bold(selectedWorkspaceName)}`);
+          selectedOrganizationId = connectResult.organizationId;
+          selectedOrganizationName = connectResult.organizationName;
+          p6.log.success(`Workspace: ${chalk5.bold(selectedOrganizationName)}`);
         } else {
-          if (workspaceData.workspaces.length === 1 && !workspaceData.canCreateWorkspace) {
-            const ws = workspaceData.workspaces[0];
-            selectedWorkspaceId = ws.id;
-            selectedWorkspaceName = ws.name;
-            p5.log.success(`Workspace: ${chalk5.bold(selectedWorkspaceName)}`);
+          const discoveryResult = await api.getCliGitHubDiscovery(userToken).catch(() => null);
+          const cachedInstallations = discoveryResult?.installations ?? [];
+          if (cachedInstallations.length > 0) {
+            if (identity?.repoCanonical) {
+              const repoOwner = identity.repoCanonical.split(":")[1]?.split("/")[0]?.toLowerCase();
+              if (repoOwner) {
+                const hasMatchingAccount = cachedInstallations.some(
+                  (i) => i.accountLogin.toLowerCase() === repoOwner
+                );
+                if (!hasMatchingAccount) {
+                  p6.log.warn(
+                    `None of your GitHub App installations belong to "${repoOwner}", the account that owns this repository.
+  The project will be created but translations won't trigger automatically.
+  To fix: install the Vocoder GitHub App on "${repoOwner}" instead.`
+                  );
+                }
+              }
+            }
+            const validInstallations = cachedInstallations.filter(
+              (i) => !i.isSuspended && !i.conflictLabel
+            );
+            let selectedInstallationId = null;
+            if (validInstallations.length === 1 && cachedInstallations.length === 1) {
+              selectedInstallationId = validInstallations[0].installationId;
+            } else {
+              selectedInstallationId = await selectGitHubInstallation(
+                cachedInstallations.map((inst) => ({
+                  installationId: inst.installationId,
+                  accountLogin: inst.accountLogin,
+                  accountType: inst.accountType,
+                  isSuspended: inst.isSuspended,
+                  conflictLabel: inst.conflictLabel
+                })),
+                false
+              );
+            }
+            if (selectedInstallationId === null || selectedInstallationId === "install_new") {
+              p6.cancel(
+                "Setup cancelled. Re-run `vocoder init` and choose Install GitHub App."
+              );
+              return 1;
+            }
+            const claimResult = await api.claimCliGitHubInstallation(
+              userToken,
+              {
+                installationId: String(selectedInstallationId),
+                organizationId: null
+              }
+            );
+            selectedOrganizationId = claimResult.organizationId;
+            selectedOrganizationName = claimResult.organizationName;
+            p6.log.success(`Workspace: ${chalk5.bold(selectedOrganizationName)}`);
+          } else if (organizationData.organizations.length === 1 && !organizationData.canCreateOrganization) {
+            const ws = organizationData.organizations[0];
+            selectedOrganizationId = ws.id;
+            selectedOrganizationName = ws.name;
+            p6.log.success(`Workspace: ${chalk5.bold(selectedOrganizationName)}`);
           } else {
-            const workspaceResult = await selectWorkspace(workspaceData);
-            if (workspaceResult.action === "cancelled") {
-              p5.cancel("Setup cancelled.");
+            const organizationResult = await selectOrganization(organizationData);
+            if (organizationResult.action === "cancelled") {
+              p6.cancel("Setup cancelled.");
               return 1;
             }
-            if (workspaceResult.action === "use") {
-              selectedWorkspaceId = workspaceResult.workspace.id;
-              selectedWorkspaceName = workspaceResult.workspace.name;
-              p5.log.success(`Workspace: ${chalk5.bold(selectedWorkspaceName)}`);
+            if (organizationResult.action === "use") {
+              selectedOrganizationId = organizationResult.organization.id;
+              selectedOrganizationName = organizationResult.organization.name;
+              p6.log.success(
+                `Workspace: ${chalk5.bold(selectedOrganizationName)}`
+              );
             } else {
-              const connectChoice = await p5.select({
+              const connectChoice = await p6.select({
                 message: "Connect your new workspace to GitHub",
                 options: [
                   { value: "install", label: "Install the Vocoder GitHub App" },
                   { value: "link", label: "Link an existing installation" }
                 ]
               });
-              if (p5.isCancel(connectChoice)) {
-                p5.cancel("Setup cancelled.");
+              if (p6.isCancel(connectChoice)) {
+                p6.cancel("Setup cancelled.");
                 return 1;
               }
               if (connectChoice === "install") {
@@ -1867,15 +2088,15 @@ async function init(options = {}) {
                   yes: options.yes
                 });
                 if (!connectResult) {
-                  p5.log.error(
+                  p6.log.error(
                     "GitHub App installation did not complete. Run `vocoder init` again."
                   );
                   return 1;
                 }
-                selectedWorkspaceId = connectResult.organizationId;
-                selectedWorkspaceName = connectResult.organizationName;
-                p5.log.success(
-                  `Workspace: ${chalk5.bold(selectedWorkspaceName)}`
+                selectedOrganizationId = connectResult.organizationId;
+                selectedOrganizationName = connectResult.organizationName;
+                p6.log.success(
+                  `Workspace: ${chalk5.bold(selectedOrganizationName)}`
                 );
               } else {
                 const installations = await runGitHubDiscoveryFlow({
@@ -1885,21 +2106,21 @@ async function init(options = {}) {
                 });
                 if (!installations) return 1;
                 if (installations.length === 0) {
-                  p5.log.warn(
+                  p6.log.warn(
                     "No GitHub installations found. Install the Vocoder GitHub App first."
                   );
-                  const installNow = await p5.confirm({
+                  const installNow = await p6.confirm({
                     message: "Open GitHub to install the App?"
                   });
-                  if (p5.isCancel(installNow) || !installNow) return 1;
+                  if (p6.isCancel(installNow) || !installNow) return 1;
                   const connectResult = await runGitHubInstallFlow({
                     api,
                     userToken,
                     yes: options.yes
                   });
                   if (!connectResult) return 1;
-                  selectedWorkspaceId = connectResult.organizationId;
-                  selectedWorkspaceName = connectResult.organizationName;
+                  selectedOrganizationId = connectResult.organizationId;
+                  selectedOrganizationName = connectResult.organizationName;
                 } else {
                   const selectedInstallationId = await selectGitHubInstallation(
                     installations.map((inst) => ({
@@ -1912,7 +2133,7 @@ async function init(options = {}) {
                     true
                   );
                   if (selectedInstallationId === null) {
-                    p5.cancel("Setup cancelled.");
+                    p6.cancel("Setup cancelled.");
                     return 1;
                   }
                   if (selectedInstallationId === "install_new") {
@@ -1922,8 +2143,8 @@ async function init(options = {}) {
                       yes: options.yes
                     });
                     if (!connectResult) return 1;
-                    selectedWorkspaceId = connectResult.organizationId;
-                    selectedWorkspaceName = connectResult.organizationName;
+                    selectedOrganizationId = connectResult.organizationId;
+                    selectedOrganizationName = connectResult.organizationName;
                   } else {
                     const claimResult = await api.claimCliGitHubInstallation(
                       userToken,
@@ -1932,12 +2153,12 @@ async function init(options = {}) {
                         organizationId: null
                       }
                     );
-                    selectedWorkspaceId = claimResult.organizationId;
-                    selectedWorkspaceName = claimResult.organizationName;
+                    selectedOrganizationId = claimResult.organizationId;
+                    selectedOrganizationName = claimResult.organizationName;
                   }
                 }
-                p5.log.success(
-                  `Workspace: ${chalk5.bold(selectedWorkspaceName)}`
+                p6.log.success(
+                  `Workspace: ${chalk5.bold(selectedOrganizationName)}`
                 );
               }
             }
@@ -1946,116 +2167,80 @@ async function init(options = {}) {
       }
     }
     if (repoProjectId && repoProjectName && existingAppsForRepo.length > 0) {
-      p5.log.info(
-        `${chalk5.bold(repoProjectName)} is already set up for this repo.
-  Configured apps: ${existingAppsForRepo.map((a) => highlight(a.appDir || "(entire repo)")).join(", ")}`
-      );
       const appResult = await runAppCreate({
         api,
         userToken,
         projectId: repoProjectId,
         projectName: repoProjectName,
-        organizationName: selectedWorkspaceName,
+        organizationName: selectedOrganizationName,
         repoCanonical: identity?.repoCanonical,
-        defaultAppDir: identity?.repoAppDir,
         existingApps: existingAppsForRepo
       });
       if (!appResult) {
-        p5.log.error("App setup failed. Run `vocoder init` again.");
+        p6.log.error("App setup failed. Run `vocoder init` again.");
         return 1;
       }
-      runScaffold({
-        sourceLocale: appResult.sourceLocale,
-        targetBranches: appResult.targetBranches,
-        appDir: identity?.repoAppDir
-      });
-      p5.outro("You're all set.");
+      const detection2 = detectLocalEcosystem();
+      runScaffold({ targetBranches: appResult.targetBranches });
+      writeAppConfigs(
+        [{ appDir: appResult.appDir, appId: appResult.appId }],
+        appResult.targetBranches,
+        detection2.isTypeScript,
+        identity?.repoRoot
+      );
+      p6.log.info(
+        chalk5.dim("Use the VOCODER_API_KEY already in your root .env")
+      );
+      p6.outro("You're all set.");
       return 0;
     }
+    let remainingApps;
     try {
-      const wsCheck = await api.listWorkspaces(userToken);
-      const ws = wsCheck.workspaces.find((w) => w.id === selectedWorkspaceId);
-      if (ws && ws.maxProjects !== -1 && ws.projectCount >= ws.maxProjects) {
-        p5.log.warn(
-          `Project limit reached \u2014 ${ws.projectCount}/${ws.maxProjects} on your ${chalk5.bold(ws.planId)} plan.`
-        );
-        const options2 = [];
-        if (repoProjectId) {
-          options2.push({
-            value: "connect",
-            label: `Reconnect this repo to ${chalk5.bold(repoProjectName ?? "existing project")}`
+      const wsCheck = await api.listOrganizations(userToken);
+      const ws = wsCheck.organizations.find(
+        (w) => w.id === selectedOrganizationId
+      );
+      if (ws) {
+        if (ws.maxApps !== -1 && ws.appCount >= ws.maxApps) {
+          p6.log.warn(
+            `App limit reached \u2014 ${ws.appCount}/${ws.maxApps} on your ${chalk5.bold(ws.planId)} plan.`
+          );
+          const limitAction = await p6.select({
+            message: "What would you like to do?",
+            options: [
+              { value: "upgrade", label: "Upgrade plan" },
+              { value: "cancel", label: "Cancel" }
+            ]
           });
-        }
-        options2.push({ value: "upgrade", label: "Upgrade plan" });
-        options2.push({ value: "cancel", label: "Cancel" });
-        const limitAction = await p5.select({
-          message: "What would you like to do?",
-          options: options2
-        });
-        if (p5.isCancel(limitAction) || limitAction === "cancel") {
-          p5.cancel("Setup cancelled.");
-          return 1;
-        }
-        if (limitAction === "upgrade") {
+          if (p6.isCancel(limitAction) || limitAction === "cancel") {
+            p6.cancel("Setup cancelled.");
+            return 1;
+          }
           await tryOpenBrowser2(`${apiUrl}${SUBSCRIPTION_SETTINGS_PATH}`);
-          p5.cancel(
+          p6.cancel(
             "Upgrade your plan in the browser, then re-run `vocoder init`."
           );
           return 1;
         }
-        const existingProjects = await api.listApps(
-          userToken,
-          selectedWorkspaceId
-        );
-        const chosenProject = existingProjects.find(
-          (proj) => proj.id === repoProjectId
-        );
-        if (!chosenProject) {
-          p5.log.error("Could not find the project. Try again.");
-          return 1;
-        }
-        try {
-          const appResult = await api.createApp(userToken, {
-            projectId: chosenProject.id,
-            appDir: identity?.repoAppDir ?? "",
-            sourceLocale: chosenProject.sourceLocale,
-            targetLocales: chosenProject.targetLocales,
-            targetBranches: chosenProject.targetBranches,
-            repoCanonical: identity?.repoCanonical ?? ""
-          });
-          p5.log.success(`Connected to project: ${chalk5.bold(chosenProject.name)}`);
-          printApiKey(appResult.apiKey);
-          runScaffold({
-            sourceLocale: chosenProject.sourceLocale,
-            targetBranches: chosenProject.targetBranches,
-            appDir: identity?.repoAppDir
-          });
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          p5.log.error(`Failed to create app binding: ${msg}`);
-          return 1;
-        }
-        p5.outro("You're all set.");
-        return 0;
+        remainingApps = ws.maxApps === -1 ? void 0 : Math.max(0, ws.maxApps - ws.appCount);
       }
     } catch {
+      p6.log.warn("Could not verify plan limits \u2014 proceeding, the server will enforce them.");
     }
     const projectResult = await runProjectCreate({
       api,
       userToken,
-      organizationId: selectedWorkspaceId,
+      organizationId: selectedOrganizationId,
       defaultName: identity?.repoCanonical ? identity.repoCanonical.split("/").pop() : void 0,
       defaultSourceLocale: "en",
       repoCanonical: identity?.repoCanonical,
+      repoRoot: identity?.repoRoot,
       defaultBranches: ["main"],
-      defaultAppDir: identity?.repoAppDir
+      maxAppDirs: remainingApps
     });
-    if (!projectResult) {
-      p5.log.error("Project creation failed. Run `vocoder init` again.");
-      return 1;
-    }
+    if (!projectResult) return 1;
     if (!projectResult.repositoryBound && identity?.repoCanonical) {
-      p5.log.warn(
+      p6.log.warn(
         `This repository isn't accessible to your GitHub App installation.
 Translations won't run automatically until you grant access.
 
@@ -2066,38 +2251,45 @@ Translations won't run automatically until you grant access.
 ` : "")
       );
     }
-    runScaffold({
-      sourceLocale: projectResult.sourceLocale,
-      targetBranches: projectResult.targetBranches,
-      appDir: identity?.repoAppDir
+    const detection = detectLocalEcosystem();
+    runScaffold({ targetBranches: projectResult.targetBranches });
+    writeAppConfigs(
+      projectResult.apps,
+      projectResult.targetBranches,
+      detection.isTypeScript,
+      identity?.repoRoot
+    );
+    printApiKey(projectResult.apiKey, identity?.repoRoot);
+    const wantsMcp = await p6.confirm({
+      message: "Set up the Vocoder MCP server for your AI editor?"
     });
-    printApiKey(projectResult.apiKey);
-    p5.outro("You're all set.");
+    if (!p6.isCancel(wantsMcp) && wantsMcp) {
+      await runMcpSetup(projectResult.apiKey);
+    }
+    p6.outro("You're all set.");
     return 0;
   } catch (error) {
-    if (error instanceof Error) {
-      if (isPlanLimitFailure(error.message)) {
-        printPlanLimitMessage(apiUrl, error.message);
-        return 1;
-      }
-      p5.log.error(`Error: ${error.message}`);
+    const message = error instanceof Error ? error.message : "Unknown setup error";
+    if (isPlanLimitFailure(message)) {
+      printPlanLimitMessage(apiUrl, message);
     } else {
-      p5.log.error("Unknown setup error");
+      p6.log.error(message);
     }
     return 1;
   }
 }
 
 // src/commands/locales.ts
-import * as p8 from "@clack/prompts";
+import * as p9 from "@clack/prompts";
 import chalk7 from "chalk";
 import { config as loadEnv3 } from "dotenv";
+import { readFileSync as readFileSync3 } from "fs";
 
 // src/commands/sync.ts
-import { createHash, randomUUID } from "crypto";
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { randomUUID } from "crypto";
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
 import { join as join3 } from "path";
-import * as p7 from "@clack/prompts";
+import * as p8 from "@clack/prompts";
 import chalk6 from "chalk";
 
 // src/utils/branch.ts
@@ -2167,7 +2359,7 @@ function matchBranchPattern(branch, pattern) {
 }
 
 // src/utils/config.ts
-import * as p6 from "@clack/prompts";
+import * as p7 from "@clack/prompts";
 import { config as loadEnv2 } from "dotenv";
 loadEnv2();
 function extractShortCodeFromApiKey(apiKey) {
@@ -2223,7 +2415,7 @@ async function getMergedConfig(cliOptions, verbose = false, _startDir) {
   };
   const fileConfig = loadVocoderConfig(process.cwd());
   if (!fileConfig) {
-    p6.log.warn(
+    p7.log.warn(
       `No ${highlight("vocoder.config.ts")} found \u2014 run ${highlight("npx @vocoder/cli init")} to generate one.`
     );
   }
@@ -2254,7 +2446,7 @@ async function getMergedConfig(cliOptions, verbose = false, _startDir) {
     excludePattern = fileConfig.exclude;
     configSources.excludePattern = "vocoder.config";
   } else if (envExcludePattern) {
-    excludePattern = envExcludePattern.split(",").map((p14) => p14.trim()).filter(Boolean);
+    excludePattern = envExcludePattern.split(",").map((p15) => p15.trim()).filter(Boolean);
     configSources.excludePattern = "environment";
   } else {
     excludePattern = defaults.excludePattern;
@@ -2311,7 +2503,7 @@ async function getMergedConfig(cliOptions, verbose = false, _startDir) {
       ...maxWaitMs ? [`Max wait:         ${highlight(String(configSources.maxWaitMs))}`] : [],
       `No fallback:      ${highlight(String(configSources.noFallback))}`
     ];
-    p6.note(lines.join("\n"), "Configuration sources");
+    p7.note(lines.join("\n"), "Configuration sources");
   }
   return {
     includePattern,
@@ -2326,10 +2518,6 @@ async function getMergedConfig(cliOptions, verbose = false, _startDir) {
 }
 
 // src/commands/sync.ts
-function computeFingerprint(shortCode, texts) {
-  const sorted = [...texts].sort();
-  return createHash("sha256").update(`${shortCode}:${sorted.join("\0")}`).digest("hex").slice(0, 12);
-}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -2377,15 +2565,6 @@ function getCacheFilePath(projectRoot, fingerprint) {
   return join3(projectRoot, "node_modules", ".vocoder", "cache", `${fingerprint}.json`);
 }
 function buildTranslationData(params) {
-  const textToHash = new Map(params.stringEntries.map((e) => [e.text, e.key]));
-  const hashKeyed = {};
-  for (const [locale, localeMap] of Object.entries(params.translations)) {
-    hashKeyed[locale] = {};
-    for (const [text, translation] of Object.entries(localeMap)) {
-      const hash = textToHash.get(text);
-      if (hash) hashKeyed[locale][hash] = translation;
-    }
-  }
   const locales = {};
   for (const code of [params.sourceLocale, ...params.targetLocales]) {
     const meta = params.localeMetadata?.[code];
@@ -2393,13 +2572,13 @@ function buildTranslationData(params) {
   }
   return {
     config: { sourceLocale: params.sourceLocale, targetLocales: params.targetLocales, locales },
-    translations: hashKeyed,
+    translations: params.translations,
     updatedAt: params.updatedAt
   };
 }
 function readLocalCache(params) {
   const cacheFilePath = getCacheFilePath(params.projectRoot, params.fingerprint);
-  if (!existsSync3(cacheFilePath)) return null;
+  if (!existsSync4(cacheFilePath)) return null;
   try {
     const raw = readFileSync2(cacheFilePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -2458,9 +2637,10 @@ function normalizeTranslations(params) {
   if (!merged[params.sourceLocale]) {
     merged[params.sourceLocale] = {};
   }
-  for (const sourceText of params.sourceStrings) {
-    if (!(sourceText in merged[params.sourceLocale])) {
-      merged[params.sourceLocale][sourceText] = sourceText;
+  for (const entry of params.stringEntries) {
+    if (!entry.text) continue;
+    if (!(entry.key in merged[params.sourceLocale])) {
+      merged[params.sourceLocale][entry.key] = entry.text;
     }
   }
   return merged;
@@ -2536,11 +2716,11 @@ function mergeContext(current, incoming) {
   return Array.from(merged).join(" | ");
 }
 function buildStringEntries(extractedStrings) {
-  const byText = /* @__PURE__ */ new Map();
+  const byKey = /* @__PURE__ */ new Map();
   for (const str of extractedStrings) {
-    const existing = byText.get(str.text);
+    const existing = byKey.get(str.key);
     if (!existing) {
-      byText.set(str.text, {
+      byKey.set(str.key, {
         key: str.key,
         text: str.text,
         ...str.context ? { context: str.context } : {},
@@ -2555,11 +2735,8 @@ function buildStringEntries(extractedStrings) {
     } else if (existing.formality && str.formality && existing.formality !== str.formality) {
       existing.formality = "auto";
     }
-    if (str.key < existing.key) {
-      existing.key = str.key;
-    }
   }
-  return Array.from(byText.values());
+  return Array.from(byKey.values());
 }
 async function fetchApiSnapshot(api, params) {
   const snapshot = await api.getTranslationSnapshot({
@@ -2580,19 +2757,19 @@ async function fetchApiSnapshot(api, params) {
 async function sync(options = {}) {
   const startTime = Date.now();
   const projectRoot = process.cwd();
-  p7.intro(chalk6.bold("Vocoder Sync"));
+  p8.intro(chalk6.bold("Vocoder Sync"));
   const mergedConfig = await getMergedConfig(options, options.verbose);
   if (!mergedConfig.apiKey) {
-    p7.log.warn("No API key found. Run init to get started:");
-    p7.log.info("  npx @vocoder/cli init");
-    p7.log.info("");
-    p7.log.info(
+    p8.log.warn("No API key found. Run init to get started:");
+    p8.log.info("  npx @vocoder/cli init");
+    p8.log.info("");
+    p8.log.info(
       "  Or add your key to .env: VOCODER_API_KEY=vca_..."
     );
-    p7.outro("Run `npx @vocoder/cli init` to set up your project.");
+    p8.outro("Run `npx @vocoder/cli init` to set up your project.");
     return 1;
   }
-  const spinner7 = p7.spinner();
+  const spinner7 = p8.spinner();
   try {
     const branch = detectBranch(options.branch);
     spinner7.start("Loading project configuration");
@@ -2616,17 +2793,17 @@ async function sync(options = {}) {
       includePattern: mergedConfig.includePattern,
       excludePattern: mergedConfig.excludePattern,
       timeout: waitTimeoutMs,
-      ...fileConfig?.appIndustry ? { appIndustry: fileConfig.appIndustry } : {},
+      ...fileConfig?.industry ?? fileConfig?.appIndustry ? { industry: fileConfig?.industry ?? fileConfig?.appIndustry } : {},
       ...fileConfig?.formality ? { formality: fileConfig.formality } : {}
     };
     spinner7.stop(`Branch: ${highlight(branch)}`);
     if (!options.force && !isTargetBranch(branch, config.targetBranches)) {
-      p7.log.warn(
+      p8.log.warn(
         `Skipping translations (${highlight(branch)} is not a target branch)`
       );
-      p7.log.info(`Target branches: ${config.targetBranches.map((b) => highlight(b)).join(", ")}`);
-      p7.log.info("Use --force to translate anyway");
-      p7.outro("");
+      p8.log.info(`Target branches: ${config.targetBranches.map((b) => highlight(b)).join(", ")}`);
+      p8.log.info("Use --force to translate anyway");
+      p8.outro("");
       return 0;
     }
     const patternsDisplay = Array.isArray(config.includePattern) ? config.includePattern.join(", ") : config.includePattern;
@@ -2639,10 +2816,10 @@ async function sync(options = {}) {
     );
     if (extractedStrings.length === 0) {
       spinner7.stop("No translatable strings found");
-      p7.log.warn(
+      p8.log.warn(
         "Make sure you are wrapping translatable strings with Vocoder"
       );
-      p7.outro("");
+      p8.outro("");
       return 0;
     }
     spinner7.stop(
@@ -2653,10 +2830,10 @@ async function sync(options = {}) {
       if (extractedStrings.length > 5) {
         sampleLines.push(`  ... and ${extractedStrings.length - 5} more`);
       }
-      p7.note(sampleLines.join("\n"), "Sample strings");
+      p8.note(sampleLines.join("\n"), "Sample strings");
     }
     if (options.dryRun) {
-      p7.note(
+      p8.note(
         [
           `Strings: ${extractedStrings.length}`,
           `Branch: ${branch}`,
@@ -2667,36 +2844,36 @@ async function sync(options = {}) {
         ].join("\n"),
         "Dry run - would translate"
       );
-      p7.outro("No API calls made.");
+      p8.outro("No API calls made.");
       return 0;
     }
     const repoIdentity = resolveGitRepositoryIdentity();
     if (!repoIdentity && options.verbose) {
-      p7.log.warn(
+      p8.log.warn(
         "Could not detect git remote origin. Sync will continue without repo metadata."
       );
     }
     const commitSha = detectCommitSha() ?? void 0;
     const stringEntries = buildStringEntries(extractedStrings);
-    const sourceStrings = stringEntries.map((entry) => entry.text);
     if (options.verbose && stringEntries.length !== extractedStrings.length) {
-      p7.log.info(
-        `Deduped ${extractedStrings.length} extracted entries into ${stringEntries.length} unique source strings`
+      p8.log.info(
+        `Deduped ${extractedStrings.length} extracted entries into ${stringEntries.length} unique strings`
       );
     }
-    const fingerprint = computeFingerprint(extractShortCodeFromApiKey(localConfig.apiKey), sourceStrings);
+    const sourceKeys = stringEntries.map((entry) => entry.key);
+    const fingerprint = computeFingerprint(extractShortCodeFromApiKey(localConfig.apiKey), sourceKeys);
     if (!options.force) {
       const cacheFile = getCacheFilePath(projectRoot, fingerprint);
-      if (existsSync3(cacheFile)) {
+      if (existsSync4(cacheFile)) {
         if (options.verbose) {
-          p7.log.info(`Cache hit: ${chalk6.dim(cacheFile)} (fingerprint ${highlight(fingerprint)})`);
+          p8.log.info(`Cache hit: ${chalk6.dim(cacheFile)} (fingerprint ${highlight(fingerprint)})`);
         }
         const duration2 = ((Date.now() - startTime) / 1e3).toFixed(1);
-        p7.outro(`Up to date (${duration2}s)`);
+        p8.outro(`Up to date (${duration2}s)`);
         return 0;
       }
       if (options.verbose) {
-        p7.log.info(`No cache for fingerprint ${highlight(fingerprint)} \u2014 will submit to API`);
+        p8.log.info(`No cache for fingerprint ${highlight(fingerprint)} \u2014 will submit to API`);
       }
     }
     spinner7.start("Submitting strings to Vocoder API");
@@ -2709,8 +2886,7 @@ async function sync(options = {}) {
         requestedMaxWaitMs: waitTimeoutMs,
         clientRunId: randomUUID(),
         force: options.force,
-        // Sync appIndustry from vocoder.config.ts to App on every push
-        ...config.appIndustry ? { appIndustry: config.appIndustry } : {}
+        ...config.industry ? { industry: config.industry } : {}
       },
       repoIdentity ? { ...repoIdentity, commitSha } : { commitSha }
     );
@@ -2721,26 +2897,26 @@ async function sync(options = {}) {
       policy: config.syncPolicy
     });
     if (options.verbose) {
-      p7.log.info(`Batch: ${chalk6.dim(batchResponse.batchId)}`);
-      p7.log.info(`Requested mode: ${requestedMode}`);
-      p7.log.info(`Effective mode: ${effectiveMode}`);
-      p7.log.info(`Wait timeout: ${waitTimeoutMs}ms`);
+      p8.log.info(`Batch: ${chalk6.dim(batchResponse.batchId)}`);
+      p8.log.info(`Requested mode: ${requestedMode}`);
+      p8.log.info(`Effective mode: ${effectiveMode}`);
+      p8.log.info(`Wait timeout: ${waitTimeoutMs}ms`);
       if (batchResponse.queueStatus) {
-        p7.log.info(`Queue status: ${batchResponse.queueStatus}`);
+        p8.log.info(`Queue status: ${batchResponse.queueStatus}`);
       }
     }
     if (batchResponse.status === "UP_TO_DATE" && batchResponse.noChanges) {
-      p7.log.success(`Up to date \u2014 ${highlight(batchResponse.totalStrings)} strings, no changes`);
+      p8.log.success(`Up to date \u2014 ${highlight(batchResponse.totalStrings)} strings, no changes`);
     } else if (batchResponse.newStrings === 0) {
       const archivedNote = batchResponse.deletedStrings && batchResponse.deletedStrings > 0 ? `, ${chalk6.yellow(batchResponse.deletedStrings)} archived` : "";
-      p7.log.success(`No new strings \u2014 ${highlight(batchResponse.totalStrings)} total${archivedNote}, using existing translations`);
+      p8.log.success(`No new strings \u2014 ${highlight(batchResponse.totalStrings)} total${archivedNote}, using existing translations`);
     } else {
       const statParts = [`${highlight(batchResponse.newStrings)} new, ${highlight(batchResponse.totalStrings)} total`];
       if (batchResponse.deletedStrings && batchResponse.deletedStrings > 0) {
         statParts.push(`${chalk6.yellow(batchResponse.deletedStrings)} archived`);
       }
       const estTime = batchResponse.estimatedTime ? ` (~${batchResponse.estimatedTime}s)` : "";
-      p7.log.info(`${statParts.join(", ")} \u2192 syncing to ${config.targetLocales.map((l) => highlight(l)).join(", ")}${estTime}`);
+      p8.log.info(`${statParts.join(", ")} \u2192 syncing to ${config.targetLocales.map((l) => highlight(l)).join(", ")}${estTime}`);
     }
     let artifacts = null;
     if (batchResponse.translations) {
@@ -2778,7 +2954,7 @@ async function sync(options = {}) {
         if (effectiveMode === "required") {
           throw waitError;
         }
-        p7.log.warn(`Best-effort wait ended early: ${waitError.message}`);
+        p8.log.warn(`Best-effort wait ended early: ${waitError.message}`);
       }
     }
     if (!artifacts) {
@@ -2811,7 +2987,7 @@ async function sync(options = {}) {
           spinner7.stop("Failed to fetch API snapshot");
           if (options.verbose) {
             const message = error instanceof Error ? error.message : "Unknown snapshot fetch error";
-            p7.log.warn(`Snapshot fetch error: ${message}`);
+            p8.log.warn(`Snapshot fetch error: ${message}`);
           }
         }
       }
@@ -2829,72 +3005,71 @@ async function sync(options = {}) {
     const finalTranslations = normalizeTranslations({
       sourceLocale: config.sourceLocale,
       targetLocales: config.targetLocales,
-      sourceStrings,
+      stringEntries,
       translations: artifacts.translations
     });
     try {
       const data = buildTranslationData({
         sourceLocale: config.sourceLocale,
         targetLocales: config.targetLocales,
-        stringEntries,
         translations: finalTranslations,
         localeMetadata: artifacts.localeMetadata,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
       const cachePath = writeCache({ projectRoot, fingerprint, data });
       if (options.verbose) {
-        p7.log.info(`Cache written: ${highlight(cachePath)}`);
+        p8.log.info(`Cache written: ${highlight(cachePath)}`);
       }
     } catch (error) {
       if (options.verbose) {
         const message = error instanceof Error ? error.message : "Unknown cache write error";
-        p7.log.warn(`Failed to write cache: ${message}`);
+        p8.log.warn(`Failed to write cache: ${message}`);
       }
     }
     if (artifacts.source !== "fresh") {
       const sourceLabel = artifacts.source === "local-cache" ? "local cached snapshot" : "completed API snapshot";
-      p7.log.warn(
+      p8.log.warn(
         `Using ${sourceLabel}. New strings may appear after the background sync completes.`
       );
     }
     const duration = ((Date.now() - startTime) / 1e3).toFixed(1);
-    p7.outro(`Sync complete! (${duration}s)`);
+    p8.outro(`Sync complete! (${duration}s)`);
     return 0;
   } catch (error) {
     spinner7.stop();
     if (error instanceof VocoderAPIError && error.syncPolicyError) {
-      p7.log.error(error.syncPolicyError.message);
+      p8.log.error(error.syncPolicyError.message);
       const guidance = getSyncPolicyErrorGuidance(error.syncPolicyError);
       for (const line of guidance) {
-        p7.log.info(line);
+        p8.log.info(line);
       }
       return 1;
     }
     if (error instanceof VocoderAPIError && error.limitError) {
       const { limitError } = error;
-      p7.log.error(limitError.message);
+      p8.log.error(limitError.message);
       const guidance = getLimitErrorGuidance(limitError);
       for (const line of guidance) {
-        p7.log.info(line);
+        p8.log.info(line);
       }
       return 1;
     }
     if (error instanceof Error) {
-      p7.log.error(error.message);
+      p8.log.error(error.message);
       const isInvalidKey = error.message.toLowerCase().includes("invalid api key") || error instanceof VocoderAPIError && error.status === 401;
       if (isInvalidKey) {
-        p7.log.warn(
+        p8.log.warn(
           "API key rejected \u2014 the project may have been deleted or the key revoked."
         );
-        p7.log.info(
+        p8.log.info(
           "  Run `npx @vocoder/cli init` to create a new project and key."
         );
       } else if (error.message.includes("git branch")) {
-        p7.log.warn("Run from a git repository, or use:");
-        p7.log.info("  vocoder sync --branch main");
+        p8.log.warn("Run from a git repository, or use:");
+        p8.log.info("  vocoder sync --branch main");
       }
       if (options.verbose) {
-        p7.log.info(`Full error: ${error.stack ?? error}`);
+        p8.log.info(`Full error: ${error.stack ?? error}`);
       }
     }
     return 1;
@@ -2903,10 +3078,21 @@ async function sync(options = {}) {
 
 // src/commands/locales.ts
 loadEnv3();
+function readLocalAppId() {
+  const configPath = findExistingConfig(process.cwd());
+  if (!configPath) return void 0;
+  try {
+    const content = readFileSync3(configPath, "utf-8");
+    const match = content.match(/appId:\s*['"]([^'"]+)['"]/);
+    return match?.[1];
+  } catch {
+    return void 0;
+  }
+}
 function getApiConfig(options) {
   const apiKey = process.env.VOCODER_API_KEY;
   if (!apiKey) {
-    p8.log.error(
+    p9.log.error(
       "VOCODER_API_KEY is not set. Run `npx @vocoder/cli init` to set up your project."
     );
     return null;
@@ -2922,19 +3108,19 @@ async function listProjectLocales(options = {}) {
   const api = new VocoderAPI(config);
   try {
     const projectConfig = await api.getAppConfig();
-    p8.log.info(
+    p9.log.info(
       `Source locale:  ${highlight(projectConfig.sourceLocale)}`
     );
     if (projectConfig.targetLocales.length === 0) {
-      p8.log.info("Target locales: (none configured)");
+      p9.log.info("Target locales: (none configured)");
     } else {
-      p8.log.info(
+      p9.log.info(
         `Target locales: ${projectConfig.targetLocales.map((l) => highlight(l)).join(", ")}`
       );
     }
     return 0;
   } catch (error) {
-    p8.log.error(
+    p9.log.error(
       error instanceof Error ? error.message : "Failed to fetch project locales."
     );
     return 1;
@@ -2942,19 +3128,20 @@ async function listProjectLocales(options = {}) {
 }
 async function addLocales(locales, options = {}) {
   if (locales.length === 0) {
-    p8.log.error("No locale codes provided.");
+    p9.log.error("No locale codes provided.");
     return 1;
   }
   const config = getApiConfig(options);
   if (!config) return 1;
   const api = new VocoderAPI(config);
+  const appId = readLocalAppId();
   let lastTargetLocales = [];
   let hadError = false;
   for (const locale of locales) {
-    const spinner7 = p8.spinner();
+    const spinner7 = p9.spinner();
     spinner7.start(`Adding ${locale}\u2026`);
     try {
-      const result = await api.addLocale(locale);
+      const result = await api.addLocale(locale, void 0, appId);
       lastTargetLocales = result.targetLocales;
       spinner7.stop(`Added ${highlight(locale)}`);
     } catch (error) {
@@ -2962,19 +3149,19 @@ async function addLocales(locales, options = {}) {
       hadError = true;
       if (error instanceof VocoderAPIError && error.limitError) {
         const { limitError } = error;
-        p8.log.error(limitError.message);
+        p9.log.error(limitError.message);
         for (const line of getLimitErrorGuidance(limitError)) {
-          p8.log.info(line);
+          p9.log.info(line);
         }
         break;
       }
-      p8.log.error(
+      p9.log.error(
         error instanceof Error ? error.message : "Unknown error"
       );
     }
   }
   if (lastTargetLocales.length > 0) {
-    p8.log.info(
+    p9.log.info(
       `Target locales now: ${lastTargetLocales.map((l) => highlight(l)).join(", ")}`
     );
   }
@@ -2982,35 +3169,36 @@ async function addLocales(locales, options = {}) {
 }
 async function removeLocales(locales, options = {}) {
   if (locales.length === 0) {
-    p8.log.error("No locale codes provided.");
+    p9.log.error("No locale codes provided.");
     return 1;
   }
   const config = getApiConfig(options);
   if (!config) return 1;
   const api = new VocoderAPI(config);
+  const appId = readLocalAppId();
   let lastTargetLocales = [];
   let hadError = false;
   for (const locale of locales) {
-    const spinner7 = p8.spinner();
+    const spinner7 = p9.spinner();
     spinner7.start(`Removing ${locale}\u2026`);
     try {
-      const result = await api.removeLocale(locale);
+      const result = await api.removeLocale(locale, void 0, appId);
       lastTargetLocales = result.targetLocales;
       spinner7.stop(`Removed ${highlight(locale)}`);
     } catch (error) {
       spinner7.stop(`Failed to remove ${chalk7.red(locale)}`);
       hadError = true;
-      p8.log.error(
+      p9.log.error(
         error instanceof Error ? error.message : "Unknown error"
       );
     }
   }
   if (lastTargetLocales.length > 0) {
-    p8.log.info(
+    p9.log.info(
       `Target locales now: ${lastTargetLocales.map((l) => highlight(l)).join(", ")}`
     );
   } else if (!hadError) {
-    p8.log.info("Target locales now: (none configured)");
+    p9.log.info("Target locales now: (none configured)");
   }
   return hadError ? 1 : 0;
 }
@@ -3020,14 +3208,14 @@ async function listSupportedLocales(options = {}) {
   const api = new VocoderAPI(config);
   try {
     const result = await api.listLocales(config.apiKey);
-    p8.log.info(chalk7.bold("Source locales:"));
+    p9.log.info(chalk7.bold("Source locales:"));
     printLocaleTable(result.sourceLocales);
-    p8.log.info("");
-    p8.log.info(chalk7.bold("Target locales:"));
+    p9.log.info("");
+    p9.log.info(chalk7.bold("Target locales:"));
     printLocaleTable(result.targetLocales);
     return 0;
   } catch (error) {
-    p8.log.error(
+    p9.log.error(
       error instanceof Error ? error.message : "Failed to fetch supported locales."
     );
     return 1;
@@ -3036,16 +3224,16 @@ async function listSupportedLocales(options = {}) {
 function printLocaleTable(locales) {
   for (const locale of locales) {
     const native = locale.nativeName && locale.nativeName !== locale.name ? ` (${locale.nativeName})` : "";
-    p8.log.info(`  ${highlight(locale.code.padEnd(10))} ${locale.name}${native}`);
+    p9.log.info(`  ${highlight(locale.code.padEnd(10))} ${locale.name}${native}`);
   }
 }
 
 // src/commands/logout.ts
-import * as p9 from "@clack/prompts";
+import * as p10 from "@clack/prompts";
 async function logout(options = {}) {
   const stored = readAuthData();
   if (!stored) {
-    p9.log.info("Not currently authenticated.");
+    p10.log.info("Not currently authenticated.");
     return 0;
   }
   const apiUrl = options.apiUrl ?? stored.apiUrl ?? "https://vocoder.app";
@@ -3055,19 +3243,19 @@ async function logout(options = {}) {
   } catch {
   }
   clearAuthData();
-  p9.log.success(`Logged out (was ${stored.email})`);
+  p10.log.success(`Logged out (was ${stored.email})`);
   return 0;
 }
 
 // src/commands/app-config.ts
-import * as p10 from "@clack/prompts";
+import * as p11 from "@clack/prompts";
 import chalk8 from "chalk";
 import { config as loadEnv4 } from "dotenv";
 loadEnv4();
 async function appConfig(options = {}) {
   const apiKey = process.env.VOCODER_API_KEY;
   if (!apiKey) {
-    p10.log.error(
+    p11.log.error(
       "VOCODER_API_KEY is not set. Run `npx @vocoder/cli init` to set up your project."
     );
     return 1;
@@ -3089,10 +3277,10 @@ async function appConfig(options = {}) {
       `  Non-blocking mode: ${highlight(config.syncPolicy.nonBlockingMode)}`,
       `  Max wait:          ${highlight(String(config.syncPolicy.defaultMaxWaitMs))} ms`
     ];
-    p10.note(lines.join("\n"), `${config.projectName} \u2014 app config`);
+    p11.note(lines.join("\n"), `${config.projectName} \u2014 app config`);
     return 0;
   } catch (error) {
-    p10.log.error(
+    p11.log.error(
       error instanceof Error ? error.message : "Failed to fetch project config."
     );
     return 1;
@@ -3102,13 +3290,13 @@ async function appConfig(options = {}) {
 // src/commands/translations.ts
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync4 } from "fs";
 import { join as join4 } from "path";
-import * as p11 from "@clack/prompts";
+import * as p12 from "@clack/prompts";
 import { config as loadEnv5 } from "dotenv";
 loadEnv5();
 async function getTranslations(options = {}) {
   const apiKey = process.env.VOCODER_API_KEY;
   if (!apiKey) {
-    p11.log.error(
+    p12.log.error(
       "VOCODER_API_KEY is not set. Run `npx @vocoder/cli init` to set up your project."
     );
     return 1;
@@ -3119,25 +3307,25 @@ async function getTranslations(options = {}) {
   try {
     branch = detectBranch(options.branch);
   } catch (error) {
-    p11.log.error(
+    p12.log.error(
       error instanceof Error ? error.message : "Failed to detect branch."
     );
     return 1;
   }
-  const spinner7 = p11.spinner();
+  const spinner7 = p12.spinner();
   spinner7.start(`Fetching translations for ${highlight(branch)}\u2026`);
   try {
     const projectConfig = await api.getAppConfig();
     const targetLocales = options.locale ? [options.locale] : projectConfig.targetLocales;
     if (targetLocales.length === 0) {
       spinner7.stop("No target locales configured.");
-      p11.log.info("Add target locales with `vocoder locales add <code>`.");
+      p12.log.info("Add target locales with `vocoder locales add <code>`.");
       return 1;
     }
     const snapshot = await api.getTranslationSnapshot({ branch, targetLocales });
     spinner7.stop(`Fetched translations for ${highlight(branch)}`);
     if (snapshot.status === "NOT_FOUND") {
-      p11.log.warn(
+      p12.log.warn(
         `No translation snapshot found for branch "${branch}". Run \`vocoder sync\` to generate one.`
       );
       return 1;
@@ -3152,7 +3340,7 @@ async function getTranslations(options = {}) {
     return 0;
   } catch (error) {
     spinner7.stop("Failed to fetch translations.");
-    p11.log.error(
+    p12.log.error(
       error instanceof Error ? error.message : "Unknown error."
     );
     return 1;
@@ -3163,19 +3351,19 @@ function writeLocaleFiles(translations, outputDir) {
   for (const [locale, strings] of Object.entries(translations)) {
     const filePath = join4(outputDir, `${locale}.json`);
     writeFileSync4(filePath, JSON.stringify(strings, null, 2) + "\n", "utf-8");
-    p11.log.success(`Wrote ${highlight(filePath)}`);
+    p12.log.success(`Wrote ${highlight(filePath)}`);
   }
 }
 
 // src/commands/create-app.ts
-import * as p12 from "@clack/prompts";
+import * as p13 from "@clack/prompts";
 import chalk9 from "chalk";
 import { config as loadEnv6 } from "dotenv";
 loadEnv6();
 async function createApp(options) {
   const authData = readAuthData();
   if (!authData) {
-    p12.log.error(
+    p13.log.error(
       "Not logged in. Run `npx @vocoder/cli init` to authenticate first."
     );
     return 1;
@@ -3194,18 +3382,18 @@ async function createApp(options) {
         appDir = identity.repoAppDir;
       }
     } else {
-      p12.log.warn(
+      p13.log.warn(
         "Could not detect a git remote. The project will be created without repo binding \u2014 sync-on-push will not function until a repository is connected via the Vocoder dashboard."
       );
     }
   }
   const targetLocales = options.targetLocales ? options.targetLocales.split(",").map((l) => l.trim()).filter(Boolean) : [];
   const targetBranches = options.targetBranches ? options.targetBranches.split(",").map((b) => b.trim()).filter(Boolean) : ["main"];
-  const spinner7 = p12.spinner();
+  const spinner7 = p13.spinner();
   spinner7.start(`Creating app "${options.name}"\u2026`);
   try {
     const result = await api.createProject(authData.token, {
-      organizationId: options.workspace,
+      organizationId: options.organization,
       name: options.name,
       sourceLocale: options.sourceLocale,
       targetLocales,
@@ -3224,9 +3412,9 @@ async function createApp(options) {
       `Add this to your .env file:`,
       `  ${chalk9.bold("VOCODER_API_KEY")}=${highlight(result.apiKey)}`
     ];
-    p12.note(lines.join("\n"), "Project created");
+    p13.note(lines.join("\n"), "Project created");
     if (!result.repositoryBound && repoCanonical) {
-      p12.log.warn(
+      p13.log.warn(
         `Repository "${repoCanonical}" was not automatically connected. Ensure your GitHub App installation covers this repository.`
       );
     }
@@ -3235,13 +3423,13 @@ async function createApp(options) {
     spinner7.stop("Failed to create project.");
     if (error instanceof VocoderAPIError && error.limitError) {
       const { limitError } = error;
-      p12.log.error(limitError.message);
+      p13.log.error(limitError.message);
       for (const line of getLimitErrorGuidance(limitError)) {
-        p12.log.info(line);
+        p13.log.info(line);
       }
       return 1;
     }
-    p12.log.error(
+    p13.log.error(
       error instanceof Error ? error.message : "Unknown error."
     );
     return 1;
@@ -3249,26 +3437,26 @@ async function createApp(options) {
 }
 
 // src/commands/whoami.ts
-import * as p13 from "@clack/prompts";
+import * as p14 from "@clack/prompts";
 import chalk10 from "chalk";
 async function whoami(options = {}) {
   const stored = readAuthData();
   if (!stored) {
-    p13.log.info("Not logged in. Run `vocoder init` to authenticate.");
+    p14.log.info("Not logged in. Run `vocoder init` to authenticate.");
     return 1;
   }
   const apiUrl = options.apiUrl ?? stored.apiUrl ?? "https://vocoder.app";
   const api = new VocoderAPI({ apiUrl, apiKey: "" });
   try {
     const info2 = await api.getCliUserInfo(stored.token);
-    p13.log.info(`Logged in as ${chalk10.bold(info2.email)}`);
+    p14.log.info(`Logged in as ${chalk10.bold(info2.email)}`);
     if (info2.name) {
-      p13.log.info(`Name: ${info2.name}`);
+      p14.log.info(`Name: ${info2.name}`);
     }
-    p13.log.info(`API: ${apiUrl}`);
+    p14.log.info(`API: ${apiUrl}`);
     return 0;
   } catch {
-    p13.log.error(
+    p14.log.error(
       "Stored credentials are invalid or expired. Run `vocoder init` to re-authenticate."
     );
     return 1;
@@ -3310,7 +3498,7 @@ localesCmd.command("remove <codes...>").description("Remove one or more target l
 localesCmd.command("supported").description("List all locales supported by Vocoder").option("--api-url <url>", "Override Vocoder API URL").action((options) => runCommand(listSupportedLocales, options));
 program.command("project").description("Show current app configuration").option("--api-url <url>", "Override Vocoder API URL").action((options) => runCommand(appConfig, options));
 program.command("translations").description("Download the current translation snapshot").option("--branch <branch>", "Git branch (auto-detected if omitted)").option("--locale <locale>", "Fetch a specific locale only").option("--output <dir>", "Write locale JSON files to this directory").option("--api-url <url>", "Override Vocoder API URL").action((options) => runCommand(getTranslations, options));
-program.command("create-app").description("Create a new Vocoder app (requires prior `vocoder init`)").requiredOption("--name <name>", "App display name").requiredOption("--source-locale <code>", "Source language BCP 47 code (e.g. en)").requiredOption("--workspace <org-id>", "Workspace organization ID").option(
+program.command("create-app").description("Create a new Vocoder app (requires prior `vocoder init`)").requiredOption("--name <name>", "App display name").requiredOption("--source-locale <code>", "Source language BCP 47 code (e.g. en)").requiredOption("--organization <org-id>", "Organization ID").option(
   "--target-locales <codes>",
   "Comma-separated target locale codes (e.g. fr,de,pt-BR)"
 ).option(
@@ -3329,7 +3517,7 @@ program.command("create-app").description("Create a new Vocoder app (requires pr
     sourceLocale: options.sourceLocale,
     targetLocales: options.targetLocales,
     targetBranches: options.targetBranches,
-    workspace: options.workspace
+    organization: options.organization
   };
   return runCommand(createApp, translated);
 });