@tostudy-ai/cli 0.7.4 → 0.8.0

package/dist/cli.js

@@ -2280,6 +2280,7 @@ var init_mcp_setup = __esm({
 // src/workspace/instruction-files.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { join as join2 } from "node:path";
+import os4 from "node:os";
 function slugify(title) {
   return title.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
 }
@@ -2395,19 +2396,41 @@ ${rules.map((r, i) => `${i + 1}. ${r}`).join("\n")}`);
 | Aluno perdido / sem saber o que fazer | Rodar \`tostudy progress\` e resumir estado atual |
 | "Stop hook error" / "ECONNREFUSED" | Ignorar \u2014 problema de configura\xE7\xE3o do IDE, n\xE3o do ToStudy |`);
   if (ctx.workspaceReady !== false) {
+    const home = os4.homedir();
+    const cwd = process.cwd();
+    const isNamespaced = ctx.workspacePath === join2(cwd, ".tostudy");
+    const isFlatCwd = ctx.workspacePath === cwd;
+    const displayPath = ctx.workspacePath ? ctx.workspacePath.startsWith(home) ? ctx.workspacePath.replace(home, "~") : ctx.workspacePath : "~/study/{slug}/";
+    const vaultRelativeHint = isNamespaced ? "../vault-<slug>/              \u2190 Vault Obsidian (fora de .tostudy/)" : "vault-<slug>/                 \u2190 Vault Obsidian";
+    let locationHint;
+    if (isNamespaced) {
+      locationHint = [
+        "O workspace vive em **`.tostudy/`** nesta pasta \u2014 isolado do resto do projeto.",
+        "Os arquivos do projeto (src/, README.md, AGENTS.md...) permanecem intactos.",
+        "Os exerc\xEDcios s\xE3o extra\xEDdos dentro de `.tostudy/exercises/` e o assistente AI enxerga tudo normalmente.",
+        "",
+        "> \u26A0\uFE0F O **vault Obsidian** fica em `vault-<slug>/` **fora** de `.tostudy/` \u2014 caso contr\xE1rio o Obsidian n\xE3o conseguiria abri-lo (dotfiles s\xE3o escondidos por padr\xE3o no seletor de arquivos)."
+      ].join("\n");
+    } else if (isFlatCwd) {
+      locationHint = "O workspace \xE9 **esta pasta** \u2014 os exerc\xEDcios ficam aqui, vis\xEDveis para o assistente AI.";
+    } else {
+      locationHint = "O workspace local organiza os arquivos do curso:";
+    }
     sections.push(`## Workspace
 
-O workspace local organiza os arquivos do curso:
+${locationHint}
 
 \`\`\`
-~/study/{slug}/
+${displayPath}/
 \u251C\u2500\u2500 exercises/{m\xF3dulo}/{li\xE7\xE3o}/   \u2190 Exerc\xEDcios extra\xEDdos
 \u251C\u2500\u2500 generated/                    \u2190 Artefatos gerados
-\u2514\u2500\u2500 diagrams/                     \u2190 Diagramas
+\u251C\u2500\u2500 diagrams/                     \u2190 Diagramas
+\u2514\u2500\u2500 ${vaultRelativeHint}
 \`\`\`
 
 Comandos \xFAteis:
 - \`tostudy export\` \u2014 Extrair exerc\xEDcio para o workspace
+- \`tostudy vault init\` \u2014 Gerar vault Obsidian (abra no Obsidian: "Open folder as vault")
 - \`tostudy open\` \u2014 Abrir workspace no editor
 - \`tostudy workspace status\` \u2014 Verificar estado do workspace`);
   }
@@ -2582,10 +2605,10 @@ FIM DO M\xD3DULO:
 
 ## Workspace
 
-Quando o aluno precisar de um workspace local para exerc\xEDcios:
+Se esta pasta cont\xE9m \`.tostudy/\`, ela j\xE1 \xE9 o workspace \u2014 exerc\xEDcios ficam aqui.
+Caso contr\xE1rio, rode \`tostudy workspace setup\` para criar a estrutura.
 
-- \`tostudy workspace setup\` \u2014 Cria diret\xF3rios em ~/study/{slug}/
-- \`tostudy export\` \u2014 Extrai exerc\xEDcio para o workspace
+- \`tostudy export\` \u2014 Extrai exerc\xEDcio para o workspace (esta pasta ou ~/study/{slug}/)
 - \`tostudy open\` \u2014 Abre workspace no editor
 - \`tostudy workspace status\` \u2014 Verifica estado
 
@@ -2747,10 +2770,14 @@ async function runSetup(opts, deps = defaultDeps) {
   const activeCourse = await deps.getActiveCourse();
   const hasClaudeCmd = existsSync3(join3(cwd, ".claude", "commands", "tostudy.md"));
   const hasCursorRule = existsSync3(join3(cwd, ".cursor", "rules", "tostudy.mdc"));
+  const hasMcpConfig = existsSync3(join3(cwd, ".claude", "claude_desktop_config.json")) || existsSync3(join3(cwd, ".mcp.json"));
+  const hasClaudeIDE = detected.some((ide) => ide.name.toLowerCase().includes("claude"));
   deps.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");
   deps.log("  Setup completo!\n");
   if (activeCourse) {
     deps.log(`  Curso ativo: ${activeCourse.courseTitle}`);
+  } else {
+    deps.log("  Nenhum curso ativo \u2014 rode: tostudy courses");
   }
   if (hasClaudeCmd) {
     deps.log("  \u2192 No Claude Code, digite: /tostudy");
@@ -2759,6 +2786,9 @@ async function runSetup(opts, deps = defaultDeps) {
   } else {
     deps.log("  \u2192 Abra seu IDE e o tutor estar\xE1 dispon\xEDvel");
   }
+  if (hasClaudeIDE && !hasMcpConfig && !opts.mcp) {
+    deps.log("\n  \u{1F4A1} Dica: rode tostudy setup --mcp para habilitar ferramentas avan\xE7adas");
+  }
   deps.log("");
 }
 async function runSetupMcpSubcommand() {
@@ -2813,12 +2843,12 @@ __export(update_checker_exports, {
 });
 import fs4 from "node:fs";
 import path4 from "node:path";
-import os4 from "node:os";
+import os5 from "node:os";
 function getConfigDir2() {
   if (process.platform === "linux" && process.env["XDG_CONFIG_HOME"]) {
     return path4.join(process.env["XDG_CONFIG_HOME"], "tostudy");
   }
-  return path4.join(os4.homedir(), ".tostudy");
+  return path4.join(os5.homedir(), ".tostudy");
 }
 function readCache() {
   try {
@@ -3044,8 +3074,112 @@ var init_courses2 = __esm({
   }
 });
 
+// src/workspace/resolve.ts
+import fs5 from "node:fs/promises";
+import path5 from "node:path";
+import os6 from "node:os";
+function courseSlug(title) {
+  return title.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+}
+async function resolveWorkspace(courseTitle, basePath = DEFAULT_BASE) {
+  const slug = courseSlug(courseTitle);
+  const candidate = path5.join(basePath, slug);
+  try {
+    await fs5.access(path5.join(candidate, ".ana-config.json"));
+    return { found: true, workspacePath: candidate, source: "default" };
+  } catch {
+    return { found: false, workspacePath: null };
+  }
+}
+async function isCwdWorkspace(cwd = process.cwd()) {
+  return await resolveCwdWorkspacePath(cwd) !== null;
+}
+async function resolveCwdWorkspacePath(cwd = process.cwd()) {
+  const tostudyDir = path5.join(cwd, ".tostudy");
+  try {
+    const stat = await fs5.stat(tostudyDir);
+    if (stat.isDirectory()) return tostudyDir;
+  } catch {
+  }
+  try {
+    await fs5.access(path5.join(cwd, ".ana-config.json"));
+    return cwd;
+  } catch {
+    return null;
+  }
+}
+function resolveVaultPath(workspacePath, slug) {
+  const base = path5.basename(workspacePath) === ".tostudy" ? path5.dirname(workspacePath) : workspacePath;
+  return path5.join(base, `vault-${slug}`);
+}
+async function findExistingVault(workspacePath, slug) {
+  const slugged = resolveVaultPath(workspacePath, slug);
+  try {
+    await fs5.access(path5.join(slugged, ".ana-vault.json"));
+    return slugged;
+  } catch {
+  }
+  const legacy = path5.join(workspacePath, "vault");
+  try {
+    await fs5.access(path5.join(legacy, ".ana-vault.json"));
+    return legacy;
+  } catch {
+    return null;
+  }
+}
+async function resolveEffectiveWorkspace(courseTitle, storedPath, cwd = process.cwd(), defaultBasePath = DEFAULT_BASE) {
+  const cwdWorkspace = await resolveCwdWorkspacePath(cwd);
+  if (cwdWorkspace) {
+    return { found: true, workspacePath: cwdWorkspace, source: "cwd" };
+  }
+  if (storedPath) {
+    try {
+      await fs5.access(path5.join(storedPath, ".ana-config.json"));
+      return { found: true, workspacePath: storedPath, source: "stored" };
+    } catch {
+    }
+  }
+  const result = await resolveWorkspace(courseTitle, defaultBasePath);
+  if (result.found) {
+    return { ...result, source: "default" };
+  }
+  return { found: false, workspacePath: null };
+}
+var DEFAULT_BASE;
+var init_resolve = __esm({
+  "src/workspace/resolve.ts"() {
+    "use strict";
+    DEFAULT_BASE = path5.join(os6.homedir(), "study");
+  }
+});
+
+// src/onboarding/status.ts
+async function getCourseOnboardingStatus(activeCourse, configDir, cwd = process.cwd()) {
+  const onboardingState = await getCourseOnboardingState(activeCourse.courseId, configDir);
+  const initReady = Boolean(onboardingState?.initCompletedAt);
+  const ws = await resolveEffectiveWorkspace(
+    activeCourse.courseTitle,
+    onboardingState?.workspacePath,
+    cwd
+  );
+  return {
+    initReady,
+    workspaceReady: ws.found,
+    workspacePath: ws.workspacePath,
+    workspaceSource: ws.source
+  };
+}
+var init_status = __esm({
+  "src/onboarding/status.ts"() {
+    "use strict";
+    init_session();
+    init_resolve();
+  }
+});
+
 // src/commands/select.ts
 import { Command as Command6 } from "commander";
+import os7 from "node:os";
 var logger5, selectCommand;
 var init_select = __esm({
   "src/commands/select.ts"() {
@@ -3056,6 +3190,7 @@ var init_select = __esm({
     init_session();
     init_formatter();
     init_instruction_files();
+    init_status();
     logger5 = createLogger("cli:select");
     selectCommand = new Command6("select").description("Activate a course by ID or list index number").argument("<course>", "Course ID (UUID) or index number from `tostudy courses`").option("--json", "Output structured JSON").action(async (course, opts) => {
       try {
@@ -3088,6 +3223,12 @@ var init_select = __esm({
           courseTags: matched?.tags,
           courseLevel: matched?.level
         });
+        const activeCourseForStatus = {
+          courseId: detail.courseId,
+          courseTitle: detail.courseTitle,
+          enrollmentId
+        };
+        const onboarding = await getCourseOnboardingStatus(activeCourseForStatus);
         let courseSlug2 = "";
         try {
           courseSlug2 = generateInstructionFiles({
@@ -3096,7 +3237,9 @@ var init_select = __esm({
             progress: detail.progress,
             moduleCount: detail.moduleCount,
             lessonCount: detail.lessonCount,
-            courseDescription: detail.courseDescription
+            courseDescription: detail.courseDescription,
+            workspaceReady: onboarding.workspaceReady,
+            workspacePath: onboarding.workspacePath ?? void 0
           });
         } catch (err) {
           logger5.warn("Failed to generate instruction files", {
@@ -3104,13 +3247,36 @@ var init_select = __esm({
           });
         }
         if (opts.json) {
-          output({ ...detail, enrollmentId, courseSlug: courseSlug2 }, { json: true });
+          output(
+            {
+              ...detail,
+              enrollmentId,
+              courseSlug: courseSlug2,
+              workspacePath: onboarding.workspacePath,
+              workspaceSource: onboarding.workspaceSource
+            },
+            { json: true }
+          );
         } else {
           const slashCmd = courseSlug2 ? `/tostudy-${courseSlug2}` : "/tostudy";
+          const home = os7.homedir();
+          const cwd = process.cwd();
+          const namespacedPath = `${cwd}/.tostudy`;
+          let wsLine;
+          if (onboarding.workspacePath === namespacedPath) {
+            wsLine = `  Workspace: ${cwd.replace(home, "~")}/.tostudy/ (isolado do projeto)`;
+          } else if (onboarding.workspacePath === cwd) {
+            wsLine = `  Workspace: esta pasta (${cwd.replace(home, "~")})`;
+          } else if (onboarding.workspacePath) {
+            wsLine = `  Workspace: ${onboarding.workspacePath.replace(home, "~")}`;
+          } else {
+            wsLine = "  Workspace: rode `tostudy workspace setup` para configurar";
+          }
           output(
             [
               `\u2713 Curso ativado: ${detail.courseTitle}`,
               `  Progresso: ${detail.progress}%  |  ${detail.moduleCount} m\xF3dulos  |  ${detail.lessonCount} li\xE7\xF5es`,
+              wsLine,
               "",
               "  Arquivos de contexto criados para seu assistente AI.",
               "",
@@ -4709,7 +4875,7 @@ var init_query_promise = __esm({
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce(
-    (result2, { path: path15, field }, columnIndex) => {
+    (result2, { path: path14, field }, columnIndex) => {
       let decoder;
       if (is(field, Column)) {
         decoder = field;
@@ -4721,8 +4887,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         decoder = field.sql.decoder;
       }
       let node = result2;
-      for (const [pathChunkIndex, pathChunk] of path15.entries()) {
-        if (pathChunkIndex < path15.length - 1) {
+      for (const [pathChunkIndex, pathChunk] of path14.entries()) {
+        if (pathChunkIndex < path14.length - 1) {
           if (!(pathChunk in node)) {
             node[pathChunk] = {};
           }
@@ -4730,8 +4896,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         } else {
           const rawValue = row[columnIndex];
           const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
-          if (joinsNotNullableMap && is(field, Column) && path15.length === 2) {
-            const objectName = path15[0];
+          if (joinsNotNullableMap && is(field, Column) && path14.length === 2) {
+            const objectName = path14[0];
             if (!(objectName in nullifyMap)) {
               nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
             } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
@@ -8678,13 +8844,13 @@ function Subscribe(postgres2, options) {
       }
     }
     function handle(a, b2) {
-      const path15 = b2.relation.schema + "." + b2.relation.table;
+      const path14 = b2.relation.schema + "." + b2.relation.table;
       call("*", a, b2);
-      call("*:" + path15, a, b2);
-      b2.relation.keys.length && call("*:" + path15 + "=" + b2.relation.keys.map((x2) => a[x2.name]), a, b2);
+      call("*:" + path14, a, b2);
+      b2.relation.keys.length && call("*:" + path14 + "=" + b2.relation.keys.map((x2) => a[x2.name]), a, b2);
       call(b2.command, a, b2);
-      call(b2.command + ":" + path15, a, b2);
-      b2.relation.keys.length && call(b2.command + ":" + path15 + "=" + b2.relation.keys.map((x2) => a[x2.name]), a, b2);
+      call(b2.command + ":" + path14, a, b2);
+      b2.relation.keys.length && call(b2.command + ":" + path14 + "=" + b2.relation.keys.map((x2) => a[x2.name]), a, b2);
     }
     function pong() {
       const x2 = Buffer.alloc(34);
@@ -8797,8 +8963,8 @@ function parseEvent(x) {
   const xs = x.match(/^(\*|insert|update|delete)?:?([^.]+?\.?[^=]+)?=?(.+)?/i) || [];
   if (!xs)
     throw new Error("Malformed subscribe pattern: " + x);
-  const [, command, path15, key] = xs;
-  return (command || "*") + (path15 ? ":" + (path15.indexOf(".") === -1 ? "public." + path15 : path15) : "") + (key ? "=" + key : "");
+  const [, command, path14, key] = xs;
+  return (command || "*") + (path14 ? ":" + (path14.indexOf(".") === -1 ? "public." + path14 : path14) : "") + (key ? "=" + key : "");
 }
 var noop2;
 var init_subscribe = __esm({
@@ -8879,8 +9045,8 @@ var init_large = __esm({
 });
 
 // ../../node_modules/postgres/src/index.js
-import os5 from "os";
-import fs5 from "fs";
+import os8 from "os";
+import fs6 from "fs";
 function Postgres(a, b2) {
   const options = parseOptions(a, b2), subscribe = options.no_subscribe || Subscribe(Postgres, { ...options });
   let ending = false;
@@ -8936,10 +9102,10 @@ function Postgres(a, b2) {
       });
       return query;
     }
-    function file2(path15, args = [], options2 = {}) {
+    function file2(path14, args = [], options2 = {}) {
       arguments.length === 2 && !Array.isArray(args) && (options2 = args, args = []);
       const query = new Query([], args, (query2) => {
-        fs5.readFile(path15, "utf8", (err, string4) => {
+        fs6.readFile(path14, "utf8", (err, string4) => {
           if (err)
             return query2.reject(err);
           query2.strings = [string4];
@@ -9257,7 +9423,7 @@ function parseUrl(url2) {
 }
 function osUsername() {
   try {
-    return os5.userInfo().username;
+    return os8.userInfo().username;
   } catch (_) {
     return process.env.USERNAME || process.env.USER || process.env.LOGNAME;
   }
@@ -13518,12 +13684,12 @@ var init_session3 = __esm({
     init_tracing();
     init_utils();
     PostgresJsPreparedQuery = class extends PgPreparedQuery {
-      constructor(client, queryString, params, logger18, cache, queryMetadata, cacheConfig, fields, _isResponseInArrayMode, customResultMapper) {
+      constructor(client, queryString, params, logger19, cache, queryMetadata, cacheConfig, fields, _isResponseInArrayMode, customResultMapper) {
         super({ sql: queryString, params }, cache, queryMetadata, cacheConfig);
         this.client = client;
         this.queryString = queryString;
         this.params = params;
-        this.logger = logger18;
+        this.logger = logger19;
         this.fields = fields;
         this._isResponseInArrayMode = _isResponseInArrayMode;
         this.customResultMapper = customResultMapper;
@@ -13664,11 +13830,11 @@ function construct(client, config2 = {}) {
   client.options.serializers["114"] = transparentParser;
   client.options.serializers["3802"] = transparentParser;
   const dialect = new PgDialect({ casing: config2.casing });
-  let logger18;
+  let logger19;
   if (config2.logger === true) {
-    logger18 = new DefaultLogger();
+    logger19 = new DefaultLogger();
   } else if (config2.logger !== false) {
-    logger18 = config2.logger;
+    logger19 = config2.logger;
   }
   let schema;
   if (config2.schema) {
@@ -13682,7 +13848,7 @@ function construct(client, config2 = {}) {
       tableNamesMap: tablesConfig.tableNamesMap
     };
   }
-  const session = new PostgresJsSession(client, dialect, schema, { logger: logger18, cache: config2.cache });
+  const session = new PostgresJsSession(client, dialect, schema, { logger: logger19, cache: config2.cache });
   const db2 = new PostgresJsDatabase(dialect, session, schema);
   db2.$client = client;
   db2.$cache = config2.cache;
@@ -13884,7 +14050,7 @@ __export(util_exports, {
   required: () => required,
   safeExtend: () => safeExtend,
   shallowClone: () => shallowClone,
-  slugify: () => slugify3,
+  slugify: () => slugify2,
   stringifyPrimitive: () => stringifyPrimitive,
   uint8ArrayToBase64: () => uint8ArrayToBase64,
   uint8ArrayToBase64url: () => uint8ArrayToBase64url,
@@ -13997,10 +14163,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path15) {
-  if (!path15)
+function getElementAtPath(obj, path14) {
+  if (!path14)
     return obj;
-  return path15.reduce((acc, key) => acc?.[key], obj);
+  return path14.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -14024,7 +14190,7 @@ function randomString(length = 10) {
 function esc(str) {
   return JSON.stringify(str);
 }
-function slugify3(input2) {
+function slugify2(input2) {
   return input2.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
 }
 function isObject(data) {
@@ -14312,11 +14478,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path15, issues) {
+function prefixIssues(path14, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path15);
+    iss.path.unshift(path14);
     return iss;
   });
 }
@@ -14558,7 +14724,7 @@ function formatError(error49, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error49, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error50, path15 = []) => {
+  const processError = (error50, path14 = []) => {
     var _a2, _b;
     for (const issue2 of error50.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -14568,7 +14734,7 @@ function treeifyError(error49, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path15, ...issue2.path];
+        const fullpath = [...path14, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -14600,8 +14766,8 @@ function treeifyError(error49, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path15 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path15) {
+  const path14 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path14) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24158,7 +24324,7 @@ function _toUpperCase() {
 }
 // @__NO_SIDE_EFFECTS__
 function _slugify() {
-  return /* @__PURE__ */ _overwrite((input2) => slugify3(input2));
+  return /* @__PURE__ */ _overwrite((input2) => slugify2(input2));
 }
 // @__NO_SIDE_EFFECTS__
 function _array(Class2, element, params) {
@@ -27295,13 +27461,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path15 = ref.slice(1).split("/").filter(Boolean);
-  if (path15.length === 0) {
+  const path14 = ref.slice(1).split("/").filter(Boolean);
+  if (path14.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path15[0] === defsKey) {
-    const key = path15[1];
+  if (path14[0] === defsKey) {
+    const key = path14[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -28490,7 +28656,11 @@ var init_courses3 = __esm({
         // Learning Path Graph: Reference to migrated graph (null if not migrated)
         migratedToGraphId: uuid("migrated_to_graph_id"),
         // Study Channel Configuration: which channels are available for this course
-        channelConfig: jsonb("channel_config").$type()
+        channelConfig: jsonb("channel_config").$type(),
+        // Course Quality Dashboard: Cached health score (0-100 with tier + dimensions)
+        healthScore: jsonb("health_score").$type(),
+        // Certificate: AI-generated course summary for PDF certificates (max 200 chars)
+        certificateSummary: varchar("certificate_summary", { length: 200 })
       },
       (table) => ({
         creatorIdIdx: index("courses_creator_id_idx").on(table.creatorId),
@@ -32926,29 +33096,32 @@ var init_validation_attempts = __esm({
     init_users();
     init_enrollments();
     init_courses3();
-    validationAttempts2 = pgTable("validation_attempts", {
-      id: uuid("id").defaultRandom().primaryKey(),
-      lessonId: uuid("lesson_id").references(() => lessons.id, { onDelete: "cascade" }).notNull(),
-      userId: uuid("user_id").references(() => users.id, { onDelete: "cascade" }).notNull(),
-      passed: boolean("passed").notNull(),
-      score: text("score"),
-      // Store as text to support percentages like "85%"
-      feedback: text("feedback"),
-      missingCriteria: jsonb("missing_criteria").$type(),
-      attemptedAt: timestamp("attempted_at").defaultNow().notNull(),
-      // v2 — validation persistence & learning analytics
-      enrollmentId: uuid("enrollment_id").references(() => enrollments.id, { onDelete: "cascade" }),
-      courseId: uuid("course_id").references(() => courses.id, { onDelete: "cascade" }),
-      exerciseIndex: integer("exercise_index"),
-      solution: text("solution"),
-      criteriaResults: jsonb("criteria_results").$type(),
-      source: text("source").$type(),
-      duration: integer("duration")
-    }, (table) => [
-      index("va_user_lesson_exercise_idx").on(table.userId, table.lessonId, table.exerciseIndex),
-      index("va_course_lesson_passed_idx").on(table.courseId, table.lessonId, table.passed),
-      index("va_user_course_attempted_idx").on(table.userId, table.courseId, table.attemptedAt)
-    ]);
+    validationAttempts2 = pgTable(
+      "validation_attempts",
+      {
+        id: uuid("id").defaultRandom().primaryKey(),
+        lessonId: uuid("lesson_id").references(() => lessons.id, { onDelete: "cascade" }).notNull(),
+        userId: uuid("user_id").references(() => users.id, { onDelete: "cascade" }).notNull(),
+        passed: boolean("passed").notNull(),
+        score: real("score"),
+        feedback: text("feedback"),
+        missingCriteria: jsonb("missing_criteria").$type(),
+        attemptedAt: timestamp("attempted_at").defaultNow().notNull(),
+        // v2 — validation persistence & learning analytics
+        enrollmentId: uuid("enrollment_id").references(() => enrollments.id, { onDelete: "cascade" }),
+        courseId: uuid("course_id").references(() => courses.id, { onDelete: "cascade" }),
+        exerciseIndex: integer("exercise_index"),
+        solution: text("solution"),
+        criteriaResults: jsonb("criteria_results").$type(),
+        source: text("source").$type(),
+        duration: integer("duration")
+      },
+      (table) => [
+        index("va_user_lesson_exercise_idx").on(table.userId, table.lessonId, table.exerciseIndex),
+        index("va_course_lesson_passed_idx").on(table.courseId, table.lessonId, table.passed),
+        index("va_user_course_attempted_idx").on(table.userId, table.courseId, table.attemptedAt)
+      ]
+    );
   }
 });
 
@@ -35131,77 +35304,6 @@ var init_course_variants = __esm({
   }
 });
 
-// ../../packages/database/src/schema/_archived/user-credits.ts
-var transactionTypeEnum, userCredits2, creditTransactions2;
-var init_user_credits = __esm({
-  "../../packages/database/src/schema/_archived/user-credits.ts"() {
-    "use strict";
-    init_pg_core();
-    init_users();
-    transactionTypeEnum = pgEnum("transaction_type", [
-      "initial_grant",
-      // Credito inicial de $5
-      "purchase",
-      // Compra de creditos
-      "consumption",
-      // Consumo por uso de IA
-      "refund",
-      // Reembolso
-      "adjustment"
-      // Ajuste manual admin
-    ]);
-    userCredits2 = pgTable(
-      "user_credits",
-      {
-        id: uuid("id").primaryKey().defaultRandom(),
-        userId: uuid("user_id").references(() => users.id, { onDelete: "cascade" }).notNull().unique(),
-        /** Current balance in USD */
-        balance: decimal("balance", { precision: 10, scale: 4 }).notNull().default("0"),
-        /** Total consumed in USD (absolute value, always positive) */
-        totalConsumed: decimal("total_consumed", { precision: 10, scale: 4 }).notNull().default("0"),
-        /** Total purchased in USD */
-        totalPurchased: decimal("total_purchased", { precision: 10, scale: 4 }).notNull().default("0"),
-        createdAt: timestamp("created_at").defaultNow().notNull(),
-        updatedAt: timestamp("updated_at").defaultNow().notNull()
-      },
-      (table) => ({
-        userIdIdx: index("user_credits_user_id_idx").on(table.userId)
-      })
-    );
-    creditTransactions2 = pgTable(
-      "credit_transactions",
-      {
-        id: uuid("id").primaryKey().defaultRandom(),
-        userId: uuid("user_id").references(() => users.id, { onDelete: "restrict" }).notNull(),
-        type: transactionTypeEnum("type").notNull(),
-        /** Amount in USD (negative for consumption, positive for purchase/grant) */
-        amount: decimal("amount", { precision: 10, scale: 4 }).notNull(),
-        /** Balance after this transaction in USD */
-        balanceAfter: decimal("balance_after", { precision: 10, scale: 4 }).notNull(),
-        description: text("description"),
-        metadata: text("metadata"),
-        // JSON com detalhes (tokens, modelo, etc)
-        // Granular usage tracking columns
-        operation: varchar("operation", { length: 50 }),
-        // 'brainstorm_message', 'generation_outline', etc.
-        model: varchar("model", { length: 100 }),
-        // 'claude-sonnet-4-5-20250929'
-        inputTokens: integer("input_tokens"),
-        outputTokens: integer("output_tokens"),
-        latencyMs: integer("latency_ms"),
-        // DB FK to course_proposals preserved in migration; Drizzle ref removed for schema archival
-        proposalId: uuid("proposal_id"),
-        sessionId: uuid("session_id"),
-        createdAt: timestamp("created_at").defaultNow().notNull()
-      },
-      (table) => ({
-        userIdIdx: index("credit_transactions_user_id_idx").on(table.userId),
-        createdAtIdx: index("credit_transactions_created_at_idx").on(table.createdAt)
-      })
-    );
-  }
-});
-
 // ../../packages/database/src/schema/_archived/index.ts
 var init_archived = __esm({
   "../../packages/database/src/schema/_archived/index.ts"() {
@@ -35210,7 +35312,6 @@ var init_archived = __esm({
     init_course_matrices();
     init_matrix_modules();
     init_course_variants();
-    init_user_credits();
   }
 });
 
@@ -36417,7 +36518,6 @@ var init_system_config = __esm({
       "business.limits.free_brainstorm_sessions": "business.limits.free_brainstorm_sessions",
       // Feature Flags
       "feature.spark_chat_enabled": "feature.spark_chat_enabled",
-      "feature.ai_course_generation_enabled": "feature.ai_course_generation_enabled",
       "feature.analytics_enabled": "feature.analytics_enabled",
       "feature.mentorship_enabled": "feature.mentorship_enabled",
       "feature.community_enabled": "feature.community_enabled",
@@ -38896,7 +38996,6 @@ __export(schema_exports, {
   creditSubscriptionPlans: () => creditSubscriptionPlans,
   creditSubscriptionStatusEnum: () => creditSubscriptionStatusEnum,
   creditSubscriptions: () => creditSubscriptions,
-  creditTransactions: () => creditTransactions2,
   creditWalletTransactionTypeEnum: () => creditWalletTransactionTypeEnum,
   creditWalletTransactions: () => creditWalletTransactions,
   creditWallets: () => creditWallets,
@@ -39182,7 +39281,6 @@ __export(schema_exports, {
   testimonialStatusEnum: () => testimonialStatusEnum,
   threadStatusEnum: () => threadStatusEnum,
   toneEnum: () => toneEnum,
-  transactionTypeEnum: () => transactionTypeEnum,
   transactions: () => transactions2,
   transactionsRelations: () => transactionsRelations2,
   transferStatusEnum: () => transferStatusEnum,
@@ -39199,7 +39297,6 @@ __export(schema_exports, {
   userBadgesRelations: () => userBadgesRelations2,
   userChallengeScores: () => userChallengeScores,
   userChallengeScoresRelations: () => userChallengeScoresRelations,
-  userCredits: () => userCredits2,
   userFollows: () => userFollows2,
   userFollowsRelations: () => userFollowsRelations2,
   userPathEnrollments: () => userPathEnrollments,
@@ -40896,65 +40993,6 @@ var init_lessons2 = __esm({
   }
 });
 
-// src/workspace/resolve.ts
-import fs6 from "node:fs/promises";
-import path5 from "node:path";
-import os6 from "node:os";
-function courseSlug(title) {
-  return title.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
-}
-async function resolveWorkspace(courseTitle, basePath = DEFAULT_BASE) {
-  const slug = courseSlug(courseTitle);
-  const candidate = path5.join(basePath, slug);
-  try {
-    await fs6.access(path5.join(candidate, ".ana-config.json"));
-    return { found: true, workspacePath: candidate };
-  } catch {
-    return { found: false, workspacePath: null };
-  }
-}
-var DEFAULT_BASE;
-var init_resolve = __esm({
-  "src/workspace/resolve.ts"() {
-    "use strict";
-    DEFAULT_BASE = path5.join(os6.homedir(), "study");
-  }
-});
-
-// src/onboarding/status.ts
-import fs7 from "node:fs/promises";
-import path6 from "node:path";
-async function resolveStoredWorkspace(workspacePath) {
-  if (!workspacePath) return null;
-  try {
-    await fs7.access(path6.join(workspacePath, ".ana-config.json"));
-    return workspacePath;
-  } catch {
-    return null;
-  }
-}
-async function getCourseOnboardingStatus(activeCourse, configDir) {
-  const onboardingState = await getCourseOnboardingState(activeCourse.courseId, configDir);
-  const initReady = Boolean(onboardingState?.initCompletedAt);
-  let workspacePath = await resolveStoredWorkspace(onboardingState?.workspacePath);
-  if (!workspacePath) {
-    const resolvedWorkspace = await resolveWorkspace(activeCourse.courseTitle);
-    workspacePath = resolvedWorkspace.workspacePath;
-  }
-  return {
-    initReady,
-    workspaceReady: Boolean(workspacePath),
-    workspacePath
-  };
-}
-var init_status = __esm({
-  "src/onboarding/status.ts"() {
-    "use strict";
-    init_session();
-    init_resolve();
-  }
-});
-
 // src/commands/start.ts
 import { Command as Command8 } from "commander";
 async function runStart(opts, deps = defaultDeps2) {
@@ -41190,10 +41228,14 @@ var init_lesson = __esm({
           output(formatLessonContent(content), { json: false });
         }
         if (content.type === "exercise") {
-          const ws = await resolveWorkspace(activeCourse.courseTitle);
+          const onboardingState = await getCourseOnboardingState(activeCourse.courseId);
+          const ws = await resolveEffectiveWorkspace(
+            activeCourse.courseTitle,
+            onboardingState?.workspacePath
+          );
           if (!ws.found) {
             process.stderr.write(
-              "\n\u{1F4A1} Dica: rode `tostudy workspace setup` para criar um workspace local para exerc\xEDcios.\n"
+              "\n\u{1F4A1} Dica: rode `tostudy select` desta pasta para us\xE1-la como workspace, ou `tostudy workspace setup` para criar em ~/study/.\n"
             );
           }
         }
@@ -41270,8 +41312,8 @@ var init_exercises = __esm({
 });
 
 // src/commands/validate.ts
-import fs8 from "node:fs";
-import path7 from "node:path";
+import fs7 from "node:fs";
+import path6 from "node:path";
 import { Command as Command13 } from "commander";
 var logger12, validateCommand;
 var init_validate = __esm({
@@ -41296,17 +41338,17 @@ var init_validate = __esm({
         }
         let solution;
         if (opts.stdin) {
-          solution = fs8.readFileSync("/dev/stdin", "utf-8");
+          solution = fs7.readFileSync("/dev/stdin", "utf-8");
         } else if (file2) {
-          if (!fs8.existsSync(file2)) {
+          if (!fs7.existsSync(file2)) {
             error(`Arquivo n\xE3o encontrado: ${file2}`);
           }
-          solution = fs8.readFileSync(file2, "utf-8");
+          solution = fs7.readFileSync(file2, "utf-8");
         } else {
           error("Forne\xE7a um arquivo ou use --stdin.\n\nExemplo: tostudy validate resposta.md");
         }
         if (file2 && activeCourse.courseTags?.length) {
-          const ext = path7.extname(file2).toLowerCase();
+          const ext = path6.extname(file2).toLowerCase();
           const LANG_EXTENSIONS = {
             ".html": ["html", "html5"],
             ".css": ["css"],
@@ -41739,14 +41781,14 @@ var init_init = __esm({
 });
 
 // ../../packages/tostudy-core/src/workspace/setup-workspace.ts
-import fs9 from "node:fs/promises";
-import path8 from "node:path";
+import fs8 from "node:fs/promises";
+import path7 from "node:path";
 async function setupWorkspace(input2) {
-  const workspacePath = path8.join(input2.basePath, input2.courseSlug);
+  const workspacePath = path7.join(input2.basePath, input2.courseSlug);
   for (const dir of WORKSPACE_DIRS) {
-    await fs9.mkdir(path8.join(workspacePath, dir), { recursive: true });
+    await fs8.mkdir(path7.join(workspacePath, dir), { recursive: true });
   }
-  const configPath = path8.join(workspacePath, ".ana-config.json");
+  const configPath = path7.join(workspacePath, ".ana-config.json");
   const config2 = {
     courseId: input2.courseId,
     courseSlug: input2.courseSlug,
@@ -41756,7 +41798,7 @@ async function setupWorkspace(input2) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await fs9.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  await fs8.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
   const readme = [
     `# ${input2.courseName}`,
     "",
@@ -41781,7 +41823,7 @@ async function setupWorkspace(input2) {
     "tostudy vault sync      # Sincronizar progresso",
     "```"
   ].join("\n");
-  await fs9.writeFile(path8.join(workspacePath, "README.md"), readme, "utf-8");
+  await fs8.writeFile(path7.join(workspacePath, "README.md"), readme, "utf-8");
   return { workspacePath, directories: WORKSPACE_DIRS, configPath };
 }
 var WORKSPACE_DIRS;
