@tostudy-ai/cli 0.16.10 → 0.16.12

package/dist/cli.js

@@ -1058,8 +1058,9 @@ async function cliApiFetch(url2, token, init) {
   if (!response.ok) {
     const code = typeof body.error === "string" && body.error.length > 0 ? body.error : void 0;
     const friendly = typeof body.message === "string" && body.message.length > 0 ? body.message : void 0;
+    const unauthenticated = response.status === 401 ? "Sess\xE3o inv\xE1lida ou expirada. Rode: tostudy login" : void 0;
     throw new CliApiError(
-      friendly ?? code ?? `API error ${response.status}`,
+      friendly ?? unauthenticated ?? code ?? `API error ${response.status}`,
       response.status,
       code
     );
@@ -2617,11 +2618,18 @@ var init_login = __esm({
       }
       if (opts.manual) {
         console.log(`
-  Acesse este endere\xE7o no seu browser:`);
-        console.log(`  ${apiUrl}/api/cli/auth/authorize?port=${PORT}
+  Login sem browser nesta m\xE1quina:`);
+        console.log(`  1. Em um computador com browser, acesse:`);
+        console.log(`     ${apiUrl}/api/cli/auth/authorize`);
+        console.log(
+          `  2. Ap\xF3s autorizar, o browser tenta abrir http://localhost:9876/callback?code=...`
+        );
+        console.log(
+          `     e falha (n\xE3o h\xE1 CLI nesse computador). Copie o valor de "code" da barra de endere\xE7o.`
+        );
+        console.log(`  3. Em at\xE9 5 minutos, volte aqui e rode:`);
+        console.log(`     tostudy login --code <code>
 `);
-        console.log("  Ap\xF3s autorizar, o browser ser\xE1 redirecionado e o login ser\xE1 conclu\xEDdo.");
-        console.log("  Certifique-se de rodar este comando sem --manual para o fluxo autom\xE1tico.\n");
         return;
       }
       console.log("\n  Abrindo browser para autentica\xE7\xE3o...\n");
@@ -2829,18 +2837,6 @@ var init_errors_en_us = __esm({
 });
 
 // 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;
@@ -2852,8 +2848,8 @@ function resolveLocale() {
       return val;
     }
   }
-  const stored = readStoredLocale();
-  if (stored) {
+  const stored = process.env["TOSTUDY_LOCALE"];
+  if (stored === "pt-BR" || stored === "en-US") {
     _cachedLocale = stored;
     return stored;
   }
@@ -2888,7 +2884,6 @@ 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 = {
@@ -2902,12 +2897,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 path8 from "node:path";
+import path7 from "node:path";
 function resolveMarkerPath(workspacePath) {
-  if (path8.basename(workspacePath) === ".tostudy") {
-    return path8.join(workspacePath, "workspace.json");
+  if (path7.basename(workspacePath) === ".tostudy") {
+    return path7.join(workspacePath, "workspace.json");
   }
-  return path8.join(workspacePath, ".tostudy", "workspace.json");
+  return path7.join(workspacePath, ".tostudy", "workspace.json");
 }
 async function readWorkspaceMarker(workspacePath) {
   const filePath = resolveMarkerPath(workspacePath);
@@ -2925,13 +2920,13 @@ async function readWorkspaceMarker(workspacePath) {
   }
 }
 async function writeWorkspaceMarker(workspacePath, input2, options = {}) {
-  const homeDir = path8.resolve(options.homeDir ?? os4.homedir());
-  const resolvedWorkspace = path8.resolve(workspacePath);
-  if (resolvedWorkspace === homeDir || homeDir.startsWith(resolvedWorkspace + path8.sep)) {
+  const homeDir = path7.resolve(options.homeDir ?? os4.homedir());
+  const resolvedWorkspace = path7.resolve(workspacePath);
+  if (resolvedWorkspace === homeDir || homeDir.startsWith(resolvedWorkspace + path7.sep)) {
     throw new Error(getErrors().workspaceRefusedAtHome);
   }
   const filePath = resolveMarkerPath(workspacePath);
-  const dir = path8.dirname(filePath);
+  const dir = path7.dirname(filePath);
   if (!existsSync3(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
@@ -2968,7 +2963,7 @@ __export(workspace_state_exports, {
 });
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import os5 from "node:os";
-import path9 from "node:path";
+import path8 from "node:path";
 async function readWorkspaceState(workspacePath) {
   const marker = await readWorkspaceMarker(workspacePath);
   if (!marker) return null;
@@ -2997,13 +2992,13 @@ async function readWorkspaceState(workspacePath) {
   }
 }
 async function findWorkspaceState(startCwd = process.cwd(), homeDir = os5.homedir()) {
-  const home = path9.resolve(homeDir);
-  let current = path9.resolve(startCwd);
+  const home = path8.resolve(homeDir);
+  let current = path8.resolve(startCwd);
   while (true) {
     if (current === home) return null;
     const state = await readWorkspaceState(current);
     if (state) return { state, workspacePath: current };
-    const parent = path9.dirname(current);
+    const parent = path8.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -3072,7 +3067,7 @@ __export(course_state_exports, {
   setCourseWorkspacePath: () => setCourseWorkspacePath,
   setLastInitCourseId: () => setLastInitCourseId
 });
-import fs7 from "node:fs";
+import fs6 from "node:fs";
 async function getCourseOnboardingState(courseId, configDir) {
   const state = readCourseOnboardingState(configDir);
   return state[courseId] ?? null;
@@ -3094,7 +3089,7 @@ async function saveCourseLearnerProfile(course, learnerProfile, artifacts, confi
 }
 async function clearAllCourseOnboarding(configDir) {
   const onboardingPath = getCourseOnboardingPath(configDir);
-  if (fs7.existsSync(onboardingPath)) fs7.unlinkSync(onboardingPath);
+  if (fs6.existsSync(onboardingPath)) fs6.unlinkSync(onboardingPath);
 }
 var init_course_state = __esm({
   "src/onboarding/course-state.ts"() {
@@ -3137,14 +3132,14 @@ __export(resolve_exports, {
   resolveVaultPath: () => resolveVaultPath,
   resolveWorkspace: () => resolveWorkspace
 });
-import fs8 from "node:fs/promises";
-import path10 from "node:path";
+import fs7 from "node:fs/promises";
+import path9 from "node:path";
 import os6 from "node:os";
 async function resolveWorkspace(courseTitle, basePath = DEFAULT_BASE) {
   const slug = courseSlug(courseTitle);
-  const candidate = path10.join(basePath, slug);
+  const candidate = path9.join(basePath, slug);
   try {
-    await fs8.access(path10.join(candidate, ".ana-config.json"));
+    await fs7.access(path9.join(candidate, ".ana-config.json"));
     return { found: true, workspacePath: candidate, source: "default" };
   } catch {
     return { found: false, workspacePath: null };
@@ -3154,49 +3149,49 @@ async function isCwdWorkspace(cwd = process.cwd()) {
   return await resolveCwdWorkspacePath(cwd) !== null;
 }
 async function resolveCwdWorkspacePath(cwd = process.cwd()) {
-  const tostudyDir = path10.join(cwd, ".tostudy");
+  const tostudyDir = path9.join(cwd, ".tostudy");
   try {
-    const stat = await fs8.stat(tostudyDir);
+    const stat = await fs7.stat(tostudyDir);
     if (stat.isDirectory()) return tostudyDir;
   } catch {
   }
   try {
-    await fs8.access(path10.join(cwd, ".ana-config.json"));
+    await fs7.access(path9.join(cwd, ".ana-config.json"));
     return cwd;
   } catch {
     return null;
   }
 }
 async function findCwdWorkspaceUpwards(startCwd = process.cwd(), homeDir = os6.homedir()) {
-  const home = path10.resolve(homeDir);
-  let current = path10.resolve(startCwd);
+  const home = path9.resolve(homeDir);
+  let current = path9.resolve(startCwd);
   while (true) {
     if (current === home) return null;
     const direct = await resolveCwdWorkspacePath(current);
     if (direct) return direct;
-    const parent = path10.dirname(current);
+    const parent = path9.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function resolveVaultPath(workspacePath, slug) {
-  const base = path10.basename(workspacePath) === ".tostudy" ? path10.dirname(workspacePath) : workspacePath;
-  return path10.join(base, `vault-${slug}`);
+  const base = path9.basename(workspacePath) === ".tostudy" ? path9.dirname(workspacePath) : workspacePath;
+  return path9.join(base, `vault-${slug}`);
 }
 function cliWorkspacePaths(workspacePath, courseTitle) {
-  const base = path10.basename(workspacePath) === ".tostudy" ? path10.dirname(workspacePath) : workspacePath;
+  const base = path9.basename(workspacePath) === ".tostudy" ? path9.dirname(workspacePath) : workspacePath;
   return { workspace: base, vault: resolveVaultPath(workspacePath, courseSlug(courseTitle)) };
 }
 async function findExistingVault(workspacePath, slug) {
   const slugged = resolveVaultPath(workspacePath, slug);
   try {
-    await fs8.access(path10.join(slugged, ".ana-vault.json"));
+    await fs7.access(path9.join(slugged, ".ana-vault.json"));
     return slugged;
   } catch {
   }
-  const legacy = path10.join(workspacePath, "vault");
+  const legacy = path9.join(workspacePath, "vault");
   try {
-    await fs8.access(path10.join(legacy, ".ana-vault.json"));
+    await fs7.access(path9.join(legacy, ".ana-vault.json"));
     return legacy;
   } catch {
     return null;
@@ -3209,7 +3204,7 @@ async function resolveEffectiveWorkspace(courseTitle, storedPath, cwd = process.
   }
   if (storedPath) {
     try {
-      await fs8.access(path10.join(storedPath, ".ana-config.json"));
+      await fs7.access(path9.join(storedPath, ".ana-config.json"));
       return { found: true, workspacePath: storedPath, source: "stored" };
     } catch {
     }
@@ -3230,37 +3225,50 @@ var init_resolve = __esm({
   "src/workspace/resolve.ts"() {
     "use strict";
     init_slug();
-    DEFAULT_BASE = path10.join(os6.homedir(), "study");
+    DEFAULT_BASE = path9.join(os6.homedir(), "study");
     courseSlug = slugify;
     resolveActiveCourseWithOverride = resolveActiveCourseFromWorkspace;
   }
 });
 
 // src/auth/guards.ts
+var guards_exports = {};
+__export(guards_exports, {
+  requireActiveCourse: () => requireActiveCourse,
+  requireSession: () => requireSession
+});
 async function refreshCliSession(session, configDir) {
+  let response;
   try {
-    const response = await fetch(`${session.apiUrl}/api/cli/auth/refresh`, {
+    response = await fetch(`${session.apiUrl}/api/cli/auth/refresh`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ refreshToken: session.refreshToken })
     });
-    if (!response.ok) {
-      await clearSessionArtifacts(configDir);
-      return null;
-    }
-    const data = await response.json();
-    const refreshed = {
-      ...session,
-      token: data.token,
-      refreshToken: data.refreshToken,
-      expiresAt: data.expiresAt
-    };
-    await saveSession(refreshed, configDir);
-    return refreshed;
-  } catch {
+  } catch (err) {
+    return { status: "unavailable", reason: err instanceof Error ? err.message : String(err) };
+  }
+  if (response.status === 401 || response.status === 403) {
     await clearSessionArtifacts(configDir);
-    return null;
+    return { status: "rejected" };
+  }
+  if (!response.ok) {
+    return { status: "unavailable", reason: `HTTP ${response.status}` };
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch (err) {
+    return { status: "unavailable", reason: err instanceof Error ? err.message : String(err) };
   }
+  const refreshed = {
+    ...session,
+    token: data.token,
+    refreshToken: data.refreshToken,
+    expiresAt: data.expiresAt
+  };
+  await saveSession(refreshed, configDir);
+  return { status: "ok", session: refreshed };
 }
 async function requireSession(configDir) {
   const session = await getSession(configDir);
@@ -3270,12 +3278,17 @@ async function requireSession(configDir) {
   }
   const expiresAt = new Date(session.expiresAt);
   if (expiresAt < /* @__PURE__ */ new Date()) {
-    const refreshed = await refreshCliSession(session, configDir);
-    if (!refreshed) {
+    const outcome = await refreshCliSession(session, configDir);
+    if (outcome.status === "ok") return outcome.session;
+    if (outcome.status === "rejected") {
       process.stderr.write("Erro: Sess\xE3o expirada. Rode: tostudy login\n");
       process.exit(2);
     }
-    return refreshed;
+    process.stderr.write(
+      `Erro: N\xE3o foi poss\xEDvel renovar a sess\xE3o (${outcome.reason}). Sua sess\xE3o foi mantida \u2014 verifique a conex\xE3o e tente de novo.
+`
+    );
+    process.exit(4);
   }
   return session;
 }
@@ -3426,7 +3439,7 @@ var CLI_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    CLI_VERSION = true ? "0.16.9" : "0.7.1";
+    CLI_VERSION = true ? "0.16.12" : "0.7.1";
   }
 });
 
@@ -3440,13 +3453,13 @@ __export(update_checker_exports, {
   readCache: () => readCache,
   writeCache: () => writeCache
 });
-import fs9 from "node:fs";
-import path11 from "node:path";
+import fs8 from "node:fs";
+import path10 from "node:path";
 function readCache(configDir) {
   try {
-    const p = path11.join(configDir ?? getConfigDir(), CACHE_FILE);
-    if (!fs9.existsSync(p)) return null;
-    return JSON.parse(fs9.readFileSync(p, "utf-8"));
+    const p = path10.join(configDir ?? getConfigDir(), CACHE_FILE);
+    if (!fs8.existsSync(p)) return null;
+    return JSON.parse(fs8.readFileSync(p, "utf-8"));
   } catch {
     return null;
   }
@@ -3454,8 +3467,8 @@ function readCache(configDir) {
 function writeCache(cache, configDir) {
   try {
     const dir = configDir ?? getConfigDir();
-    fs9.mkdirSync(dir, { recursive: true });
-    fs9.writeFileSync(path11.join(dir, CACHE_FILE), JSON.stringify(cache));
+    fs8.mkdirSync(dir, { recursive: true });
+    fs8.writeFileSync(path10.join(dir, CACHE_FILE), JSON.stringify(cache));
   } catch {
   }
 }
@@ -3525,17 +3538,17 @@ var init_update_checker = __esm({
 });
 
 // src/learner-brief/cache.ts
-import fs10 from "node:fs";
-import path12 from "node:path";
+import fs9 from "node:fs";
+import path11 from "node:path";
 function resolveCachePath(configDir) {
-  return path12.join(configDir, "student-brief.json");
+  return path11.join(configDir, "student-brief.json");
 }
 async function readBriefCache(configDir) {
   const dir = configDir ?? getConfigDir();
   const p = resolveCachePath(dir);
-  if (!fs10.existsSync(p)) return null;
+  if (!fs9.existsSync(p)) return null;
   try {
-    const raw = fs10.readFileSync(p, "utf-8");
+    const raw = fs9.readFileSync(p, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -3543,8 +3556,8 @@ async function readBriefCache(configDir) {
 }
 async function writeBriefCache(configDir, cache) {
   const dir = configDir ?? getConfigDir();
-  fs10.mkdirSync(dir, { recursive: true });
-  fs10.writeFileSync(resolveCachePath(dir), JSON.stringify(cache, null, 2), { mode: 384 });
+  fs9.mkdirSync(dir, { recursive: true });
+  fs9.writeFileSync(resolveCachePath(dir), JSON.stringify(cache, null, 2), { mode: 384 });
 }
 var init_cache = __esm({
   "src/learner-brief/cache.ts"() {
@@ -3554,23 +3567,23 @@ var init_cache = __esm({
 });
 
 // src/tutor-persona/cache.ts
-import fs11 from "node:fs";
-import path13 from "node:path";
+import fs10 from "node:fs";
+import path12 from "node:path";
 function resolveCachePath2(configDir) {
-  return path13.join(configDir, "tutor-personalities.json");
+  return path12.join(configDir, "tutor-personalities.json");
 }
 function readAll(configDir) {
   const p = resolveCachePath2(configDir);
-  if (!fs11.existsSync(p)) return {};
+  if (!fs10.existsSync(p)) return {};
   try {
-    return JSON.parse(fs11.readFileSync(p, "utf-8"));
+    return JSON.parse(fs10.readFileSync(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeAll(configDir, cache) {
-  fs11.mkdirSync(configDir, { recursive: true });
-  fs11.writeFileSync(resolveCachePath2(configDir), JSON.stringify(cache, null, 2), { mode: 384 });
+  fs10.mkdirSync(configDir, { recursive: true });
+  fs10.writeFileSync(resolveCachePath2(configDir), JSON.stringify(cache, null, 2), { mode: 384 });
 }
 async function readPersonaCacheForCourse(configDir, courseId) {
   const dir = configDir ?? getConfigDir();
@@ -4385,6 +4398,7 @@ var init_select = __esm({
           interactive: isInteractiveTerminal(opts.json)
         });
         let pipelineResult = null;
+        let pipelineError = null;
         try {
           pipelineResult = await resolveAndGenerate(
             { courseId: detail.courseId, enrollmentId },
@@ -4395,9 +4409,8 @@ var init_select = __esm({
             }
           );
         } catch (err) {
-          logger8.warn("Failed to run instruction pipeline", {
-            error: err instanceof Error ? err.message : String(err)
-          });
+          pipelineError = err instanceof Error ? err.message : String(err);
+          logger8.warn("Failed to run instruction pipeline", { error: pipelineError });
         }
         const slugMatch = pipelineResult?.wroteFiles.find((f) => f.startsWith(".claude/commands/"))?.match(/tostudy-(.+)\.md$/);
         const courseSlug2 = slugMatch?.[1] ?? "";
@@ -4415,7 +4428,8 @@ var init_select = __esm({
               usedT0: pipelineResult?.usedT0 ?? false,
               usedT1: pipelineResult?.usedT1 ?? false,
               usedT2: pipelineResult?.usedT2 ?? false,
-              instruction: pipelineResult?.renderedInstruction ?? null
+              instruction: pipelineResult?.renderedInstruction ?? null,
+              pipelineError
             },
             { json: true }
           );
@@ -4439,7 +4453,8 @@ var init_select = __esm({
             `  Progresso: ${detail.progress}%  |  ${detail.moduleCount} m\xF3dulos  |  ${detail.lessonCount} li\xE7\xF5es`,
             wsLine,
             "",
-            "  Arquivos de contexto criados para seu assistente AI."
+            pipelineError ? `\u26A0 Arquivos de contexto N\xC3O foram criados (${pipelineError}).
+  Rode \`tostudy select\` de novo com a conex\xE3o ativa.` : "  Arquivos de contexto criados para seu assistente AI."
           ];
           if (pipelineResult && !pipelineResult.usedT0) {
             lines.push("  (sem persona do creator \u2014 usando tutor neutro)");
@@ -4813,7 +4828,7 @@ var init_next = __esm({
 
 // src/commands/lesson.ts
 import { Command as Command11 } from "commander";
-import path14 from "node:path";
+import path13 from "node:path";
 function adjustTimeEstimate(type, baseMinutes) {
   if (type === "exercise") return Math.max(baseMinutes, 30);
   return baseMinutes;
@@ -4826,7 +4841,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 = path14.basename(workspacePath) === ".tostudy" ? path14.dirname(workspacePath) : workspacePath;
+    const base = path13.basename(workspacePath) === ".tostudy" ? path13.dirname(workspacePath) : workspacePath;
     const slug = courseSlug(courseTitle);
     const vaultPath = resolveVaultPath(workspacePath, slug);
     lines.push(
@@ -5370,10 +5385,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path25) {
-  if (!path25)
+function getElementAtPath(obj, path24) {
+  if (!path24)
     return obj;
-  return path25.reduce((acc, key) => acc?.[key], obj);
+  return path24.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -5685,11 +5700,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path25, issues) {
+function prefixIssues(path24, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path25);
+    iss.path.unshift(path24);
     return iss;
   });
 }
@@ -5931,7 +5946,7 @@ function formatError(error49, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error49, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error50, path25 = []) => {
+  const processError = (error50, path24 = []) => {
     var _a2, _b;
     for (const issue2 of error50.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -5941,7 +5956,7 @@ function treeifyError(error49, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path25, ...issue2.path];
+        const fullpath = [...path24, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -5973,8 +5988,8 @@ function treeifyError(error49, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path25 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path25) {
+  const path24 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path24) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -18668,13 +18683,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path25 = ref.slice(1).split("/").filter(Boolean);
-  if (path25.length === 0) {
+  const path24 = ref.slice(1).split("/").filter(Boolean);
+  if (path24.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path25[0] === defsKey) {
-    const key = path25[1];
+  if (path24[0] === defsKey) {
+    const key = path24[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -20006,8 +20021,8 @@ var init_init_template = __esm({
 });
 
 // src/commands/validate.ts
-import fs12 from "node:fs";
-import path15 from "node:path";
+import fs11 from "node:fs";
+import path14 from "node:path";
 import { Command as Command14 } from "commander";
 var logger16, validateCommand;
 var init_validate = __esm({
@@ -20051,21 +20066,21 @@ var init_validate = __esm({
         }
         let solution;
         if (opts.stdin) {
-          solution = fs12.readFileSync("/dev/stdin", "utf-8");
+          solution = fs11.readFileSync("/dev/stdin", "utf-8");
         } else if (file2) {
-          if (!fs12.existsSync(file2)) {
+          if (!fs11.existsSync(file2)) {
             if (opts.json)
               jsonError("file_not_found", { message: `Arquivo n\xE3o encontrado: ${file2}` });
             error(`Arquivo n\xE3o encontrado: ${file2}`);
           }
-          solution = fs12.readFileSync(file2, "utf-8");
+          solution = fs11.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 = path15.extname(file2).toLowerCase();
+          const ext = path14.extname(file2).toLowerCase();
           const LANG_EXTENSIONS = {
             ".html": ["html", "html5"],
             ".css": ["css"],
@@ -20440,15 +20455,27 @@ Rode \`tostudy select <n\xFAmero>\` para ativar um curso.`,
     progressData,
     learnerProfile
   );
-  await deps.saveRemoteEnrollmentOnboarding({
-    apiUrl: session.apiUrl,
-    token: session.token,
-    enrollmentId: activeCourse.enrollmentId,
-    learnerBrief: artifacts.learnerBrief,
-    learnerProfile,
-    source: "cli"
-  });
   await deps.saveCourseLearnerProfile(activeCourse, learnerProfile, artifacts);
+  try {
+    await deps.saveRemoteEnrollmentOnboarding({
+      apiUrl: session.apiUrl,
+      token: session.token,
+      enrollmentId: activeCourse.enrollmentId,
+      learnerBrief: artifacts.learnerBrief,
+      learnerProfile,
+      source: "cli"
+    });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    deps.logger.warn("Failed to save enrollment onboarding remotely", { error: reason });
+    if (!flags.json) {
+      process.stderr.write(
+        `\u26A0 Suas respostas foram salvas neste computador, mas n\xE3o chegaram ao servidor (${reason}).
+  Rode \`tostudy init\` de novo com a conex\xE3o ativa para sincronizar.
+`
+      );
+    }
+  }
   try {
     const rootAgents = await resolveRootAgentsConsent({
       cwd: process.cwd(),
@@ -20506,7 +20533,13 @@ var init_init = __esm({
     init_pipeline_deps();
     logger17 = createLogger("cli:init");
     defaultDeps4 = {
-      getSession,
+      // GH #1419 item 3 — `init` used the raw session, so an expired access
+      // token met the POST as a 401. Refresh through the guard when one exists.
+      getSession: async () => {
+        if (!await getSession()) return null;
+        const { requireSession: requireSession2 } = await Promise.resolve().then(() => (init_guards(), guards_exports));
+        return requireSession2();
+      },
       findWorkspaceState,
       listCourses,
       getProgress,
@@ -20533,14 +20566,14 @@ var init_init = __esm({
 });
 
 // ../../packages/tostudy-core/src/workspace/setup-workspace.ts
-import fs13 from "node:fs/promises";
-import path16 from "node:path";
+import fs12 from "node:fs/promises";
+import path15 from "node:path";
 async function setupWorkspace(input2) {
-  const workspacePath = path16.join(input2.basePath, input2.courseSlug);
+  const workspacePath = path15.join(input2.basePath, input2.courseSlug);
   for (const dir of WORKSPACE_DIRS) {
-    await fs13.mkdir(path16.join(workspacePath, dir), { recursive: true });
+    await fs12.mkdir(path15.join(workspacePath, dir), { recursive: true });
   }
-  const configPath = path16.join(workspacePath, ".ana-config.json");
+  const configPath = path15.join(workspacePath, ".ana-config.json");
   const config2 = {
     courseId: input2.courseId,
     courseSlug: input2.courseSlug,
@@ -20550,7 +20583,7 @@ async function setupWorkspace(input2) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await fs13.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  await fs12.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
   const readme = [
     `# ${input2.courseName}`,
     "",
@@ -20575,7 +20608,7 @@ async function setupWorkspace(input2) {
     "tostudy vault sync      # Sincronizar progresso",
     "```"
   ].join("\n");
-  await fs13.writeFile(path16.join(workspacePath, "README.md"), readme, "utf-8");
+  await fs12.writeFile(path15.join(workspacePath, "README.md"), readme, "utf-8");
   return { workspacePath, directories: WORKSPACE_DIRS, configPath };
 }
 var WORKSPACE_DIRS;
@@ -20676,8 +20709,8 @@ var init_templates = __esm({
 });
 
 // ../../packages/tostudy-core/src/workspace/extract-exercise.ts
-import fs14 from "node:fs/promises";
-import path17 from "node:path";
+import fs13 from "node:fs/promises";
+import path16 from "node:path";
 function padOrder(n) {
   return String(n).padStart(2, "0");
 }
@@ -20703,16 +20736,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 = path17.join(workspacePath, "exercises", moduleDir, lessonDir);
-  await fs14.mkdir(exercisePath, { recursive: true });
+  const exercisePath = path16.join(workspacePath, "exercises", moduleDir, lessonDir);
+  await fs13.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 = path17.join(exercisePath, cleanPath);
-      await fs14.mkdir(path17.dirname(fullPath), { recursive: true });
-      await fs14.writeFile(fullPath, fileData.code, "utf-8");
+      const fullPath = path16.join(exercisePath, cleanPath);
+      await fs13.mkdir(path16.dirname(fullPath), { recursive: true });
+      await fs13.writeFile(fullPath, fileData.code, "utf-8");
       extractedFiles.push(cleanPath);
       hasStarterCode = true;
     }
@@ -20720,13 +20753,13 @@ async function extractExercise(input2) {
     const tierData = getTierData(lessonData.structuredData, exerciseTier);
     const tierCode = tierData?.code;
     if (tierCode) {
-      await fs14.writeFile(path17.join(exercisePath, "exercise.js"), tierCode, "utf-8");
+      await fs13.writeFile(path16.join(exercisePath, "exercise.js"), tierCode, "utf-8");
       extractedFiles.push("exercise.js");
       hasStarterCode = true;
     } else {
       const starter = getStarterCode(lessonData.structuredData);
       if (starter) {
-        await fs14.writeFile(path17.join(exercisePath, "exercise.js"), starter, "utf-8");
+        await fs13.writeFile(path16.join(exercisePath, "exercise.js"), starter, "utf-8");
         extractedFiles.push("exercise.js");
         hasStarterCode = true;
       }
@@ -20744,8 +20777,8 @@ async function extractExercise(input2) {
           ...exerciseDeps
         }
       };
-      await fs14.writeFile(
-        path17.join(exercisePath, "package.json"),
+      await fs13.writeFile(
+        path16.join(exercisePath, "package.json"),
         JSON.stringify(pkgJson, null, 2),
         "utf-8"
       );
@@ -20757,20 +20790,20 @@ async function extractExercise(input2) {
       );
       for (const [configFile, configContent] of Object.entries(scaffold.configs)) {
         if (!sandpackFileNames.has(configFile)) {
-          await fs14.writeFile(path17.join(exercisePath, configFile), configContent, "utf-8");
+          await fs13.writeFile(path16.join(exercisePath, configFile), configContent, "utf-8");
           extractedFiles.push(configFile);
         }
       }
       const setupSh = `#!/bin/sh
 ${scaffold.setupScript}
 `;
-      await fs14.writeFile(path17.join(exercisePath, "setup.sh"), setupSh, "utf-8");
+      await fs13.writeFile(path16.join(exercisePath, "setup.sh"), setupSh, "utf-8");
       extractedFiles.push("setup.sh");
     }
   }
   const readme = generateReadme(lessonData, exerciseTier);
-  const readmePath = path17.join(exercisePath, "README.md");
-  await fs14.writeFile(readmePath, readme, "utf-8");
+  const readmePath = path16.join(exercisePath, "README.md");
+  await fs13.writeFile(readmePath, readme, "utf-8");
   extractedFiles.push("README.md");
   return {
     exercisePath,
@@ -20852,9 +20885,9 @@ var init_workspace = __esm({
 
 // src/commands/workspace.ts
 import { Command as Command17 } from "commander";
-import path18 from "node:path";
+import path17 from "node:path";
 import os8 from "node:os";
-import fs15 from "node:fs/promises";
+import fs14 from "node:fs/promises";
 var logger18, workspaceCommand;
 var init_workspace2 = __esm({
   "src/commands/workspace.ts"() {
@@ -20878,14 +20911,14 @@ var init_workspace2 = __esm({
         let directories;
         if (!opts.path && cwdIsWorkspace) {
           const resolvedCwd = await resolveCwdWorkspacePath(process.cwd());
-          workspacePath = resolvedCwd ?? path18.join(process.cwd(), ".tostudy");
-          await fs15.mkdir(workspacePath, { recursive: true });
+          workspacePath = resolvedCwd ?? path17.join(process.cwd(), ".tostudy");
+          await fs14.mkdir(workspacePath, { recursive: true });
           directories = ["exercises", "generated", "notes", "diagrams"];
           for (const dir of directories) {
-            await fs15.mkdir(path18.join(workspacePath, dir), { recursive: true });
+            await fs14.mkdir(path17.join(workspacePath, dir), { recursive: true });
           }
-          const configPath = path18.join(workspacePath, ".ana-config.json");
-          await fs15.writeFile(
+          const configPath = path17.join(workspacePath, ".ana-config.json");
+          await fs14.writeFile(
             configPath,
             JSON.stringify(
               {
@@ -20903,7 +20936,7 @@ var init_workspace2 = __esm({
             "utf-8"
           );
         } else {
-          const basePath = opts.path ?? path18.join(os8.homedir(), "study");
+          const basePath = opts.path ?? path17.join(os8.homedir(), "study");
           const result2 = await setupWorkspace({
             courseId: activeCourse.courseId,
             courseSlug: courseSlug(activeCourse.courseTitle),
@@ -20937,7 +20970,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", path18.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", path17.join(os8.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const activeCourse = await requireActiveCourse();
         const onboardingState = await getCourseOnboardingState(activeCourse.courseId);
@@ -20954,40 +20987,40 @@ Pr\xF3ximo passo: tostudy export
         const workspacePath = ws.workspacePath;
         let configData = null;
         try {
-          const raw = await fs15.readFile(path18.join(workspacePath, ".ana-config.json"), "utf-8");
+          const raw = await fs14.readFile(path17.join(workspacePath, ".ana-config.json"), "utf-8");
           configData = JSON.parse(raw);
         } catch {
           configData = null;
         }
-        const exercisesDir = path18.join(workspacePath, "exercises");
+        const exercisesDir = path17.join(workspacePath, "exercises");
         let exerciseCount = 0;
         try {
-          const moduleDirs = await fs15.readdir(exercisesDir);
+          const moduleDirs = await fs14.readdir(exercisesDir);
           for (const modDir of moduleDirs) {
-            const modPath = path18.join(exercisesDir, modDir);
-            const stat = await fs15.stat(modPath);
+            const modPath = path17.join(exercisesDir, modDir);
+            const stat = await fs14.stat(modPath);
             if (stat.isDirectory()) {
-              const lessonDirs = await fs15.readdir(modPath);
+              const lessonDirs = await fs14.readdir(modPath);
               for (const lessonDir of lessonDirs) {
-                const lessonPath = path18.join(modPath, lessonDir);
-                const lstat = await fs15.stat(lessonPath);
+                const lessonPath = path17.join(modPath, lessonDir);
+                const lstat = await fs14.stat(lessonPath);
                 if (lstat.isDirectory()) exerciseCount++;
               }
             }
           }
         } catch {
         }
-        const generatedDir = path18.join(workspacePath, "generated");
+        const generatedDir = path17.join(workspacePath, "generated");
         let artifactCount = 0;
         try {
-          const files = await fs15.readdir(generatedDir);
+          const files = await fs14.readdir(generatedDir);
           artifactCount = files.length;
         } catch {
         }
-        const diagramsDir = path18.join(workspacePath, "diagrams");
+        const diagramsDir = path17.join(workspacePath, "diagrams");
         let diagramCount = 0;
         try {
-          const files = await fs15.readdir(diagramsDir);
+          const files = await fs14.readdir(diagramsDir);
           diagramCount = files.length;
         } catch {
         }
@@ -21036,9 +21069,9 @@ Pr\xF3ximo passo: tostudy export
 
 // src/commands/export.ts
 import { Command as Command18 } from "commander";
-import path19 from "node:path";
+import path18 from "node:path";
 import os9 from "node:os";
-import fs16 from "node:fs/promises";
+import fs15 from "node:fs/promises";
 var logger19, exportCommand;
 var init_export = __esm({
   "src/commands/export.ts"() {
@@ -21051,7 +21084,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", path19.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", path18.join(os9.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
         const activeCourse = await requireActiveCourse();
@@ -21069,21 +21102,21 @@ var init_export = __esm({
           opts.path
         );
         if (ws.found && ws.source === "cwd" && ws.workspacePath) {
-          const configPath = path19.join(ws.workspacePath, ".ana-config.json");
+          const configPath = path18.join(ws.workspacePath, ".ana-config.json");
           let hasConfig = false;
           try {
-            await fs16.access(configPath);
+            await fs15.access(configPath);
             hasConfig = true;
           } catch {
           }
           if (!hasConfig) {
             const slug = courseSlug(activeCourse.courseTitle);
             logger19.info("Auto-initializing workspace", { workspacePath: ws.workspacePath });
-            await fs16.mkdir(ws.workspacePath, { recursive: true });
+            await fs15.mkdir(ws.workspacePath, { recursive: true });
             for (const dir of ["exercises", "generated", "notes", "diagrams"]) {
-              await fs16.mkdir(path19.join(ws.workspacePath, dir), { recursive: true });
+              await fs15.mkdir(path18.join(ws.workspacePath, dir), { recursive: true });
             }
-            await fs16.writeFile(
+            await fs15.writeFile(
               configPath,
               JSON.stringify(
                 {
@@ -21101,7 +21134,7 @@ var init_export = __esm({
               "utf-8"
             );
             await setCourseWorkspacePath(activeCourse.courseId, ws.workspacePath);
-            const isNamespaced = ws.workspacePath === path19.join(process.cwd(), ".tostudy");
+            const isNamespaced = ws.workspacePath === path18.join(process.cwd(), ".tostudy");
             process.stderr.write(
               isNamespaced ? `\u2728 Workspace inicializado em .tostudy/ (isolado do projeto).
 ` : `\u2728 Workspace inicializado nesta pasta.
@@ -21155,7 +21188,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 path20 from "node:path";
+import path19 from "node:path";
 import os10 from "node:os";
 var logger20, openCommand;
 var init_open = __esm({
@@ -21167,7 +21200,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", path20.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", path19.join(os10.homedir(), "study")).action(async (opts) => {
       try {
         const activeCourse = await requireActiveCourse();
         const onboardingState = await getCourseOnboardingState(activeCourse.courseId);
@@ -21221,24 +21254,24 @@ var init_types = __esm({
 });
 
 // ../../packages/tostudy-core/src/vault/write-vault.ts
-import fs17 from "node:fs/promises";
-import path21 from "node:path";
+import fs16 from "node:fs/promises";
+import path20 from "node:path";
 async function writeVaultFiles(files, outputPath, courseId, courseSlug2) {
   for (const file2 of files) {
-    const fullPath = path21.join(outputPath, file2.relativePath);
-    await fs17.mkdir(path21.dirname(fullPath), { recursive: true });
-    await fs17.writeFile(fullPath, file2.content, "utf-8");
+    const fullPath = path20.join(outputPath, file2.relativePath);
+    await fs16.mkdir(path20.dirname(fullPath), { recursive: true });
+    await fs16.writeFile(fullPath, file2.content, "utf-8");
   }
-  const vaultPath = path21.join(outputPath, courseSlug2);
+  const vaultPath = path20.join(outputPath, courseSlug2);
   const marker = {
     courseId,
     courseSlug: courseSlug2,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     version: VAULT_MARKER_VERSION
   };
-  await fs17.mkdir(vaultPath, { recursive: true });
-  await fs17.writeFile(
-    path21.join(vaultPath, VAULT_MARKER_FILENAME),
+  await fs16.mkdir(vaultPath, { recursive: true });
+  await fs16.writeFile(
+    path20.join(vaultPath, VAULT_MARKER_FILENAME),
     JSON.stringify(marker, null, 2),
     "utf-8"
   );
@@ -21263,9 +21296,9 @@ var init_vault = __esm({
 
 // src/commands/vault.ts
 import { Command as Command20 } from "commander";
-import path22 from "node:path";
+import path21 from "node:path";
 import os11 from "node:os";
-import fs18 from "node:fs/promises";
+import fs17 from "node:fs/promises";
 var logger21, vaultCommand;
 var init_vault2 = __esm({
   "src/commands/vault.ts"() {
@@ -21281,7 +21314,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", path22.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", path21.join(os11.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
         const activeCourse = await requireActiveCourse();
@@ -21362,7 +21395,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", path22.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", path21.join(os11.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
         const activeCourse = await requireActiveCourse();
@@ -21388,8 +21421,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 = path22.join(vaultPath, ".ana-vault.json");
-        const markerRaw = await fs18.readFile(markerPath, "utf-8");
+        const markerPath = path21.join(vaultPath, ".ana-vault.json");
+        const markerRaw = await fs17.readFile(markerPath, "utf-8");
         const marker = JSON.parse(markerRaw);
         marker.lastSyncedAt = (/* @__PURE__ */ new Date()).toISOString();
         marker.progress = {
@@ -21397,10 +21430,10 @@ Para visualizar:
           currentModule: progress.currentModule.title,
           currentLesson: progress.currentLesson.title
         };
-        await fs18.writeFile(markerPath, JSON.stringify(marker, null, 2), "utf-8");
-        const courseIndexPath = path22.join(vaultPath, slug, "index.md");
+        await fs17.writeFile(markerPath, JSON.stringify(marker, null, 2), "utf-8");
+        const courseIndexPath = path21.join(vaultPath, slug, "index.md");
         try {
-          let indexContent = await fs18.readFile(courseIndexPath, "utf-8");
+          let indexContent = await fs17.readFile(courseIndexPath, "utf-8");
           indexContent = indexContent.replace(/\n---\n\n> 📊 Progresso:.*\n/g, "");
           const titleEnd = indexContent.indexOf("\n");
           if (titleEnd !== -1) {
@@ -21411,7 +21444,7 @@ Para visualizar:
 `;
             indexContent = indexContent.slice(0, titleEnd) + banner + indexContent.slice(titleEnd);
           }
-          await fs18.writeFile(courseIndexPath, indexContent, "utf-8");
+          await fs17.writeFile(courseIndexPath, indexContent, "utf-8");
         } catch {
         }
         const syncedAt = marker.lastSyncedAt;
@@ -21731,16 +21764,16 @@ var init_brief_open = __esm({
 });
 
 // src/sessions/storage.ts
-import fs19 from "node:fs";
-import path23 from "node:path";
+import fs18 from "node:fs";
+import path22 from "node:path";
 function sessionsDir(workspacePath) {
-  return path23.join(workspacePath, ".tostudy", "sessions");
+  return path22.join(workspacePath, ".tostudy", "sessions");
 }
 async function saveModuleSummary(workspacePath, input2) {
   const dir = sessionsDir(workspacePath);
-  fs19.mkdirSync(dir, { recursive: true });
+  fs18.mkdirSync(dir, { recursive: true });
   const filename = `module-${input2.moduleId}-summary.md`;
-  const filePath = path23.join(dir, filename);
+  const filePath = path22.join(dir, filename);
   const header = [
     "---",
     `moduleId: ${input2.moduleId}`,
@@ -21749,17 +21782,17 @@ async function saveModuleSummary(workspacePath, input2) {
     "---",
     ""
   ].join("\n");
-  fs19.writeFileSync(filePath, header + input2.summary, { mode: 384 });
+  fs18.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 (!fs19.existsSync(dir)) return { moduleSummaries: [] };
-  const files = fs19.readdirSync(dir).filter((f) => f.startsWith("module-") && f.endsWith("-summary.md")).sort();
+  if (!fs18.existsSync(dir)) return { moduleSummaries: [] };
+  const files = fs18.readdirSync(dir).filter((f) => f.startsWith("module-") && f.endsWith("-summary.md")).sort();
   const summaries = [];
   for (const file2 of files) {
-    const content = fs19.readFileSync(path23.join(dir, file2), "utf-8");
+    const content = fs18.readFileSync(path22.join(dir, file2), "utf-8");
     const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
     if (!frontmatterMatch) continue;
     const meta3 = frontmatterMatch[1];
@@ -21781,7 +21814,7 @@ var init_storage = __esm({
 });
 
 // src/commands/compact.ts
-import fs20 from "node:fs";
+import fs19 from "node:fs";
 import { Command as Command26 } from "commander";
 var logger26, compactCommand;
 var init_compact = __esm({
@@ -21801,7 +21834,7 @@ var init_compact = __esm({
           if (opts.json) jsonError("no_workspace");
           error("Nenhum workspace encontrado.");
         }
-        const summary = fs20.readFileSync("/dev/stdin", "utf-8").trim();
+        const summary = fs19.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.");
@@ -22970,8 +23003,17 @@ __export(cli_exports, {
 import { Command as Command35 } from "commander";
 function createProgram() {
   const program2 = new Command35();
-  program2.name("tostudy").description("ToStudy CLI \u2014 study courses from the terminal").version(CLI_VERSION).option("--verbose", "Enable debug output").option("--course <id>", "Override active course ID").option("--locale <code>", "Output locale (pt-BR | en-US); defaults to LANG env then pt-BR");
-  program2.addCommand(setupCommand);
+  program2.name("tostudy").description("ToStudy CLI \u2014 study courses from the terminal").version(CLI_VERSION).option("--verbose", "Enable debug output").option("--course <id>", "Override active course ID").option("--locale <code>", "Output locale (pt-BR | en-US); defaults to LANG env then pt-BR").addHelpText(
+    "before",
+    [
+      "",
+      "  Come\xE7ando:   login \u2192 courses \u2192 select <n> \u2192 start",
+      "  Estudando:   next \xB7 lesson \xB7 hint \xB7 validate \xB7 theory \xB7 progress",
+      "  Com d\xFAvida:  tostudy menu  (mostra onde voc\xEA est\xE1 e o que fazer)",
+      ""
+    ].join("\n")
+  );
+  program2.addCommand(setupCommand, { hidden: true });
   program2.addCommand(doctorCommand);
   program2.addCommand(initCommand);
   program2.addCommand(loginCommand);
@@ -23055,11 +23097,11 @@ __export(auto_updater_exports, {
   detectManager: () => detectManager,
   maybeAutoUpdate: () => maybeAutoUpdate
 });
-import fs21 from "node:fs";
-import path24 from "node:path";
+import fs20 from "node:fs";
+import path23 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 function detectManager(entryRealPath) {
-  const p = entryRealPath.split(path24.sep).join("/");
+  const p = entryRealPath.split(path23.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}/`))
@@ -23067,10 +23109,10 @@ function detectManager(entryRealPath) {
   return null;
 }
 function installDir(entryRealPath) {
-  const normalized = entryRealPath.split(path24.sep).join("/");
+  const normalized = entryRealPath.split(path23.sep).join("/");
   const marker = `/node_modules/${PACKAGE_NAME2}/`;
   const idx = normalized.indexOf(marker);
-  if (idx === -1) return path24.dirname(entryRealPath);
+  if (idx === -1) return path23.dirname(entryRealPath);
   return entryRealPath.slice(0, idx + marker.length - 1);
 }
 function maybeAutoUpdate(currentVersion, opts = {}) {
@@ -23086,10 +23128,10 @@ function maybeAutoUpdate(currentVersion, opts = {}) {
     if (cache.attemptedVersion === cache.latest) return;
     const entryPath = opts.entryPath ?? argv[1];
     if (!entryPath) return;
-    const real = fs21.realpathSync(entryPath);
+    const real = fs20.realpathSync(entryPath);
     const mgr = detectManager(real);
     if (!mgr) return;
-    fs21.accessSync(installDir(real), fs21.constants.W_OK);
+    fs20.accessSync(installDir(real), fs20.constants.W_OK);
     writeCache({ ...cache, attemptedVersion: cache.latest }, configDir);
     process.stderr.write(
       `
@@ -23132,9 +23174,28 @@ Update at https://nodejs.org and run the command again.
   );
   process.exit(1);
 }
+if (!process.env["TOSTUDY_LOCALE"]) {
+  try {
+    const { readFileSync: readFileSync4 } = await import("node:fs");
+    const { join: join3 } = await import("node:path");
+    const { homedir: homedir2 } = await import("node:os");
+    const xdg = process.env["XDG_CONFIG_HOME"];
+    const dir = process.platform === "linux" && xdg ? join3(xdg, "tostudy") : join3(homedir2(), ".tostudy");
+    const { locale } = JSON.parse(readFileSync4(join3(dir, "config.json"), "utf-8"));
+    if (locale === "pt-BR" || locale === "en-US") process.env["TOSTUDY_LOCALE"] = locale;
+  } catch {
+  }
+}
 var { createProgram: createProgram2, CLI_VERSION: CLI_VERSION2 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
 var { checkForUpdates: checkForUpdates2 } = await Promise.resolve().then(() => (init_update_checker(), update_checker_exports));
 var { maybeAutoUpdate: maybeAutoUpdate2 } = await Promise.resolve().then(() => (init_auto_updater(), auto_updater_exports));
+process.on("unhandledRejection", (reason) => {
+  const msg = reason instanceof Error ? reason.message : String(reason);
+  process.stderr.write(`Erro: ${msg}
+  Se o problema continuar, rode: tostudy doctor
+`);
+  process.exit(1);
+});
 var program = createProgram2();
 program.parse();
 checkForUpdates2(CLI_VERSION2);