@tostudy-ai/cli 0.16.8 → 0.16.10

package/dist/cli.js

@@ -1440,7 +1440,8 @@ async function saveSession(session, configDir) {
     userName: session.userName,
     expiresAt: session.expiresAt,
     apiUrl: session.apiUrl,
-    sessionId: session.sessionId
+    sessionId: session.sessionId,
+    ...session.locale ? { locale: session.locale } : {}
   };
   fs2.writeFileSync(path3.join(dir, "config.json"), JSON.stringify(stored, null, 2), {
     mode: 384
@@ -1460,7 +1461,8 @@ async function getSession(configDir) {
     userName: stored.userName,
     expiresAt: stored.expiresAt,
     apiUrl: stored.apiUrl,
-    sessionId: stored.sessionId
+    sessionId: stored.sessionId,
+    ...stored.locale ? { locale: stored.locale } : {}
   };
 }
 async function clearSessionArtifacts(configDir) {
@@ -2645,10 +2647,20 @@ var init_login = __esm({
           const body = await res.json();
           error(body.error ?? "Falha na autentica\xE7\xE3o");
         }
-        const { token, refreshToken, sessionId, userId, userName, expiresAt } = await res.json();
-        await saveSession({ token, refreshToken, sessionId, userId, userName, expiresAt, apiUrl });
+        const { token, refreshToken, sessionId, userId, userName, expiresAt, locale } = await res.json();
+        await saveSession({
+          token,
+          refreshToken,
+          sessionId,
+          userId,
+          userName,
+          expiresAt,
+          apiUrl,
+          ...locale === "pt-BR" || locale === "en-US" ? { locale } : {}
+        });
         console.log(`
   \u2713 Logado como ${userName}`);
+        const installedFiles = [];
         try {
           const { detectIDEs: detectIDEs2 } = await Promise.resolve().then(() => (init_ide_detector(), ide_detector_exports));
           const { installUniversalCommand: installUniversalCommand2 } = await Promise.resolve().then(() => (init_instruction_files(), instruction_files_exports));
@@ -2664,7 +2676,6 @@ var init_login = __esm({
           }
           const cwd = process.cwd();
           const home = homedir2();
-          const installedFiles = [];
           for (const runtime of RUNTIMES2) {
             if (runtime.writeUniversal && runtime.detect(home, cwd)) {
               installedFiles.push(...installUniversalCommand2(runtime.id, cwd));
@@ -2692,7 +2703,16 @@ var init_login = __esm({
         }
         console.log("");
         console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-        console.log("  Pronto! Abra seu IDE e digite /tostudy");
+        console.log("  Pronto! Para estudar no terminal:");
+        console.log("");
+        console.log("    mkdir ~/meus-cursos && cd ~/meus-cursos");
+        console.log("    tostudy courses        lista seus cursos");
+        console.log("    tostudy select <n>     ativa um curso nesta pasta");
+        console.log("    tostudy start          abre a primeira aula");
+        if (installedFiles.length > 0) {
+          console.log("");
+          console.log("  Ou, na sua IDE, digite /tostudy.");
+        }
         console.log("");
       } catch (err) {
         const msg = err instanceof Error ? err.message : "Login falhou";
@@ -2780,6 +2800,7 @@ var init_errors_pt_br = __esm({
       insufficientCredits: "\u274C Voc\xEA est\xE1 sem cr\xE9ditos. Cada resposta do tutor de IA consome cr\xE9ditos para cobrir o processamento. Recarregue em https://tostudy.ai/student/credits para continuar de onde parou.\n",
       workspaceRefusedAtHome: "N\xE3o d\xE1 para configurar o estudo direto na sua pasta pessoal.\nCrie uma pasta para o curso e entre nela antes de continuar:\n\n  mkdir ~/meus-cursos && cd ~/meus-cursos\n",
       courseArchived: "Este curso foi arquivado e est\xE1 dispon\xEDvel somente para leitura.\nUse `tostudy lesson` para revisar o conte\xFAdo j\xE1 estudado.\n",
+      noActiveCourse: "Nenhum curso ativo nesta pasta.\nVeja seus cursos com `tostudy courses` e ative um com `tostudy select <n>`.\n",
       enrollmentNotEntitled: "\u{1F6AB} Sua matr\xEDcula neste curso n\xE3o est\xE1 mais ativa (reembolso, cancelamento ou preview expirado).\nPara voltar a estudar, adquira o curso novamente em https://tostudy.ai.\n"
     };
   }
@@ -2801,12 +2822,25 @@ var init_errors_en_us = __esm({
       insufficientCredits: "\u274C You're out of credits. Every reply from the AI tutor uses credits to cover processing. Top up at https://tostudy.ai/student/credits to continue from where you stopped.\n",
       workspaceRefusedAtHome: "Study can't be set up directly in your home folder.\nCreate a folder for the course and switch into it first:\n\n  mkdir ~/my-courses && cd ~/my-courses\n",
       courseArchived: "This course has been archived and is available for reading only.\nUse `tostudy lesson` to review the content you've already studied.\n",
+      noActiveCourse: "No active course in this folder.\nList your courses with `tostudy courses` and activate one with `tostudy select <n>`.\n",
       enrollmentNotEntitled: "\u{1F6AB} Your enrollment in this course is no longer active (refund, cancellation, or expired preview).\nTo study again, purchase the course at https://tostudy.ai.\n"
     };
   }
 });
 
 // src/errors/index.ts
+import fs6 from "node:fs";
+import path7 from "node:path";
+function readStoredLocale() {
+  try {
+    const p = path7.join(getConfigDir(), "config.json");
+    if (!fs6.existsSync(p)) return null;
+    const { locale } = JSON.parse(fs6.readFileSync(p, "utf-8"));
+    return locale === "pt-BR" || locale === "en-US" ? locale : null;
+  } catch {
+    return null;
+  }
+}
 function resolveLocale() {
   if (_cachedLocale !== null) return _cachedLocale;
   const argv = process.argv;
@@ -2818,6 +2852,11 @@ function resolveLocale() {
       return val;
     }
   }
+  const stored = readStoredLocale();
+  if (stored) {
+    _cachedLocale = stored;
+    return stored;
+  }
   const lang = (process.env["LANG"] ?? "").toLowerCase();
   if (lang.startsWith("en")) {
     _cachedLocale = "en-US";
@@ -2849,6 +2888,7 @@ var BUNDLES, _cachedLocale;
 var init_errors = __esm({
   "src/errors/index.ts"() {
     "use strict";
+    init_config_dir();
     init_errors_pt_br();
     init_errors_en_us();
     BUNDLES = {
@@ -2862,12 +2902,12 @@ var init_errors = __esm({
 // src/workspace/workspace-marker.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, readFileSync as readFileSync2 } from "node:fs";
 import os4 from "node:os";
-import path7 from "node:path";
+import path8 from "node:path";
 function resolveMarkerPath(workspacePath) {
-  if (path7.basename(workspacePath) === ".tostudy") {
-    return path7.join(workspacePath, "workspace.json");
+  if (path8.basename(workspacePath) === ".tostudy") {
+    return path8.join(workspacePath, "workspace.json");
   }
-  return path7.join(workspacePath, ".tostudy", "workspace.json");
+  return path8.join(workspacePath, ".tostudy", "workspace.json");
 }
 async function readWorkspaceMarker(workspacePath) {
   const filePath = resolveMarkerPath(workspacePath);
@@ -2885,13 +2925,13 @@ async function readWorkspaceMarker(workspacePath) {
   }
 }
 async function writeWorkspaceMarker(workspacePath, input2, options = {}) {
-  const homeDir = path7.resolve(options.homeDir ?? os4.homedir());
-  const resolvedWorkspace = path7.resolve(workspacePath);
-  if (resolvedWorkspace === homeDir || homeDir.startsWith(resolvedWorkspace + path7.sep)) {
+  const homeDir = path8.resolve(options.homeDir ?? os4.homedir());
+  const resolvedWorkspace = path8.resolve(workspacePath);
+  if (resolvedWorkspace === homeDir || homeDir.startsWith(resolvedWorkspace + path8.sep)) {
     throw new Error(getErrors().workspaceRefusedAtHome);
   }
   const filePath = resolveMarkerPath(workspacePath);
-  const dir = path7.dirname(filePath);
+  const dir = path8.dirname(filePath);
   if (!existsSync3(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
@@ -2928,7 +2968,7 @@ __export(workspace_state_exports, {
 });
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import os5 from "node:os";
-import path8 from "node:path";
+import path9 from "node:path";
 async function readWorkspaceState(workspacePath) {
   const marker = await readWorkspaceMarker(workspacePath);
   if (!marker) return null;
@@ -2957,13 +2997,13 @@ async function readWorkspaceState(workspacePath) {
   }
 }
 async function findWorkspaceState(startCwd = process.cwd(), homeDir = os5.homedir()) {
-  const home = path8.resolve(homeDir);
-  let current = path8.resolve(startCwd);
+  const home = path9.resolve(homeDir);
+  let current = path9.resolve(startCwd);
   while (true) {
     if (current === home) return null;
     const state = await readWorkspaceState(current);
     if (state) return { state, workspacePath: current };
-    const parent = path8.dirname(current);
+    const parent = path9.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -3032,7 +3072,7 @@ __export(course_state_exports, {
   setCourseWorkspacePath: () => setCourseWorkspacePath,
   setLastInitCourseId: () => setLastInitCourseId
 });
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 async function getCourseOnboardingState(courseId, configDir) {
   const state = readCourseOnboardingState(configDir);
   return state[courseId] ?? null;
@@ -3054,7 +3094,7 @@ async function saveCourseLearnerProfile(course, learnerProfile, artifacts, confi
 }
 async function clearAllCourseOnboarding(configDir) {
   const onboardingPath = getCourseOnboardingPath(configDir);
-  if (fs6.existsSync(onboardingPath)) fs6.unlinkSync(onboardingPath);
+  if (fs7.existsSync(onboardingPath)) fs7.unlinkSync(onboardingPath);
 }
 var init_course_state = __esm({
   "src/onboarding/course-state.ts"() {
@@ -3097,14 +3137,14 @@ __export(resolve_exports, {
   resolveVaultPath: () => resolveVaultPath,
   resolveWorkspace: () => resolveWorkspace
 });
-import fs7 from "node:fs/promises";
-import path9 from "node:path";
+import fs8 from "node:fs/promises";
+import path10 from "node:path";
 import os6 from "node:os";
 async function resolveWorkspace(courseTitle, basePath = DEFAULT_BASE) {
   const slug = courseSlug(courseTitle);
-  const candidate = path9.join(basePath, slug);
+  const candidate = path10.join(basePath, slug);
   try {
-    await fs7.access(path9.join(candidate, ".ana-config.json"));
+    await fs8.access(path10.join(candidate, ".ana-config.json"));
     return { found: true, workspacePath: candidate, source: "default" };
   } catch {
     return { found: false, workspacePath: null };
@@ -3114,49 +3154,49 @@ async function isCwdWorkspace(cwd = process.cwd()) {
   return await resolveCwdWorkspacePath(cwd) !== null;
 }
 async function resolveCwdWorkspacePath(cwd = process.cwd()) {
-  const tostudyDir = path9.join(cwd, ".tostudy");
+  const tostudyDir = path10.join(cwd, ".tostudy");
   try {
-    const stat = await fs7.stat(tostudyDir);
+    const stat = await fs8.stat(tostudyDir);
     if (stat.isDirectory()) return tostudyDir;
   } catch {
   }
   try {
-    await fs7.access(path9.join(cwd, ".ana-config.json"));
+    await fs8.access(path10.join(cwd, ".ana-config.json"));
     return cwd;
   } catch {
     return null;
   }
 }
 async function findCwdWorkspaceUpwards(startCwd = process.cwd(), homeDir = os6.homedir()) {
-  const home = path9.resolve(homeDir);
-  let current = path9.resolve(startCwd);
+  const home = path10.resolve(homeDir);
+  let current = path10.resolve(startCwd);
   while (true) {
     if (current === home) return null;
     const direct = await resolveCwdWorkspacePath(current);
     if (direct) return direct;
-    const parent = path9.dirname(current);
+    const parent = path10.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function resolveVaultPath(workspacePath, slug) {
-  const base = path9.basename(workspacePath) === ".tostudy" ? path9.dirname(workspacePath) : workspacePath;
-  return path9.join(base, `vault-${slug}`);
+  const base = path10.basename(workspacePath) === ".tostudy" ? path10.dirname(workspacePath) : workspacePath;
+  return path10.join(base, `vault-${slug}`);
 }
 function cliWorkspacePaths(workspacePath, courseTitle) {
-  const base = path9.basename(workspacePath) === ".tostudy" ? path9.dirname(workspacePath) : workspacePath;
+  const base = path10.basename(workspacePath) === ".tostudy" ? path10.dirname(workspacePath) : workspacePath;
   return { workspace: base, vault: resolveVaultPath(workspacePath, courseSlug(courseTitle)) };
 }
 async function findExistingVault(workspacePath, slug) {
   const slugged = resolveVaultPath(workspacePath, slug);
   try {
-    await fs7.access(path9.join(slugged, ".ana-vault.json"));
+    await fs8.access(path10.join(slugged, ".ana-vault.json"));
     return slugged;
   } catch {
   }
-  const legacy = path9.join(workspacePath, "vault");
+  const legacy = path10.join(workspacePath, "vault");
   try {
-    await fs7.access(path9.join(legacy, ".ana-vault.json"));
+    await fs8.access(path10.join(legacy, ".ana-vault.json"));
     return legacy;
   } catch {
     return null;
@@ -3169,7 +3209,7 @@ async function resolveEffectiveWorkspace(courseTitle, storedPath, cwd = process.
   }
   if (storedPath) {
     try {
-      await fs7.access(path9.join(storedPath, ".ana-config.json"));
+      await fs8.access(path10.join(storedPath, ".ana-config.json"));
       return { found: true, workspacePath: storedPath, source: "stored" };
     } catch {
     }
@@ -3190,7 +3230,7 @@ var init_resolve = __esm({
   "src/workspace/resolve.ts"() {
     "use strict";
     init_slug();
-    DEFAULT_BASE = path9.join(os6.homedir(), "study");
+    DEFAULT_BASE = path10.join(os6.homedir(), "study");
     courseSlug = slugify;
     resolveActiveCourseWithOverride = resolveActiveCourseFromWorkspace;
   }
@@ -3246,7 +3286,7 @@ async function requireActiveCourse() {
     await primeWorkspaceTokenPaths(result.state);
     return result.state;
   }
-  process.stderr.write("Erro: Nenhum workspace configurado. Rode: tostudy setup\n");
+  process.stderr.write(`Erro: ${getErrors().noActiveCourse}`);
   process.exit(3);
 }
 async function primeWorkspaceTokenPaths(state) {
@@ -3272,6 +3312,7 @@ var init_guards = __esm({
   "src/auth/guards.ts"() {
     "use strict";
     init_session_store();
+    init_errors();
   }
 });
 
@@ -3320,7 +3361,9 @@ var init_mcp_setup = __esm({
 import { Command as Command3 } from "commander";
 async function runSetup(_opts, deps = defaultDeps) {
   deps.log("\n  \u26A0\uFE0F  `tostudy setup` foi incorporado ao `tostudy login`.");
-  deps.log("  Rode `tostudy login` para configurar seu ambiente.\n");
+  deps.log(
+    "  Rode `tostudy login`, depois `tostudy courses` e `tostudy select <n>` para estudar no terminal.\n"
+  );
 }
 async function runSetupMcpSubcommand() {
   console.log("\n  ToStudy MCP Setup\n  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
@@ -3383,7 +3426,7 @@ var CLI_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    CLI_VERSION = true ? "0.16.8" : "0.7.1";
+    CLI_VERSION = true ? "0.16.9" : "0.7.1";
   }
 });
 
@@ -3397,13 +3440,13 @@ __export(update_checker_exports, {
   readCache: () => readCache,
   writeCache: () => writeCache
 });
-import fs8 from "node:fs";
-import path10 from "node:path";
+import fs9 from "node:fs";
+import path11 from "node:path";
 function readCache(configDir) {
   try {
-    const p = path10.join(configDir ?? getConfigDir(), CACHE_FILE);
-    if (!fs8.existsSync(p)) return null;
-    return JSON.parse(fs8.readFileSync(p, "utf-8"));
+    const p = path11.join(configDir ?? getConfigDir(), CACHE_FILE);
+    if (!fs9.existsSync(p)) return null;
+    return JSON.parse(fs9.readFileSync(p, "utf-8"));
   } catch {
     return null;
   }
@@ -3411,8 +3454,8 @@ function readCache(configDir) {
 function writeCache(cache, configDir) {
   try {
     const dir = configDir ?? getConfigDir();
-    fs8.mkdirSync(dir, { recursive: true });
-    fs8.writeFileSync(path10.join(dir, CACHE_FILE), JSON.stringify(cache));
+    fs9.mkdirSync(dir, { recursive: true });
+    fs9.writeFileSync(path11.join(dir, CACHE_FILE), JSON.stringify(cache));
   } catch {
   }
 }
@@ -3482,17 +3525,17 @@ var init_update_checker = __esm({
 });
 
 // src/learner-brief/cache.ts
-import fs9 from "node:fs";
-import path11 from "node:path";
+import fs10 from "node:fs";
+import path12 from "node:path";
 function resolveCachePath(configDir) {
-  return path11.join(configDir, "student-brief.json");
+  return path12.join(configDir, "student-brief.json");
 }
 async function readBriefCache(configDir) {
   const dir = configDir ?? getConfigDir();
   const p = resolveCachePath(dir);
-  if (!fs9.existsSync(p)) return null;
+  if (!fs10.existsSync(p)) return null;
   try {
-    const raw = fs9.readFileSync(p, "utf-8");
+    const raw = fs10.readFileSync(p, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -3500,8 +3543,8 @@ async function readBriefCache(configDir) {
 }
 async function writeBriefCache(configDir, cache) {
   const dir = configDir ?? getConfigDir();
-  fs9.mkdirSync(dir, { recursive: true });
-  fs9.writeFileSync(resolveCachePath(dir), JSON.stringify(cache, null, 2), { mode: 384 });
+  fs10.mkdirSync(dir, { recursive: true });
+  fs10.writeFileSync(resolveCachePath(dir), JSON.stringify(cache, null, 2), { mode: 384 });
 }
 var init_cache = __esm({
   "src/learner-brief/cache.ts"() {
@@ -3511,23 +3554,23 @@ var init_cache = __esm({
 });
 
 // src/tutor-persona/cache.ts
-import fs10 from "node:fs";
-import path12 from "node:path";
+import fs11 from "node:fs";
+import path13 from "node:path";
 function resolveCachePath2(configDir) {
-  return path12.join(configDir, "tutor-personalities.json");
+  return path13.join(configDir, "tutor-personalities.json");
 }
 function readAll(configDir) {
   const p = resolveCachePath2(configDir);
-  if (!fs10.existsSync(p)) return {};
+  if (!fs11.existsSync(p)) return {};
   try {
-    return JSON.parse(fs10.readFileSync(p, "utf-8"));
+    return JSON.parse(fs11.readFileSync(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeAll(configDir, cache) {
-  fs10.mkdirSync(configDir, { recursive: true });
-  fs10.writeFileSync(resolveCachePath2(configDir), JSON.stringify(cache, null, 2), { mode: 384 });
+  fs11.mkdirSync(configDir, { recursive: true });
+  fs11.writeFileSync(resolveCachePath2(configDir), JSON.stringify(cache, null, 2), { mode: 384 });
 }
 async function readPersonaCacheForCourse(configDir, courseId) {
   const dir = configDir ?? getConfigDir();
@@ -4770,7 +4813,7 @@ var init_next = __esm({
 
 // src/commands/lesson.ts
 import { Command as Command11 } from "commander";
-import path13 from "node:path";
+import path14 from "node:path";
 function adjustTimeEstimate(type, baseMinutes) {
   if (type === "exercise") return Math.max(baseMinutes, 30);
   return baseMinutes;
@@ -4783,7 +4826,7 @@ function formatLessonContent(data, workspacePath, courseTitle) {
   const isPractical = data.type === "exercise" || isCheckpoint(data.title);
   const lines = [`\u2501\u2501\u2501 Li\xE7\xE3o: ${data.title} \u2501\u2501\u2501`];
   if (isPractical && workspacePath) {
-    const base = path13.basename(workspacePath) === ".tostudy" ? path13.dirname(workspacePath) : workspacePath;
+    const base = path14.basename(workspacePath) === ".tostudy" ? path14.dirname(workspacePath) : workspacePath;
     const slug = courseSlug(courseTitle);
     const vaultPath = resolveVaultPath(workspacePath, slug);
     lines.push(
@@ -5327,10 +5370,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path24) {
-  if (!path24)
+function getElementAtPath(obj, path25) {
+  if (!path25)
     return obj;
-  return path24.reduce((acc, key) => acc?.[key], obj);
+  return path25.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -5642,11 +5685,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path24, issues) {
+function prefixIssues(path25, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path24);
+    iss.path.unshift(path25);
     return iss;
   });
 }
@@ -5888,7 +5931,7 @@ function formatError(error49, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error49, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error50, path24 = []) => {
+  const processError = (error50, path25 = []) => {
     var _a2, _b;
     for (const issue2 of error50.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -5898,7 +5941,7 @@ function treeifyError(error49, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path24, ...issue2.path];
+        const fullpath = [...path25, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -5930,8 +5973,8 @@ function treeifyError(error49, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path24 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path24) {
+  const path25 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path25) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -18625,13 +18668,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path24 = ref.slice(1).split("/").filter(Boolean);
-  if (path24.length === 0) {
+  const path25 = ref.slice(1).split("/").filter(Boolean);
+  if (path25.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path24[0] === defsKey) {
-    const key = path24[1];
+  if (path25[0] === defsKey) {
+    const key = path25[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -19963,8 +20006,8 @@ var init_init_template = __esm({
 });
 
 // src/commands/validate.ts
-import fs11 from "node:fs";
-import path14 from "node:path";
+import fs12 from "node:fs";
+import path15 from "node:path";
 import { Command as Command14 } from "commander";
 var logger16, validateCommand;
 var init_validate = __esm({
@@ -20008,21 +20051,21 @@ var init_validate = __esm({
         }
         let solution;
         if (opts.stdin) {
-          solution = fs11.readFileSync("/dev/stdin", "utf-8");
+          solution = fs12.readFileSync("/dev/stdin", "utf-8");
         } else if (file2) {
-          if (!fs11.existsSync(file2)) {
+          if (!fs12.existsSync(file2)) {
             if (opts.json)
               jsonError("file_not_found", { message: `Arquivo n\xE3o encontrado: ${file2}` });
             error(`Arquivo n\xE3o encontrado: ${file2}`);
           }
-          solution = fs11.readFileSync(file2, "utf-8");
+          solution = fs12.readFileSync(file2, "utf-8");
         } else {
           if (opts.json)
             jsonError("no_solution_provided", { message: "Forne\xE7a um arquivo ou use --stdin" });
           error("Forne\xE7a um arquivo ou use --stdin.\n\nExemplo: tostudy validate resposta.md");
         }
         if (file2 && activeCourse.courseTags?.length) {
-          const ext = path14.extname(file2).toLowerCase();
+          const ext = path15.extname(file2).toLowerCase();
           const LANG_EXTENSIONS = {
             ".html": ["html", "html5"],
             ".css": ["css"],
@@ -20490,14 +20533,14 @@ var init_init = __esm({
 });
 
 // ../../packages/tostudy-core/src/workspace/setup-workspace.ts
-import fs12 from "node:fs/promises";
-import path15 from "node:path";
+import fs13 from "node:fs/promises";
+import path16 from "node:path";
 async function setupWorkspace(input2) {
-  const workspacePath = path15.join(input2.basePath, input2.courseSlug);
+  const workspacePath = path16.join(input2.basePath, input2.courseSlug);
   for (const dir of WORKSPACE_DIRS) {
-    await fs12.mkdir(path15.join(workspacePath, dir), { recursive: true });
+    await fs13.mkdir(path16.join(workspacePath, dir), { recursive: true });
   }
-  const configPath = path15.join(workspacePath, ".ana-config.json");
+  const configPath = path16.join(workspacePath, ".ana-config.json");
   const config2 = {
     courseId: input2.courseId,
     courseSlug: input2.courseSlug,
@@ -20507,7 +20550,7 @@ async function setupWorkspace(input2) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await fs12.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  await fs13.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
   const readme = [
     `# ${input2.courseName}`,
     "",
@@ -20532,7 +20575,7 @@ async function setupWorkspace(input2) {
     "tostudy vault sync      # Sincronizar progresso",
     "```"
   ].join("\n");
-  await fs12.writeFile(path15.join(workspacePath, "README.md"), readme, "utf-8");
+  await fs13.writeFile(path16.join(workspacePath, "README.md"), readme, "utf-8");
   return { workspacePath, directories: WORKSPACE_DIRS, configPath };
 }
 var WORKSPACE_DIRS;
@@ -20633,8 +20676,8 @@ var init_templates = __esm({
 });
 
 // ../../packages/tostudy-core/src/workspace/extract-exercise.ts
-import fs13 from "node:fs/promises";
-import path16 from "node:path";
+import fs14 from "node:fs/promises";
+import path17 from "node:path";
 function padOrder(n) {
   return String(n).padStart(2, "0");
 }
@@ -20660,16 +20703,16 @@ async function extractExercise(input2) {
   const lessonData = resolveWorkspaceTokens(input2.lessonData, paths);
   const moduleDir = `${padOrder(lessonData.moduleOrder)}-${lessonData.moduleSlug}`;
   const lessonDir = `${padOrder(lessonData.lessonOrder)}-${lessonData.lessonSlug}`;
-  const exercisePath = path16.join(workspacePath, "exercises", moduleDir, lessonDir);
-  await fs13.mkdir(exercisePath, { recursive: true });
+  const exercisePath = path17.join(workspacePath, "exercises", moduleDir, lessonDir);
+  await fs14.mkdir(exercisePath, { recursive: true });
   const extractedFiles = [];
   let hasStarterCode = false;
   if (lessonData.sandpackConfig?.files) {
     for (const [filePath, fileData] of Object.entries(lessonData.sandpackConfig.files)) {
       const cleanPath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
-      const fullPath = path16.join(exercisePath, cleanPath);
-      await fs13.mkdir(path16.dirname(fullPath), { recursive: true });
-      await fs13.writeFile(fullPath, fileData.code, "utf-8");
+      const fullPath = path17.join(exercisePath, cleanPath);
+      await fs14.mkdir(path17.dirname(fullPath), { recursive: true });
+      await fs14.writeFile(fullPath, fileData.code, "utf-8");
       extractedFiles.push(cleanPath);
       hasStarterCode = true;
     }
@@ -20677,13 +20720,13 @@ async function extractExercise(input2) {
     const tierData = getTierData(lessonData.structuredData, exerciseTier);
     const tierCode = tierData?.code;
     if (tierCode) {
-      await fs13.writeFile(path16.join(exercisePath, "exercise.js"), tierCode, "utf-8");
+      await fs14.writeFile(path17.join(exercisePath, "exercise.js"), tierCode, "utf-8");
       extractedFiles.push("exercise.js");
       hasStarterCode = true;
     } else {
       const starter = getStarterCode(lessonData.structuredData);
       if (starter) {
-        await fs13.writeFile(path16.join(exercisePath, "exercise.js"), starter, "utf-8");
+        await fs14.writeFile(path17.join(exercisePath, "exercise.js"), starter, "utf-8");
         extractedFiles.push("exercise.js");
         hasStarterCode = true;
       }
@@ -20701,8 +20744,8 @@ async function extractExercise(input2) {
           ...exerciseDeps
         }
       };
-      await fs13.writeFile(
-        path16.join(exercisePath, "package.json"),
+      await fs14.writeFile(
+        path17.join(exercisePath, "package.json"),
         JSON.stringify(pkgJson, null, 2),
         "utf-8"
       );
@@ -20714,20 +20757,20 @@ async function extractExercise(input2) {
       );
       for (const [configFile, configContent] of Object.entries(scaffold.configs)) {
         if (!sandpackFileNames.has(configFile)) {
-          await fs13.writeFile(path16.join(exercisePath, configFile), configContent, "utf-8");
+          await fs14.writeFile(path17.join(exercisePath, configFile), configContent, "utf-8");
           extractedFiles.push(configFile);
         }
       }
       const setupSh = `#!/bin/sh
 ${scaffold.setupScript}
 `;
-      await fs13.writeFile(path16.join(exercisePath, "setup.sh"), setupSh, "utf-8");
+      await fs14.writeFile(path17.join(exercisePath, "setup.sh"), setupSh, "utf-8");
       extractedFiles.push("setup.sh");
     }
   }
   const readme = generateReadme(lessonData, exerciseTier);
-  const readmePath = path16.join(exercisePath, "README.md");
-  await fs13.writeFile(readmePath, readme, "utf-8");
+  const readmePath = path17.join(exercisePath, "README.md");
+  await fs14.writeFile(readmePath, readme, "utf-8");
   extractedFiles.push("README.md");
   return {
     exercisePath,
@@ -20809,9 +20852,9 @@ var init_workspace = __esm({
 
 // src/commands/workspace.ts
 import { Command as Command17 } from "commander";
-import path17 from "node:path";
+import path18 from "node:path";
 import os8 from "node:os";
-import fs14 from "node:fs/promises";
+import fs15 from "node:fs/promises";
 var logger18, workspaceCommand;
 var init_workspace2 = __esm({
   "src/commands/workspace.ts"() {
@@ -20835,14 +20878,14 @@ var init_workspace2 = __esm({
         let directories;
         if (!opts.path && cwdIsWorkspace) {
           const resolvedCwd = await resolveCwdWorkspacePath(process.cwd());
-          workspacePath = resolvedCwd ?? path17.join(process.cwd(), ".tostudy");
-          await fs14.mkdir(workspacePath, { recursive: true });
+          workspacePath = resolvedCwd ?? path18.join(process.cwd(), ".tostudy");
+          await fs15.mkdir(workspacePath, { recursive: true });
           directories = ["exercises", "generated", "notes", "diagrams"];
           for (const dir of directories) {
-            await fs14.mkdir(path17.join(workspacePath, dir), { recursive: true });
+            await fs15.mkdir(path18.join(workspacePath, dir), { recursive: true });
           }
-          const configPath = path17.join(workspacePath, ".ana-config.json");
-          await fs14.writeFile(
+          const configPath = path18.join(workspacePath, ".ana-config.json");
+          await fs15.writeFile(
             configPath,
             JSON.stringify(
               {
@@ -20860,7 +20903,7 @@ var init_workspace2 = __esm({
             "utf-8"
           );
         } else {
-          const basePath = opts.path ?? path17.join(os8.homedir(), "study");
+          const basePath = opts.path ?? path18.join(os8.homedir(), "study");
           const result2 = await setupWorkspace({
             courseId: activeCourse.courseId,
             courseSlug: courseSlug(activeCourse.courseTitle),
@@ -20894,7 +20937,7 @@ Pr\xF3ximo passo: tostudy export
         process.exit(1);
       }
     });
-    workspaceCommand.command("status").description("Mostrar status do workspace do curso ativo").option("--path <dir>", "Diret\xF3rio base do workspace", path17.join(os8.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
+    workspaceCommand.command("status").description("Mostrar status do workspace do curso ativo").option("--path <dir>", "Diret\xF3rio base do workspace", path18.join(os8.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const activeCourse = await requireActiveCourse();
         const onboardingState = await getCourseOnboardingState(activeCourse.courseId);
@@ -20911,40 +20954,40 @@ Pr\xF3ximo passo: tostudy export
         const workspacePath = ws.workspacePath;
         let configData = null;
         try {
-          const raw = await fs14.readFile(path17.join(workspacePath, ".ana-config.json"), "utf-8");
+          const raw = await fs15.readFile(path18.join(workspacePath, ".ana-config.json"), "utf-8");
           configData = JSON.parse(raw);
         } catch {
           configData = null;
         }
-        const exercisesDir = path17.join(workspacePath, "exercises");
+        const exercisesDir = path18.join(workspacePath, "exercises");
         let exerciseCount = 0;
         try {
-          const moduleDirs = await fs14.readdir(exercisesDir);
+          const moduleDirs = await fs15.readdir(exercisesDir);
           for (const modDir of moduleDirs) {
-            const modPath = path17.join(exercisesDir, modDir);
-            const stat = await fs14.stat(modPath);
+            const modPath = path18.join(exercisesDir, modDir);
+            const stat = await fs15.stat(modPath);
             if (stat.isDirectory()) {
-              const lessonDirs = await fs14.readdir(modPath);
+              const lessonDirs = await fs15.readdir(modPath);
               for (const lessonDir of lessonDirs) {
-                const lessonPath = path17.join(modPath, lessonDir);
-                const lstat = await fs14.stat(lessonPath);
+                const lessonPath = path18.join(modPath, lessonDir);
+                const lstat = await fs15.stat(lessonPath);
                 if (lstat.isDirectory()) exerciseCount++;
               }
             }
           }
         } catch {
         }
-        const generatedDir = path17.join(workspacePath, "generated");
+        const generatedDir = path18.join(workspacePath, "generated");
         let artifactCount = 0;
         try {
-          const files = await fs14.readdir(generatedDir);
+          const files = await fs15.readdir(generatedDir);
           artifactCount = files.length;
         } catch {
         }
-        const diagramsDir = path17.join(workspacePath, "diagrams");
+        const diagramsDir = path18.join(workspacePath, "diagrams");
         let diagramCount = 0;
         try {
-          const files = await fs14.readdir(diagramsDir);
+          const files = await fs15.readdir(diagramsDir);
           diagramCount = files.length;
         } catch {
         }
@@ -20993,9 +21036,9 @@ Pr\xF3ximo passo: tostudy export
 
 // src/commands/export.ts
 import { Command as Command18 } from "commander";
-import path18 from "node:path";
+import path19 from "node:path";
 import os9 from "node:os";
-import fs15 from "node:fs/promises";
+import fs16 from "node:fs/promises";
 var logger19, exportCommand;
 var init_export = __esm({
   "src/commands/export.ts"() {
@@ -21008,7 +21051,7 @@ var init_export = __esm({
     init_resolve();
     init_errors();
     logger19 = createLogger("cli:export");
-    exportCommand = new Command18("export").description("Extrair exerc\xEDcio atual para o workspace local").option("--tier <tier>", "Tier do exerc\xEDcio: guided, semiGuided, challenging", "guided").option("--path <dir>", "Diret\xF3rio base do workspace", path18.join(os9.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
+    exportCommand = new Command18("export").description("Extrair exerc\xEDcio atual para o workspace local").option("--tier <tier>", "Tier do exerc\xEDcio: guided, semiGuided, challenging", "guided").option("--path <dir>", "Diret\xF3rio base do workspace", path19.join(os9.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
         const activeCourse = await requireActiveCourse();
@@ -21026,21 +21069,21 @@ var init_export = __esm({
           opts.path
         );
         if (ws.found && ws.source === "cwd" && ws.workspacePath) {
-          const configPath = path18.join(ws.workspacePath, ".ana-config.json");
+          const configPath = path19.join(ws.workspacePath, ".ana-config.json");
           let hasConfig = false;
           try {
-            await fs15.access(configPath);
+            await fs16.access(configPath);
             hasConfig = true;
           } catch {
           }
           if (!hasConfig) {
             const slug = courseSlug(activeCourse.courseTitle);
             logger19.info("Auto-initializing workspace", { workspacePath: ws.workspacePath });
-            await fs15.mkdir(ws.workspacePath, { recursive: true });
+            await fs16.mkdir(ws.workspacePath, { recursive: true });
             for (const dir of ["exercises", "generated", "notes", "diagrams"]) {
-              await fs15.mkdir(path18.join(ws.workspacePath, dir), { recursive: true });
+              await fs16.mkdir(path19.join(ws.workspacePath, dir), { recursive: true });
             }
-            await fs15.writeFile(
+            await fs16.writeFile(
               configPath,
               JSON.stringify(
                 {
@@ -21058,7 +21101,7 @@ var init_export = __esm({
               "utf-8"
             );
             await setCourseWorkspacePath(activeCourse.courseId, ws.workspacePath);
-            const isNamespaced = ws.workspacePath === path18.join(process.cwd(), ".tostudy");
+            const isNamespaced = ws.workspacePath === path19.join(process.cwd(), ".tostudy");
             process.stderr.write(
               isNamespaced ? `\u2728 Workspace inicializado em .tostudy/ (isolado do projeto).
 ` : `\u2728 Workspace inicializado nesta pasta.
@@ -21112,7 +21155,7 @@ ${result.files.map((f) => `  \u{1F4C4} ${f}`).join("\n")}
 // src/commands/open.ts
 import { Command as Command19 } from "commander";
 import { execFile as execFile3 } from "node:child_process";
-import path19 from "node:path";
+import path20 from "node:path";
 import os10 from "node:os";
 var logger20, openCommand;
 var init_open = __esm({
@@ -21124,7 +21167,7 @@ var init_open = __esm({
     init_resolve();
     init_errors();
     logger20 = createLogger("cli:open");
-    openCommand = new Command19("open").description("Abrir workspace do curso na IDE").option("--path <dir>", "Diret\xF3rio base do workspace", path19.join(os10.homedir(), "study")).action(async (opts) => {
+    openCommand = new Command19("open").description("Abrir workspace do curso na IDE").option("--path <dir>", "Diret\xF3rio base do workspace", path20.join(os10.homedir(), "study")).action(async (opts) => {
       try {
         const activeCourse = await requireActiveCourse();
         const onboardingState = await getCourseOnboardingState(activeCourse.courseId);
@@ -21178,24 +21221,24 @@ var init_types = __esm({
 });
 
 // ../../packages/tostudy-core/src/vault/write-vault.ts
-import fs16 from "node:fs/promises";
-import path20 from "node:path";
+import fs17 from "node:fs/promises";
+import path21 from "node:path";
 async function writeVaultFiles(files, outputPath, courseId, courseSlug2) {
   for (const file2 of files) {
-    const fullPath = path20.join(outputPath, file2.relativePath);
-    await fs16.mkdir(path20.dirname(fullPath), { recursive: true });
-    await fs16.writeFile(fullPath, file2.content, "utf-8");
+    const fullPath = path21.join(outputPath, file2.relativePath);
+    await fs17.mkdir(path21.dirname(fullPath), { recursive: true });
+    await fs17.writeFile(fullPath, file2.content, "utf-8");
   }
-  const vaultPath = path20.join(outputPath, courseSlug2);
+  const vaultPath = path21.join(outputPath, courseSlug2);
   const marker = {
     courseId,
     courseSlug: courseSlug2,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     version: VAULT_MARKER_VERSION
   };
-  await fs16.mkdir(vaultPath, { recursive: true });
-  await fs16.writeFile(
-    path20.join(vaultPath, VAULT_MARKER_FILENAME),
+  await fs17.mkdir(vaultPath, { recursive: true });
+  await fs17.writeFile(
+    path21.join(vaultPath, VAULT_MARKER_FILENAME),
     JSON.stringify(marker, null, 2),
     "utf-8"
   );
@@ -21220,9 +21263,9 @@ var init_vault = __esm({
 
 // src/commands/vault.ts
 import { Command as Command20 } from "commander";
-import path21 from "node:path";
+import path22 from "node:path";
 import os11 from "node:os";
-import fs17 from "node:fs/promises";
+import fs18 from "node:fs/promises";
 var logger21, vaultCommand;
 var init_vault2 = __esm({
   "src/commands/vault.ts"() {
@@ -21238,7 +21281,7 @@ var init_vault2 = __esm({
     init_errors();
     logger21 = createLogger("cli:vault");
     vaultCommand = new Command20("vault").description("Gerenciar vault Obsidian do curso");
-    vaultCommand.command("init").description("Gerar vault Obsidian para o curso ativo").option("--path <dir>", "Diret\xF3rio base do workspace", path21.join(os11.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
+    vaultCommand.command("init").description("Gerar vault Obsidian para o curso ativo").option("--path <dir>", "Diret\xF3rio base do workspace", path22.join(os11.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
         const activeCourse = await requireActiveCourse();
@@ -21319,7 +21362,7 @@ Para visualizar:
         process.exit(1);
       }
     });
-    vaultCommand.command("sync").description("Sincronizar progresso do curso com o vault local").option("--path <dir>", "Diret\xF3rio base do workspace", path21.join(os11.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
+    vaultCommand.command("sync").description("Sincronizar progresso do curso com o vault local").option("--path <dir>", "Diret\xF3rio base do workspace", path22.join(os11.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
         const activeCourse = await requireActiveCourse();
@@ -21345,8 +21388,8 @@ Para visualizar:
         const data = createHttpProvider(session.apiUrl, session.token);
         const deps = { data, logger: logger21 };
         const progress = await getProgress({ enrollmentId: activeCourse.enrollmentId }, deps);
-        const markerPath = path21.join(vaultPath, ".ana-vault.json");
-        const markerRaw = await fs17.readFile(markerPath, "utf-8");
+        const markerPath = path22.join(vaultPath, ".ana-vault.json");
+        const markerRaw = await fs18.readFile(markerPath, "utf-8");
         const marker = JSON.parse(markerRaw);
         marker.lastSyncedAt = (/* @__PURE__ */ new Date()).toISOString();
         marker.progress = {
@@ -21354,10 +21397,10 @@ Para visualizar:
           currentModule: progress.currentModule.title,
           currentLesson: progress.currentLesson.title
         };
-        await fs17.writeFile(markerPath, JSON.stringify(marker, null, 2), "utf-8");
-        const courseIndexPath = path21.join(vaultPath, slug, "index.md");
+        await fs18.writeFile(markerPath, JSON.stringify(marker, null, 2), "utf-8");
+        const courseIndexPath = path22.join(vaultPath, slug, "index.md");
         try {
-          let indexContent = await fs17.readFile(courseIndexPath, "utf-8");
+          let indexContent = await fs18.readFile(courseIndexPath, "utf-8");
           indexContent = indexContent.replace(/\n---\n\n> 📊 Progresso:.*\n/g, "");
           const titleEnd = indexContent.indexOf("\n");
           if (titleEnd !== -1) {
@@ -21368,7 +21411,7 @@ Para visualizar:
 `;
             indexContent = indexContent.slice(0, titleEnd) + banner + indexContent.slice(titleEnd);
           }
-          await fs17.writeFile(courseIndexPath, indexContent, "utf-8");
+          await fs18.writeFile(courseIndexPath, indexContent, "utf-8");
         } catch {
         }
         const syncedAt = marker.lastSyncedAt;
@@ -21688,16 +21731,16 @@ var init_brief_open = __esm({
 });
 
 // src/sessions/storage.ts
-import fs18 from "node:fs";
-import path22 from "node:path";
+import fs19 from "node:fs";
+import path23 from "node:path";
 function sessionsDir(workspacePath) {
-  return path22.join(workspacePath, ".tostudy", "sessions");
+  return path23.join(workspacePath, ".tostudy", "sessions");
 }
 async function saveModuleSummary(workspacePath, input2) {
   const dir = sessionsDir(workspacePath);
-  fs18.mkdirSync(dir, { recursive: true });
+  fs19.mkdirSync(dir, { recursive: true });
   const filename = `module-${input2.moduleId}-summary.md`;
-  const filePath = path22.join(dir, filename);
+  const filePath = path23.join(dir, filename);
   const header = [
     "---",
     `moduleId: ${input2.moduleId}`,
@@ -21706,17 +21749,17 @@ async function saveModuleSummary(workspacePath, input2) {
     "---",
     ""
   ].join("\n");
-  fs18.writeFileSync(filePath, header + input2.summary, { mode: 384 });
+  fs19.writeFileSync(filePath, header + input2.summary, { mode: 384 });
   logger25.debug("Module summary saved", { moduleId: input2.moduleId, path: filePath });
   return filePath;
 }
 async function loadSessionContext(workspacePath) {
   const dir = sessionsDir(workspacePath);
-  if (!fs18.existsSync(dir)) return { moduleSummaries: [] };
-  const files = fs18.readdirSync(dir).filter((f) => f.startsWith("module-") && f.endsWith("-summary.md")).sort();
+  if (!fs19.existsSync(dir)) return { moduleSummaries: [] };
+  const files = fs19.readdirSync(dir).filter((f) => f.startsWith("module-") && f.endsWith("-summary.md")).sort();
   const summaries = [];
   for (const file2 of files) {
-    const content = fs18.readFileSync(path22.join(dir, file2), "utf-8");
+    const content = fs19.readFileSync(path23.join(dir, file2), "utf-8");
     const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
     if (!frontmatterMatch) continue;
     const meta3 = frontmatterMatch[1];
@@ -21738,7 +21781,7 @@ var init_storage = __esm({
 });
 
 // src/commands/compact.ts
-import fs19 from "node:fs";
+import fs20 from "node:fs";
 import { Command as Command26 } from "commander";
 var logger26, compactCommand;
 var init_compact = __esm({
@@ -21758,7 +21801,7 @@ var init_compact = __esm({
           if (opts.json) jsonError("no_workspace");
           error("Nenhum workspace encontrado.");
         }
-        const summary = fs19.readFileSync("/dev/stdin", "utf-8").trim();
+        const summary = fs20.readFileSync("/dev/stdin", "utf-8").trim();
         if (!summary) {
           if (opts.json) jsonError("empty_summary", { message: "Summary vazio" });
           error("Summary vazio. Envie o conte\xFAdo via stdin.");
@@ -21797,13 +21840,14 @@ var init_context = __esm({
     init_workspace_state();
     init_storage();
     init_formatter();
+    init_errors();
     logger27 = createLogger("cli:context");
     contextCommand = new Command27("context").description("Load session context (workspace state + module summaries) for LLM consumption").option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const ws = await findWorkspaceState();
         if (!ws) {
           if (opts.json) jsonError("no_workspace");
-          error("Nenhum workspace encontrado. Rode: tostudy setup");
+          error(getErrors().noActiveCourse.trimEnd());
         }
         const sessionCtx = await loadSessionContext(ws.workspacePath);
         const result = {
@@ -21858,13 +21902,14 @@ var init_memory = __esm({
     init_workspace_state();
     init_guards();
     init_formatter();
+    init_errors();
     logger28 = createLogger("cli:memory");
     memoryCommand = new Command28("memory").description("Load accumulated student memory (learning profile + recent lessons) for the tutor").option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const ws = await findWorkspaceState();
         if (!ws) {
           if (opts.json) return jsonError("no_workspace");
-          return error("Nenhum workspace encontrado. Rode: tostudy setup");
+          return error(getErrors().noActiveCourse.trimEnd());
         }
         const { courseId, enrollmentId } = ws.state;
         if (!courseId || !enrollmentId) {
@@ -21901,6 +21946,7 @@ var init_insight = __esm({
     init_workspace_state();
     init_guards();
     init_formatter();
+    init_errors();
     logger29 = createLogger("cli:insight");
     VALID_TYPES = ["difficulty", "breakthrough", "question"];
     insightCommand = new Command29("insight").description(
@@ -21919,7 +21965,7 @@ var init_insight = __esm({
         const ws = await findWorkspaceState();
         if (!ws) {
           if (opts.json) return jsonError("no_workspace");
-          return error("Nenhum workspace encontrado. Rode: tostudy setup");
+          return error(getErrors().noActiveCourse.trimEnd());
         }
         const { courseId, enrollmentId } = ws.state;
         if (!courseId || !enrollmentId) {
@@ -23009,11 +23055,11 @@ __export(auto_updater_exports, {
   detectManager: () => detectManager,
   maybeAutoUpdate: () => maybeAutoUpdate
 });
-import fs20 from "node:fs";
-import path23 from "node:path";
+import fs21 from "node:fs";
+import path24 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 function detectManager(entryRealPath) {
-  const p = entryRealPath.split(path23.sep).join("/");
+  const p = entryRealPath.split(path24.sep).join("/");
   if (p.includes("/pnpm/")) return { cmd: "pnpm", args: ["add", "-g", `${PACKAGE_NAME2}@latest`] };
   if (p.includes("/.bun/")) return { cmd: "bun", args: ["add", "-g", `${PACKAGE_NAME2}@latest`] };
   if (p.includes(`/node_modules/${PACKAGE_NAME2}/`))
@@ -23021,10 +23067,10 @@ function detectManager(entryRealPath) {
   return null;
 }
 function installDir(entryRealPath) {
-  const normalized = entryRealPath.split(path23.sep).join("/");
+  const normalized = entryRealPath.split(path24.sep).join("/");
   const marker = `/node_modules/${PACKAGE_NAME2}/`;
   const idx = normalized.indexOf(marker);
-  if (idx === -1) return path23.dirname(entryRealPath);
+  if (idx === -1) return path24.dirname(entryRealPath);
   return entryRealPath.slice(0, idx + marker.length - 1);
 }
 function maybeAutoUpdate(currentVersion, opts = {}) {
@@ -23040,10 +23086,10 @@ function maybeAutoUpdate(currentVersion, opts = {}) {
     if (cache.attemptedVersion === cache.latest) return;
     const entryPath = opts.entryPath ?? argv[1];
     if (!entryPath) return;
-    const real = fs20.realpathSync(entryPath);
+    const real = fs21.realpathSync(entryPath);
     const mgr = detectManager(real);
     if (!mgr) return;
-    fs20.accessSync(installDir(real), fs20.constants.W_OK);
+    fs21.accessSync(installDir(real), fs21.constants.W_OK);
     writeCache({ ...cache, attemptedVersion: cache.latest }, configDir);
     process.stderr.write(
       `