@@ -41882,8 +41924,8 @@ var init_templates = __esm({
 });
 
 // ../../packages/tostudy-core/src/workspace/extract-exercise.ts
-import fs10 from "node:fs/promises";
-import path9 from "node:path";
+import fs9 from "node:fs/promises";
+import path8 from "node:path";
 function padOrder(n) {
   return String(n).padStart(2, "0");
 }
@@ -41907,16 +41949,16 @@ async function extractExercise(input2) {
   const { lessonData, exerciseTier, workspacePath } = input2;
   const moduleDir = `${padOrder(lessonData.moduleOrder)}-${lessonData.moduleSlug}`;
   const lessonDir = `${padOrder(lessonData.lessonOrder)}-${lessonData.lessonSlug}`;
-  const exercisePath = path9.join(workspacePath, "exercises", moduleDir, lessonDir);
-  await fs10.mkdir(exercisePath, { recursive: true });
+  const exercisePath = path8.join(workspacePath, "exercises", moduleDir, lessonDir);
+  await fs9.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 = path9.join(exercisePath, cleanPath);
-      await fs10.mkdir(path9.dirname(fullPath), { recursive: true });
-      await fs10.writeFile(fullPath, fileData.code, "utf-8");
+      const fullPath = path8.join(exercisePath, cleanPath);
+      await fs9.mkdir(path8.dirname(fullPath), { recursive: true });
+      await fs9.writeFile(fullPath, fileData.code, "utf-8");
       extractedFiles.push(cleanPath);
       hasStarterCode = true;
     }
@@ -41924,13 +41966,13 @@ async function extractExercise(input2) {
     const tierData = getTierData(lessonData.structuredData, exerciseTier);
     const tierCode = tierData?.code;
     if (tierCode) {
-      await fs10.writeFile(path9.join(exercisePath, "exercise.js"), tierCode, "utf-8");
+      await fs9.writeFile(path8.join(exercisePath, "exercise.js"), tierCode, "utf-8");
       extractedFiles.push("exercise.js");
       hasStarterCode = true;
     } else {
       const starter = getStarterCode(lessonData.structuredData);
       if (starter) {
-        await fs10.writeFile(path9.join(exercisePath, "exercise.js"), starter, "utf-8");
+        await fs9.writeFile(path8.join(exercisePath, "exercise.js"), starter, "utf-8");
         extractedFiles.push("exercise.js");
         hasStarterCode = true;
       }
@@ -41948,8 +41990,8 @@ async function extractExercise(input2) {
           ...exerciseDeps
         }
       };
-      await fs10.writeFile(
-        path9.join(exercisePath, "package.json"),
+      await fs9.writeFile(
+        path8.join(exercisePath, "package.json"),
         JSON.stringify(pkgJson, null, 2),
         "utf-8"
       );
@@ -41961,20 +42003,20 @@ async function extractExercise(input2) {
       );
       for (const [configFile, configContent] of Object.entries(scaffold.configs)) {
         if (!sandpackFileNames.has(configFile)) {
-          await fs10.writeFile(path9.join(exercisePath, configFile), configContent, "utf-8");
+          await fs9.writeFile(path8.join(exercisePath, configFile), configContent, "utf-8");
           extractedFiles.push(configFile);
         }
       }
       const setupSh = `#!/bin/sh
 ${scaffold.setupScript}
 `;
-      await fs10.writeFile(path9.join(exercisePath, "setup.sh"), setupSh, "utf-8");
+      await fs9.writeFile(path8.join(exercisePath, "setup.sh"), setupSh, "utf-8");
       extractedFiles.push("setup.sh");
     }
   }
   const readme = generateReadme(lessonData, exerciseTier);
-  const readmePath = path9.join(exercisePath, "README.md");
-  await fs10.writeFile(readmePath, readme, "utf-8");
+  const readmePath = path8.join(exercisePath, "README.md");
+  await fs9.writeFile(readmePath, readme, "utf-8");
   extractedFiles.push("README.md");
   return {
     exercisePath,
@@ -42046,9 +42088,9 @@ var init_workspace = __esm({
 
 // src/commands/workspace.ts
 import { Command as Command16 } from "commander";
-import path10 from "node:path";
-import os7 from "node:os";
-import fs11 from "node:fs/promises";
+import path9 from "node:path";
+import os9 from "node:os";
+import fs10 from "node:fs/promises";
 var logger14, workspaceCommand;
 var init_workspace2 = __esm({
   "src/commands/workspace.ts"() {
@@ -42056,31 +42098,67 @@ var init_workspace2 = __esm({
     init_src();
     init_workspace();
     init_session();
+    init_resolve();
     logger14 = createLogger("cli:workspace");
     workspaceCommand = new Command16("workspace").description(
       "Gerenciar workspace de estudo local"
     );
-    workspaceCommand.command("setup").description("Criar estrutura do workspace para o curso ativo").option("--path <dir>", "Diret\xF3rio base do workspace", path10.join(os7.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
+    workspaceCommand.command("setup").description("Criar estrutura do workspace para o curso ativo").option("--path <dir>", "Diret\xF3rio base do workspace (omita para usar a pasta atual)").option("--json", "Output structured JSON").action(async (opts) => {
       try {
         await requireSession();
         const activeCourse = await requireActiveCourse();
-        const result = await setupWorkspace({
-          courseId: activeCourse.courseId,
-          courseSlug: activeCourse.courseTitle.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 60),
-          courseName: activeCourse.courseTitle,
-          basePath: opts.path,
-          locale: "pt-BR"
-        });
-        await setCourseWorkspacePath(activeCourse.courseId, result.workspacePath);
+        const cwdIsWorkspace = await isCwdWorkspace(process.cwd());
+        let workspacePath;
+        let directories;
+        if (!opts.path && cwdIsWorkspace) {
+          const resolvedCwd = await resolveCwdWorkspacePath(process.cwd());
+          workspacePath = resolvedCwd ?? path9.join(process.cwd(), ".tostudy");
+          await fs10.mkdir(workspacePath, { recursive: true });
+          directories = ["exercises", "generated", "notes", "diagrams"];
+          for (const dir of directories) {
+            await fs10.mkdir(path9.join(workspacePath, dir), { recursive: true });
+          }
+          const configPath = path9.join(workspacePath, ".ana-config.json");
+          await fs10.writeFile(
+            configPath,
+            JSON.stringify(
+              {
+                courseId: activeCourse.courseId,
+                courseSlug: courseSlug(activeCourse.courseTitle),
+                courseName: activeCourse.courseTitle,
+                workspacePath,
+                locale: "pt-BR",
+                createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+                lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString()
+              },
+              null,
+              2
+            ),
+            "utf-8"
+          );
+        } else {
+          const basePath = opts.path ?? path9.join(os9.homedir(), "study");
+          const result2 = await setupWorkspace({
+            courseId: activeCourse.courseId,
+            courseSlug: courseSlug(activeCourse.courseTitle),
+            courseName: activeCourse.courseTitle,
+            basePath,
+            locale: "pt-BR"
+          });
+          workspacePath = result2.workspacePath;
+          directories = result2.directories;
+        }
+        await setCourseWorkspacePath(activeCourse.courseId, workspacePath);
+        const result = { workspacePath, directories };
         if (opts.json) {
           process.stdout.write(JSON.stringify(result, null, 2) + "\n");
         } else {
           process.stdout.write(
             `
-\u2705 Workspace criado em: ${result.workspacePath}
+\u2705 Workspace criado em: ${workspacePath}
 
 Diret\xF3rios:
-${result.directories.map((d) => `  \u{1F4C1} ${d}/`).join("\n")}
+${directories.map((d) => `  \u{1F4C1} ${d}/`).join("\n")}
 
 Pr\xF3ximo passo: tostudy export
 `
@@ -42093,62 +42171,68 @@ 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", path10.join(os7.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", path9.join(os9.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const activeCourse = await requireActiveCourse();
-        const courseSlug2 = activeCourse.courseTitle.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
-        const workspacePath = path10.join(opts.path, courseSlug2);
-        let configData = null;
-        try {
-          const raw = await fs11.readFile(path10.join(workspacePath, ".ana-config.json"), "utf-8");
-          configData = JSON.parse(raw);
-        } catch {
+        const onboardingState = await getCourseOnboardingState(activeCourse.courseId);
+        const ws = await resolveEffectiveWorkspace(
+          activeCourse.courseTitle,
+          onboardingState?.workspacePath,
+          process.cwd(),
+          opts.path
+        );
+        if (!ws.found || !ws.workspacePath) {
           process.stderr.write(
             "\u274C Workspace n\xE3o encontrado. Execute 'tostudy workspace setup' primeiro.\n"
           );
           process.exit(1);
         }
-        const exercisesDir = path10.join(workspacePath, "exercises");
+        const workspacePath = ws.workspacePath;
+        let configData = null;
+        try {
+          const raw = await fs10.readFile(path9.join(workspacePath, ".ana-config.json"), "utf-8");
+          configData = JSON.parse(raw);
+        } catch {
+          configData = null;
+        }
+        const exercisesDir = path9.join(workspacePath, "exercises");
         let exerciseCount = 0;
         try {
-          const moduleDirs = await fs11.readdir(exercisesDir);
+          const moduleDirs = await fs10.readdir(exercisesDir);
           for (const modDir of moduleDirs) {
-            const modPath = path10.join(exercisesDir, modDir);
-            const stat = await fs11.stat(modPath);
+            const modPath = path9.join(exercisesDir, modDir);
+            const stat = await fs10.stat(modPath);
             if (stat.isDirectory()) {
-              const lessonDirs = await fs11.readdir(modPath);
+              const lessonDirs = await fs10.readdir(modPath);
               for (const lessonDir of lessonDirs) {
-                const lessonPath = path10.join(modPath, lessonDir);
-                const lstat = await fs11.stat(lessonPath);
+                const lessonPath = path9.join(modPath, lessonDir);
+                const lstat = await fs10.stat(lessonPath);
                 if (lstat.isDirectory()) exerciseCount++;
               }
             }
           }
         } catch {
         }
-        const generatedDir = path10.join(workspacePath, "generated");
+        const generatedDir = path9.join(workspacePath, "generated");
         let artifactCount = 0;
         try {
-          const files = await fs11.readdir(generatedDir);
+          const files = await fs10.readdir(generatedDir);
           artifactCount = files.length;
         } catch {
         }
-        const diagramsDir = path10.join(workspacePath, "diagrams");
+        const diagramsDir = path9.join(workspacePath, "diagrams");
         let diagramCount = 0;
         try {
-          const files = await fs11.readdir(diagramsDir);
+          const files = await fs10.readdir(diagramsDir);
           diagramCount = files.length;
         } catch {
         }
-        const vaultDir = path10.join(workspacePath, "vault");
-        let hasVault = false;
-        try {
-          await fs11.access(path10.join(vaultDir, ".ana-vault.json"));
-          hasVault = true;
-        } catch {
-        }
+        const slug = courseSlug(activeCourse.courseTitle);
+        const foundVaultPath = await findExistingVault(workspacePath, slug);
+        const hasVault = foundVaultPath !== null;
         const status = {
           workspacePath,
+          workspaceSource: ws.source,
           course: activeCourse.courseTitle,
           courseId: activeCourse.courseId,
           exercisesExtracted: exerciseCount,
@@ -42160,11 +42244,12 @@ Pr\xF3ximo passo: tostudy export
         if (opts.json) {
           process.stdout.write(JSON.stringify(status, null, 2) + "\n");
         } else {
+          const sourceLabel = ws.source === "cwd" ? " (pasta atual)" : ws.source === "stored" ? " (configurado)" : ws.source === "default" ? " (~/study/)" : "";
           process.stdout.write(
             [
               "",
               `\u{1F4DA} **${activeCourse.courseTitle}**`,
-              `\u{1F4C1} ${workspacePath}`,
+              `\u{1F4C1} ${workspacePath}${sourceLabel}`,
               "",
               `  Exerc\xEDcios extra\xEDdos: ${exerciseCount}`,
               `  Artefatos exportados: ${artifactCount}`,
@@ -42187,8 +42272,9 @@ Pr\xF3ximo passo: tostudy export
 
 // src/commands/export.ts
 import { Command as Command17 } from "commander";
-import path11 from "node:path";
-import os8 from "node:os";
+import path10 from "node:path";
+import os10 from "node:os";
+import fs11 from "node:fs/promises";
 var logger15, exportCommand;
 var init_export = __esm({
   "src/commands/export.ts"() {
@@ -42199,7 +42285,7 @@ var init_export = __esm({
     init_session();
     init_resolve();
     logger15 = createLogger("cli:export");
-    exportCommand = new Command17("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", path11.join(os8.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
+    exportCommand = new Command17("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", path10.join(os10.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
         const activeCourse = await requireActiveCourse();
@@ -42209,10 +42295,57 @@ var init_export = __esm({
           process.stderr.write("\u274C Nenhuma li\xE7\xE3o ativa. Execute 'tostudy start' primeiro.\n");
           process.exit(1);
         }
-        const ws = await resolveWorkspace(activeCourse.courseTitle, opts.path);
-        if (!ws.found) {
+        const onboardingState = await getCourseOnboardingState(activeCourse.courseId);
+        const ws = await resolveEffectiveWorkspace(
+          activeCourse.courseTitle,
+          onboardingState?.workspacePath,
+          process.cwd(),
+          opts.path
+        );
+        if (ws.found && ws.source === "cwd" && ws.workspacePath) {
+          const configPath = path10.join(ws.workspacePath, ".ana-config.json");
+          let hasConfig = false;
+          try {
+            await fs11.access(configPath);
+            hasConfig = true;
+          } catch {
+          }
+          if (!hasConfig) {
+            const slug = courseSlug(activeCourse.courseTitle);
+            logger15.info("Auto-initializing workspace", { workspacePath: ws.workspacePath });
+            await fs11.mkdir(ws.workspacePath, { recursive: true });
+            for (const dir of ["exercises", "generated", "notes", "diagrams"]) {
+              await fs11.mkdir(path10.join(ws.workspacePath, dir), { recursive: true });
+            }
+            await fs11.writeFile(
+              configPath,
+              JSON.stringify(
+                {
+                  courseId: activeCourse.courseId,
+                  courseSlug: slug,
+                  courseName: activeCourse.courseTitle,
+                  workspacePath: ws.workspacePath,
+                  locale: "pt-BR",
+                  createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+                  lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString()
+                },
+                null,
+                2
+              ),
+              "utf-8"
+            );
+            await setCourseWorkspacePath(activeCourse.courseId, ws.workspacePath);
+            const isNamespaced = ws.workspacePath === path10.join(process.cwd(), ".tostudy");
+            process.stderr.write(
+              isNamespaced ? `\u2728 Workspace inicializado em .tostudy/ (isolado do projeto).
+` : `\u2728 Workspace inicializado nesta pasta.
+`
+            );
+          }
+        }
+        if (!ws.found || !ws.workspacePath) {
           process.stderr.write(
-            "\u274C Workspace n\xE3o encontrado. Execute 'tostudy workspace setup' primeiro.\n"
+            "\u274C Workspace n\xE3o encontrado. Execute 'tostudy workspace setup' ou rode 'tostudy select' desta pasta.\n"
           );
           process.exit(1);
         }
@@ -42255,45 +42388,41 @@ ${result.files.map((f) => `  \u{1F4C4} ${f}`).join("\n")}
 // src/commands/open.ts
 import { Command as Command18 } from "commander";
 import { execFile as execFile3 } from "node:child_process";
-import fs12 from "node:fs/promises";
-import path12 from "node:path";
-import os9 from "node:os";
-async function findWorkspacePath(courseTitle, basePath) {
-  const slug = courseTitle.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
-  const candidate = path12.join(basePath, slug);
-  try {
-    await fs12.access(path12.join(candidate, ".ana-config.json"));
-    return candidate;
-  } catch {
-    return null;
-  }
-}
+import path11 from "node:path";
+import os11 from "node:os";
 var logger16, openCommand;
 var init_open = __esm({
   "src/commands/open.ts"() {
     "use strict";
     init_src();
     init_session();
+    init_resolve();
     logger16 = createLogger("cli:open");
-    openCommand = new Command18("open").description("Abrir workspace do curso na IDE").option("--path <dir>", "Diret\xF3rio base do workspace", path12.join(os9.homedir(), "study")).action(async (opts) => {
+    openCommand = new Command18("open").description("Abrir workspace do curso na IDE").option("--path <dir>", "Diret\xF3rio base do workspace", path11.join(os11.homedir(), "study")).action(async (opts) => {
       try {
         const activeCourse = await requireActiveCourse();
-        const workspacePath = await findWorkspacePath(activeCourse.courseTitle, opts.path);
-        if (!workspacePath) {
+        const onboardingState = await getCourseOnboardingState(activeCourse.courseId);
+        const ws = await resolveEffectiveWorkspace(
+          activeCourse.courseTitle,
+          onboardingState?.workspacePath,
+          process.cwd(),
+          opts.path
+        );
+        if (!ws.found || !ws.workspacePath) {
           process.stderr.write(
             "\u274C Workspace n\xE3o encontrado. Execute 'tostudy workspace setup' primeiro.\n"
           );
           process.exit(1);
         }
         const editor = process.env["EDITOR"] ?? "code";
-        execFile3(editor, [workspacePath], (err) => {
+        execFile3(editor, [ws.workspacePath], (err) => {
           if (err) {
-            logger16.error("open failed", { editor, workspacePath });
+            logger16.error("open failed", { editor, workspacePath: ws.workspacePath });
             process.stderr.write(`\u274C Falha ao abrir: ${err.message}
 `);
             process.exit(1);
           }
-          process.stdout.write(`\u2705 Aberto em ${editor}: ${workspacePath}
+          process.stdout.write(`\u2705 Aberto em ${editor}: ${ws.workspacePath}
 `);
         });
       } catch (err) {
@@ -42324,24 +42453,24 @@ var init_types3 = __esm({
 });
 
 // ../../packages/tostudy-core/src/vault/write-vault.ts
-import fs13 from "node:fs/promises";
-import path13 from "node:path";
+import fs12 from "node:fs/promises";
+import path12 from "node:path";
 async function writeVaultFiles(files, outputPath, courseId, courseSlug2) {
   for (const file2 of files) {
-    const fullPath = path13.join(outputPath, file2.relativePath);
-    await fs13.mkdir(path13.dirname(fullPath), { recursive: true });
-    await fs13.writeFile(fullPath, file2.content, "utf-8");
+    const fullPath = path12.join(outputPath, file2.relativePath);
+    await fs12.mkdir(path12.dirname(fullPath), { recursive: true });
+    await fs12.writeFile(fullPath, file2.content, "utf-8");
   }
-  const vaultPath = path13.join(outputPath, courseSlug2);
+  const vaultPath = path12.join(outputPath, courseSlug2);
   const marker = {
     courseId,
     courseSlug: courseSlug2,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     version: VAULT_MARKER_VERSION
   };
-  await fs13.mkdir(vaultPath, { recursive: true });
-  await fs13.writeFile(
-    path13.join(vaultPath, VAULT_MARKER_FILENAME),
+  await fs12.mkdir(vaultPath, { recursive: true });
+  await fs12.writeFile(
+    path12.join(vaultPath, VAULT_MARKER_FILENAME),
     JSON.stringify(marker, null, 2),
     "utf-8"
   );
@@ -42366,9 +42495,9 @@ var init_vault = __esm({
 
 // src/commands/vault.ts
 import { Command as Command19 } from "commander";
-import path14 from "node:path";
-import os10 from "node:os";
-import fs14 from "node:fs/promises";
+import path13 from "node:path";
+import os12 from "node:os";
+import fs13 from "node:fs/promises";
 var logger17, vaultCommand;
 var init_vault2 = __esm({
   "src/commands/vault.ts"() {
@@ -42378,17 +42507,31 @@ var init_vault2 = __esm({
     init_courses();
     init_http2();
     init_session();
+    init_resolve();
     logger17 = createLogger("cli:vault");
     vaultCommand = new Command19("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", path14.join(os10.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", path13.join(os12.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
         const activeCourse = await requireActiveCourse();
         const driftWarning = await checkCourseDrift();
         if (driftWarning) process.stderr.write(driftWarning + "\n");
-        const courseSlug2 = activeCourse.courseTitle.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
-        const workspacePath = path14.join(opts.path, courseSlug2);
-        const vaultOutputPath = path14.join(workspacePath, "vault");
+        const onboardingState = await getCourseOnboardingState(activeCourse.courseId);
+        const ws = await resolveEffectiveWorkspace(
+          activeCourse.courseTitle,
+          onboardingState?.workspacePath,
+          process.cwd(),
+          opts.path
+        );
+        if (!ws.found || !ws.workspacePath) {
+          process.stderr.write(
+            "\u274C Workspace n\xE3o encontrado. Execute 'tostudy workspace setup' primeiro.\n"
+          );
+          process.exit(1);
+        }
+        const slug = courseSlug(activeCourse.courseTitle);
+        const workspacePath = ws.workspacePath;
+        const vaultOutputPath = resolveVaultPath(workspacePath, slug);
         const res = await fetch(`${session.apiUrl}/api/cli/vault/init`, {
           method: "POST",
           headers: {
@@ -42410,7 +42553,7 @@ var init_vault2 = __esm({
           data.files,
           vaultOutputPath,
           activeCourse.courseId,
-          courseSlug2
+          slug
         );
         logger17.info("Vault generated", {
           courseId: activeCourse.courseId,
@@ -42451,25 +42594,36 @@ 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", path14.join(os10.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", path13.join(os12.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
         const activeCourse = await requireActiveCourse();
         const driftWarning = await checkCourseDrift();
         if (driftWarning) process.stderr.write(driftWarning + "\n");
-        const courseSlug2 = activeCourse.courseTitle.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
-        const vaultPath = path14.join(opts.path, courseSlug2, "vault");
-        try {
-          await fs14.access(path14.join(vaultPath, ".ana-vault.json"));
-        } catch {
+        const onboardingState = await getCourseOnboardingState(activeCourse.courseId);
+        const ws = await resolveEffectiveWorkspace(
+          activeCourse.courseTitle,
+          onboardingState?.workspacePath,
+          process.cwd(),
+          opts.path
+        );
+        if (!ws.found || !ws.workspacePath) {
+          process.stderr.write(
+            "\u274C Workspace n\xE3o encontrado. Execute 'tostudy workspace setup' primeiro.\n"
+          );
+          process.exit(1);
+        }
+        const slug = courseSlug(activeCourse.courseTitle);
+        const vaultPath = await findExistingVault(ws.workspacePath, slug);
+        if (!vaultPath) {
           process.stderr.write("\u274C Vault n\xE3o encontrado. Execute 'tostudy vault init' primeiro.\n");
           process.exit(1);
         }
         const data = createHttpProvider(session.apiUrl, session.token);
         const deps = { data, logger: logger17 };
         const progress3 = await getProgress({ enrollmentId: activeCourse.enrollmentId }, deps);
-        const markerPath = path14.join(vaultPath, ".ana-vault.json");
-        const markerRaw = await fs14.readFile(markerPath, "utf-8");
+        const markerPath = path13.join(vaultPath, ".ana-vault.json");
+        const markerRaw = await fs13.readFile(markerPath, "utf-8");
         const marker = JSON.parse(markerRaw);
         marker.lastSyncedAt = (/* @__PURE__ */ new Date()).toISOString();
         marker.progress = {
@@ -42477,10 +42631,10 @@ Para visualizar:
           currentModule: progress3.currentModule.title,
           currentLesson: progress3.currentLesson.title
         };
-        await fs14.writeFile(markerPath, JSON.stringify(marker, null, 2), "utf-8");
-        const courseIndexPath = path14.join(vaultPath, courseSlug2, "index.md");
+        await fs13.writeFile(markerPath, JSON.stringify(marker, null, 2), "utf-8");
+        const courseIndexPath = path13.join(vaultPath, slug, "index.md");
         try {
-          let indexContent = await fs14.readFile(courseIndexPath, "utf-8");
+          let indexContent = await fs13.readFile(courseIndexPath, "utf-8");
           indexContent = indexContent.replace(/\n---\n\n> 📊 Progresso:.*\n/g, "");
           const titleEnd = indexContent.indexOf("\n");
           if (titleEnd !== -1) {
@@ -42491,7 +42645,7 @@ Para visualizar:
 `;
             indexContent = indexContent.slice(0, titleEnd) + banner + indexContent.slice(titleEnd);
           }
-          await fs14.writeFile(courseIndexPath, indexContent, "utf-8");
+          await fs13.writeFile(courseIndexPath, indexContent, "utf-8");
         } catch {
         }
         const syncedAt = marker.lastSyncedAt;
@@ -42596,15 +42750,85 @@ var init_profile = __esm({
   }
 });
 
+// src/commands/sync.ts
+import { Command as Command21 } from "commander";
+var logger18, syncCommand;
+var init_sync = __esm({
+  "src/commands/sync.ts"() {
+    "use strict";
+    init_src();
+    init_courses();
+    init_http2();
+    init_session();
+    init_formatter();
+    init_instruction_files();
+    init_status();
+    logger18 = createLogger("cli:sync");
+    syncCommand = new Command21("sync").description("Regenerate instruction files with updated progress").option("--json", "Output structured JSON").action(async (opts) => {
+      try {
+        const session = await requireSession();
+        const activeCourse = await requireActiveCourse();
+        const data = createHttpProvider(session.apiUrl, session.token);
+        const deps = { data, logger: logger18 };
+        const [courses3, progressData] = await Promise.all([
+          listCourses({ userId: session.userId }, deps),
+          getProgress({ enrollmentId: activeCourse.enrollmentId }, deps).catch(() => null)
+        ]);
+        const matchedCourse = courses3.find((c) => c.courseId === activeCourse.courseId);
+        if (!matchedCourse) {
+          error("Curso ativo n\xE3o encontrado. Rode `tostudy courses` para verificar.");
+        }
+        const onboardingState = await getCourseOnboardingState(activeCourse.courseId);
+        const onboarding = await getCourseOnboardingStatus(activeCourse);
+        const slug = generateInstructionFiles(
+          {
+            courseTitle: matchedCourse.title,
+            courseId: activeCourse.courseId,
+            progress: progressData?.coursePercent ?? matchedCourse.progress ?? 0,
+            moduleCount: progressData?.currentModule?.totalModules ?? 0,
+            lessonCount: progressData?.currentLesson?.totalLessons ?? 0,
+            currentModuleTitle: progressData?.currentModule?.title,
+            currentLessonTitle: progressData?.currentLesson?.title,
+            courseDescription: matchedCourse.description ?? void 0,
+            workspaceReady: onboarding.workspaceReady,
+            workspacePath: onboarding.workspacePath ?? void 0
+          },
+          onboardingState?.learnerProfile
+        );
+        if (opts.json) {
+          output(
+            {
+              status: "ok",
+              courseId: activeCourse.courseId,
+              slug,
+              progress: progressData?.coursePercent ?? matchedCourse.progress ?? 0
+            },
+            { json: true }
+          );
+        } else {
+          const progress3 = progressData?.coursePercent ?? matchedCourse.progress ?? 0;
+          output(`\u2713 Instru\xE7\xF5es sincronizadas para "${matchedCourse.title}" (${progress3}%)`, {
+            json: false
+          });
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("process.exit")) return;
+        error(msg);
+      }
+    });
+  }
+});
+
 // src/cli.ts
 var cli_exports = {};
 __export(cli_exports, {
   CLI_VERSION: () => CLI_VERSION,
   createProgram: () => createProgram
 });
-import { Command as Command21 } from "commander";
+import { Command as Command22 } from "commander";
 function createProgram() {
-  const program2 = new Command21();
+  const program2 = new Command22();
   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");
   program2.addCommand(setupCommand);
   program2.addCommand(doctorCommand);
@@ -42623,6 +42847,7 @@ function createProgram() {
   program2.addCommand(menuCommand);
   program2.addCommand(profileCommand);
   program2.addCommand(workspaceCommand);
+  program2.addCommand(syncCommand);
   program2.addCommand(exportCommand);
   program2.addCommand(openCommand);
   program2.addCommand(vaultCommand);
@@ -42652,7 +42877,8 @@ var init_cli = __esm({
     init_open();
     init_vault2();
     init_profile();
-    CLI_VERSION = true ? "0.7.4" : "0.7.1";
+    init_sync();
+    CLI_VERSION = true ? "0.8.0" : "0.7.1";
   }
 });