@tostudy-ai/cli 0.7.4 → 0.9.0

package/dist/cli.js

@@ -1289,29 +1289,227 @@ var init_secret_store = __esm({
   }
 });
 
-// src/auth/session.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
+// src/workspace/workspace-marker.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync } from "node:fs";
 import os2 from "node:os";
+import path2 from "node:path";
+function resolveMarkerPath(workspacePath) {
+  if (path2.basename(workspacePath) === ".tostudy") {
+    return path2.join(workspacePath, "workspace.json");
+  }
+  return path2.join(workspacePath, ".tostudy", "workspace.json");
+}
+async function readWorkspaceMarker(workspacePath) {
+  const filePath = resolveMarkerPath(workspacePath);
+  if (!existsSync2(filePath)) return null;
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== CURRENT_VERSION) return null;
+    if (typeof parsed.courseId !== "string" || typeof parsed.enrollmentId !== "string" || typeof parsed.slug !== "string" || typeof parsed.courseTitle !== "string" || typeof parsed.createdAt !== "string" || typeof parsed.updatedAt !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeWorkspaceMarker(workspacePath, input2, options = {}) {
+  const homeDir = path2.resolve(options.homeDir ?? os2.homedir());
+  const resolvedWorkspace = path2.resolve(workspacePath);
+  if (resolvedWorkspace === homeDir || homeDir.startsWith(resolvedWorkspace + path2.sep)) {
+    throw new Error(
+      `Refusing to write workspace marker at ${workspacePath}: it is the home directory or an ancestor of it.`
+    );
+  }
+  const filePath = resolveMarkerPath(workspacePath);
+  const dir = path2.dirname(filePath);
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  const existing = await readWorkspaceMarker(workspacePath);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const marker = {
+    version: CURRENT_VERSION,
+    courseId: input2.courseId,
+    enrollmentId: input2.enrollmentId,
+    slug: input2.slug,
+    courseTitle: input2.courseTitle,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now
+  };
+  writeFileSync2(filePath, JSON.stringify(marker, null, 2), { mode: 384 });
+  return filePath;
+}
+var CURRENT_VERSION;
+var init_workspace_marker = __esm({
+  "src/workspace/workspace-marker.ts"() {
+    "use strict";
+    CURRENT_VERSION = 1;
+  }
+});
+
+// src/workspace/resolve.ts
+var resolve_exports = {};
+__export(resolve_exports, {
+  courseSlug: () => courseSlug,
+  findCwdWorkspaceUpwards: () => findCwdWorkspaceUpwards,
+  findExistingVault: () => findExistingVault,
+  isCwdWorkspace: () => isCwdWorkspace,
+  resolveActiveCourseWithOverride: () => resolveActiveCourseWithOverride,
+  resolveCwdWorkspacePath: () => resolveCwdWorkspacePath,
+  resolveEffectiveWorkspace: () => resolveEffectiveWorkspace,
+  resolveVaultPath: () => resolveVaultPath,
+  resolveWorkspace: () => resolveWorkspace
+});
+import fs2 from "node:fs/promises";
+import path3 from "node:path";
+import os3 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 = path3.join(basePath, slug);
+  try {
+    await fs2.access(path3.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 = path3.join(cwd, ".tostudy");
+  try {
+    const stat = await fs2.stat(tostudyDir);
+    if (stat.isDirectory()) return tostudyDir;
+  } catch {
+  }
+  try {
+    await fs2.access(path3.join(cwd, ".ana-config.json"));
+    return cwd;
+  } catch {
+    return null;
+  }
+}
+async function findCwdWorkspaceUpwards(startCwd = process.cwd(), homeDir = os3.homedir()) {
+  const home = path3.resolve(homeDir);
+  let current = path3.resolve(startCwd);
+  while (true) {
+    if (current === home) return null;
+    const direct = await resolveCwdWorkspacePath(current);
+    if (direct) return direct;
+    const parent = path3.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function resolveVaultPath(workspacePath, slug) {
+  const base = path3.basename(workspacePath) === ".tostudy" ? path3.dirname(workspacePath) : workspacePath;
+  return path3.join(base, `vault-${slug}`);
+}
+async function findExistingVault(workspacePath, slug) {
+  const slugged = resolveVaultPath(workspacePath, slug);
+  try {
+    await fs2.access(path3.join(slugged, ".ana-vault.json"));
+    return slugged;
+  } catch {
+  }
+  const legacy = path3.join(workspacePath, "vault");
+  try {
+    await fs2.access(path3.join(legacy, ".ana-vault.json"));
+    return legacy;
+  } catch {
+    return null;
+  }
+}
+async function resolveEffectiveWorkspace(courseTitle, storedPath, cwd = process.cwd(), defaultBasePath = DEFAULT_BASE, homeDir = os3.homedir()) {
+  const cwdWorkspace = await findCwdWorkspaceUpwards(cwd, homeDir);
+  if (cwdWorkspace) {
+    return { found: true, workspacePath: cwdWorkspace, source: "cwd" };
+  }
+  if (storedPath) {
+    try {
+      await fs2.access(path3.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 };
+}
+async function findWorkspaceMarkerUpwards(startCwd, homeDir) {
+  const home = path3.resolve(homeDir);
+  let current = path3.resolve(startCwd);
+  while (true) {
+    if (current === home) return null;
+    const marker = await readWorkspaceMarker(current);
+    if (marker) return marker;
+    const parent = path3.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+async function resolveActiveCourseWithOverride(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const homeDir = options.homeDir ?? os3.homedir();
+  const marker = await findWorkspaceMarkerUpwards(cwd, homeDir);
+  if (marker) {
+    return {
+      courseId: marker.courseId,
+      enrollmentId: marker.enrollmentId,
+      courseTitle: marker.courseTitle,
+      source: "cwd-marker"
+    };
+  }
+  const global = await getActiveCourse(options.configDir);
+  if (!global) return null;
+  return {
+    courseId: global.courseId,
+    enrollmentId: global.enrollmentId,
+    courseTitle: global.courseTitle,
+    source: "global"
+  };
+}
+var DEFAULT_BASE;
+var init_resolve = __esm({
+  "src/workspace/resolve.ts"() {
+    "use strict";
+    init_workspace_marker();
+    init_session();
+    DEFAULT_BASE = path3.join(os3.homedir(), "study");
+  }
+});
+
+// src/auth/session.ts
+import fs3 from "node:fs";
+import path4 from "node:path";
+import os4 from "node:os";
 function getConfigDir(override) {
   if (override) return override;
   if (process.platform === "linux" && process.env["XDG_CONFIG_HOME"]) {
-    return path2.join(process.env["XDG_CONFIG_HOME"], "tostudy");
+    return path4.join(process.env["XDG_CONFIG_HOME"], "tostudy");
   }
-  return path2.join(os2.homedir(), ".tostudy");
+  return path4.join(os4.homedir(), ".tostudy");
 }
 function getCourseOnboardingPath(configDir) {
-  return path2.join(getConfigDir(configDir), "course-onboarding.json");
+  return path4.join(getConfigDir(configDir), "course-onboarding.json");
 }
 function readCourseOnboardingState(configDir) {
   const onboardingPath = getCourseOnboardingPath(configDir);
-  if (!fs2.existsSync(onboardingPath)) return {};
-  return JSON.parse(fs2.readFileSync(onboardingPath, "utf-8"));
+  if (!fs3.existsSync(onboardingPath)) return {};
+  return JSON.parse(fs3.readFileSync(onboardingPath, "utf-8"));
 }
 function writeCourseOnboardingState(state, configDir) {
   const dir = getConfigDir(configDir);
-  fs2.mkdirSync(dir, { recursive: true });
-  fs2.writeFileSync(getCourseOnboardingPath(configDir), JSON.stringify(state, null, 2), {
+  fs3.mkdirSync(dir, { recursive: true });
+  fs3.writeFileSync(getCourseOnboardingPath(configDir), JSON.stringify(state, null, 2), {
     mode: 384
   });
 }
@@ -1343,27 +1541,27 @@ async function saveCourseLearnerProfile(course, learnerProfile, artifacts, confi
   await saveUserProfile(learnerProfile, configDir);
 }
 function getUserProfilePath(configDir) {
-  return path2.join(getConfigDir(configDir), "user-profile.json");
+  return path4.join(getConfigDir(configDir), "user-profile.json");
 }
 async function getUserProfile(configDir) {
   const profilePath = getUserProfilePath(configDir);
-  if (!fs2.existsSync(profilePath)) return null;
+  if (!fs3.existsSync(profilePath)) return null;
   try {
-    return JSON.parse(fs2.readFileSync(profilePath, "utf-8"));
+    return JSON.parse(fs3.readFileSync(profilePath, "utf-8"));
   } catch {
     return null;
   }
 }
 async function saveUserProfile(profile, configDir) {
   const dir = getConfigDir(configDir);
-  fs2.mkdirSync(dir, { recursive: true });
-  fs2.writeFileSync(getUserProfilePath(configDir), JSON.stringify(profile, null, 2), {
+  fs3.mkdirSync(dir, { recursive: true });
+  fs3.writeFileSync(getUserProfilePath(configDir), JSON.stringify(profile, null, 2), {
     mode: 384
   });
 }
 async function saveSession(session, configDir) {
   const dir = getConfigDir(configDir);
-  fs2.mkdirSync(dir, { recursive: true });
+  fs3.mkdirSync(dir, { recursive: true });
   await saveSessionSecrets(
     {
       accessToken: session.token,
@@ -1378,15 +1576,15 @@ async function saveSession(session, configDir) {
     apiUrl: session.apiUrl,
     sessionId: session.sessionId
   };
-  fs2.writeFileSync(path2.join(dir, "config.json"), JSON.stringify(stored, null, 2), {
+  fs3.writeFileSync(path4.join(dir, "config.json"), JSON.stringify(stored, null, 2), {
     mode: 384
   });
 }
 async function getSession(configDir) {
   const dir = getConfigDir(configDir);
-  const p = path2.join(dir, "config.json");
-  if (!fs2.existsSync(p)) return null;
-  const stored = JSON.parse(fs2.readFileSync(p, "utf-8"));
+  const p = path4.join(dir, "config.json");
+  if (!fs3.existsSync(p)) return null;
+  const stored = JSON.parse(fs3.readFileSync(p, "utf-8"));
   const secrets = await loadStoredSessionSecrets(dir);
   if (!secrets) return null;
   return {
@@ -1401,26 +1599,26 @@ async function getSession(configDir) {
 }
 async function clearSession(configDir) {
   const dir = getConfigDir(configDir);
-  const p = path2.join(dir, "config.json");
-  if (fs2.existsSync(p)) fs2.unlinkSync(p);
-  const ap = path2.join(dir, "active-course.json");
-  if (fs2.existsSync(ap)) fs2.unlinkSync(ap);
+  const p = path4.join(dir, "config.json");
+  if (fs3.existsSync(p)) fs3.unlinkSync(p);
+  const ap = path4.join(dir, "active-course.json");
+  if (fs3.existsSync(ap)) fs3.unlinkSync(ap);
   const onboardingPath = getCourseOnboardingPath(configDir);
-  if (fs2.existsSync(onboardingPath)) fs2.unlinkSync(onboardingPath);
+  if (fs3.existsSync(onboardingPath)) fs3.unlinkSync(onboardingPath);
   await deleteStoredSessionSecrets(dir);
 }
 async function getActiveCourse(configDir) {
   const dir = getConfigDir(configDir);
-  const p = path2.join(dir, "active-course.json");
-  if (!fs2.existsSync(p)) return null;
-  return JSON.parse(fs2.readFileSync(p, "utf-8"));
+  const p = path4.join(dir, "active-course.json");
+  if (!fs3.existsSync(p)) return null;
+  return JSON.parse(fs3.readFileSync(p, "utf-8"));
 }
 async function setActiveCourse(course, configDir) {
   const dir = getConfigDir(configDir);
-  fs2.mkdirSync(dir, { recursive: true });
+  fs3.mkdirSync(dir, { recursive: true });
   const onboardingState = await getCourseOnboardingState(course.courseId, configDir);
   const persistedCourse = onboardingState?.initCompletedAt && !course.lastInitCourseId ? { ...course, lastInitCourseId: course.courseId } : course;
-  fs2.writeFileSync(path2.join(dir, "active-course.json"), JSON.stringify(persistedCourse, null, 2), {
+  fs3.writeFileSync(path4.join(dir, "active-course.json"), JSON.stringify(persistedCourse, null, 2), {
     mode: 384
   });
 }
@@ -1466,13 +1664,23 @@ async function requireSession(configDir) {
   }
   return session;
 }
-async function requireActiveCourse(configDir) {
-  const course = await getActiveCourse(configDir);
-  if (!course) {
-    process.stderr.write("Erro: Nenhum curso ativo. Rode: tostudy select <curso>\n");
-    process.exit(3);
+async function requireActiveCourse(configDir, options = {}) {
+  if (options.respectWorkspace) {
+    const { resolveActiveCourseWithOverride: resolveActiveCourseWithOverride2 } = await Promise.resolve().then(() => (init_resolve(), resolve_exports));
+    const resolved = await resolveActiveCourseWithOverride2({ configDir });
+    if (resolved) {
+      return {
+        courseId: resolved.courseId,
+        enrollmentId: resolved.enrollmentId,
+        courseTitle: resolved.courseTitle
+      };
+    }
+  } else {
+    const course = await getActiveCourse(configDir);
+    if (course) return course;
   }
-  return course;
+  process.stderr.write("Erro: Nenhum curso ativo. Rode: tostudy select <curso>\n");
+  process.exit(3);
 }
 async function setLastInitCourseId(courseId, configDir) {
   const existing = await getActiveCourse(configDir);
@@ -2153,34 +2361,34 @@ var init_node_detector = __esm({
 
 // src/installer/ide-detector.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import fs3 from "node:fs";
-import path3 from "node:path";
-import os3 from "node:os";
+import fs4 from "node:fs";
+import path5 from "node:path";
+import os5 from "node:os";
 function checkExists(p) {
-  return fs3.existsSync(p);
+  return fs4.existsSync(p);
 }
 function detectIDEs() {
-  const home = os3.homedir();
+  const home = os5.homedir();
   const ides = [
     // Claude Code: detected by presence of 'claude' binary
     {
       name: "Claude Code",
       id: "claude-code",
       detected: false,
-      configPath: path3.join(home, ".mcp.json")
+      configPath: path5.join(home, ".mcp.json")
     },
     // Cursor: ~/.cursor directory
     {
       name: "Cursor",
       id: "cursor",
-      detected: checkExists(path3.join(home, ".cursor")),
-      configPath: path3.join(home, ".cursor", "mcp.json")
+      detected: checkExists(path5.join(home, ".cursor")),
+      configPath: path5.join(home, ".cursor", "mcp.json")
     },
     // VS Code: ~/.vscode directory
     {
       name: "VS Code",
       id: "vscode",
-      detected: checkExists(path3.join(home, ".vscode")),
+      detected: checkExists(path5.join(home, ".vscode")),
       configPath: ".vscode/mcp.json"
     },
     // Claude Desktop: platform-specific config dir
@@ -2188,29 +2396,29 @@ function detectIDEs() {
       name: "Claude Desktop",
       id: "desktop",
       detected: checkExists(
-        process.platform === "darwin" ? path3.join(home, "Library", "Application Support", "Claude") : process.platform === "win32" ? path3.join(process.env["APPDATA"] ?? home, "Claude") : path3.join(home, ".config", "claude")
+        process.platform === "darwin" ? path5.join(home, "Library", "Application Support", "Claude") : process.platform === "win32" ? path5.join(process.env["APPDATA"] ?? home, "Claude") : path5.join(home, ".config", "claude")
       ),
-      configPath: process.platform === "darwin" ? path3.join(
+      configPath: process.platform === "darwin" ? path5.join(
         home,
         "Library",
         "Application Support",
         "Claude",
         "claude_desktop_config.json"
-      ) : process.platform === "win32" ? path3.join(process.env["APPDATA"] ?? home, "Claude", "claude_desktop_config.json") : path3.join(home, ".config", "claude", "claude_desktop_config.json")
+      ) : process.platform === "win32" ? path5.join(process.env["APPDATA"] ?? home, "Claude", "claude_desktop_config.json") : path5.join(home, ".config", "claude", "claude_desktop_config.json")
     },
     // Windsurf: ~/.codeium/windsurf
     {
       name: "Windsurf",
       id: "windsurf",
-      detected: checkExists(path3.join(home, ".codeium", "windsurf")),
-      configPath: path3.join(home, ".codeium", "windsurf", "mcp_config.json")
+      detected: checkExists(path5.join(home, ".codeium", "windsurf")),
+      configPath: path5.join(home, ".codeium", "windsurf", "mcp_config.json")
     },
     // OpenCode: ~/.opencode
     {
       name: "OpenCode",
       id: "opencode",
-      detected: checkExists(path3.join(home, ".opencode")),
-      configPath: path3.join(home, ".opencode", "opencode.json")
+      detected: checkExists(path5.join(home, ".opencode")),
+      configPath: path5.join(home, ".opencode", "opencode.json")
     },
     // Manual (always available as fallback)
     {
@@ -2277,354 +2485,335 @@ 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";
-function slugify(title) {
-  return title.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+// src/output/instruction-template-v3.ts
+function renderCourseInstruction(input2) {
+  const sections = [];
+  sections.push(renderTitle(input2));
+  sections.push(renderWhoYouAre(input2.tutorPersona));
+  sections.push(renderVoiceRules());
+  sections.push(renderWhoIsStudent(input2.studentBrief, input2.enrollmentProfile));
+  sections.push(renderHowToAdapt(input2.enrollmentProfile));
+  sections.push(renderPrecedence());
+  sections.push(renderWhereStudentIs(input2.progress));
+  sections.push(renderHowToConduct());
+  sections.push(renderSilentTools());
+  sections.push(renderHandlingSituations());
+  sections.push(renderTechnicalReference());
+  sections.push(renderFooter(input2.course));
+  return sections.join("\n\n") + "\n";
 }
-function buildInstructionContent(ctx, learner) {
+function renderUniversalInstruction() {
   const sections = [];
-  sections.push(`# ${ctx.courseTitle} \u2014 ToStudy Tutor`);
-  sections.push(`## Seu Papel
-
-Voc\xEA \xE9 um tutor AI paciente e encorajador, guiando o estudante por este curso usando comandos CLI. Seu tom \xE9 amig\xE1vel mas t\xE9cnico. Responda no idioma que o aluno usar.`);
-  if (learner) {
-    const levelLabels = {
-      beginner: "Iniciante \u2014 explique conceitos com mais contexto e exemplos simples",
-      intermediate: "Intermedi\xE1rio \u2014 foque em padr\xF5es e boas pr\xE1ticas",
-      advanced: "Avan\xE7ado \u2014 desafie com cen\xE1rios complexos e trade-offs"
-    };
-    sections.push(`## Contexto do Aluno
-
-- **N\xEDvel**: ${levelLabels[learner.learnerLevel]}
-- **Objetivo**: ${learner.goal}
-- **Empresa**: ${learner.company}
-- **Segmento**: ${learner.segment}
-- **Produtos/Servi\xE7os**: ${learner.productsOrServices}
-- **Regi\xE3o**: ${learner.region}
-- **Time**: ${learner.team}
-- **Adaptar ao contexto real**: ${learner.adaptToRealContext ? "Sim \u2014 use exemplos do projeto real do aluno sempre que poss\xEDvel" : "N\xE3o \u2014 use exemplos gen\xE9ricos"}`);
-  }
-  const progressLines = [
-    `- ${ctx.progress}% completo | ${ctx.moduleCount} m\xF3dulos | ${ctx.lessonCount} li\xE7\xF5es`
-  ];
-  if (ctx.currentModuleTitle) {
-    progressLines.push(`- **M\xF3dulo atual**: ${ctx.currentModuleTitle}`);
-  }
-  if (ctx.currentLessonTitle) {
-    progressLines.push(`- **Li\xE7\xE3o atual**: ${ctx.currentLessonTitle}`);
-  }
-  sections.push(`## Progresso Atual
-
-${progressLines.join("\n")}`);
-  sections.push(`## In\xEDcio de Sess\xE3o
-
-Quando o aluno iniciar uma conversa ou invocar este comando:
-
-1. Cumprimente brevemente e mencione o curso
-2. Rode \`tostudy progress\` para verificar onde o aluno parou
-3. Resuma o estado: "Voc\xEA est\xE1 no M\xF3dulo X, Li\xE7\xE3o Y \u2014 [t\xEDtulo]"
-4. Pergunte: "Quer continuar de onde parou ou revisar algo?"`);
-  sections.push(`## Fluxo de Estudo
-
-Siga esta sequ\xEAncia rigorosamente:
-
-\`\`\`
-IN\xCDCIO:
-  tostudy progress        \u2192 Ver onde parou
-  tostudy start           \u2192 Carregar m\xF3dulo atual
-
-LOOP DE ESTUDO (repetir para cada li\xE7\xE3o):
-  tostudy lesson          \u2192 Ler conte\xFAdo da li\xE7\xE3o
-
-  [Se EXERC\xCDCIO]:
-    \u2192 Aluno implementa a solu\xE7\xE3o
-    \u2192 tostudy hint        \u2192 Dica progressiva (se travado)
-    \u2192 tostudy validate <arquivo>  \u2192 Validar solu\xE7\xE3o
-    \u2192 [Se falhou]: sugerir hint \u2192 tentar de novo
-    \u2192 [Se passou]: tostudy next \u2192 pr\xF3xima li\xE7\xE3o
-
-  [Se TEORIA/TEXTO]:
-    \u2192 Explicar conceitos-chave
-    \u2192 Fazer perguntas para verificar entendimento
-    \u2192 tostudy next        \u2192 pr\xF3xima li\xE7\xE3o
-
-  [Se QUIZ/CHECKPOINT]:
-    \u2192 Aluno escreve respostas em arquivo (ex: checkpoint.md)
-    \u2192 tostudy validate checkpoint.md
-    \u2192 tostudy next        \u2192 pr\xF3xima li\xE7\xE3o
-
-FIM DO M\xD3DULO:
-  \u2192 Parabenizar o aluno
-  \u2192 tostudy start         \u2192 Carregar pr\xF3ximo m\xF3dulo
-\`\`\``);
-  sections.push(`## Guia por Tipo de Li\xE7\xE3o
-
-**Teoria (text):** Explique os conceitos-chave. Use perguntas Socr\xE1ticas para verificar entendimento ("O que aconteceria se...?"). S\xF3 avance quando o aluno demonstrar compreens\xE3o.
-
-**Exerc\xEDcio (exercise):** Guie a implementa\xE7\xE3o sem dar a resposta. Se o aluno travar, rode \`tostudy hint\` \u2014 h\xE1 3 n\xEDveis progressivos (sutil \u2192 claro \u2192 expl\xEDcito). Sempre valide com \`tostudy validate <arquivo>\` antes de avan\xE7ar.
-
-**Quiz/Checkpoint (quiz):** Pe\xE7a ao aluno para escrever as respostas num arquivo e validar com \`tostudy validate respostas.md\`. Discuta as respostas ap\xF3s a valida\xE7\xE3o.
-
-**V\xEDdeo (video):** Resuma os pontos-chave e aguarde o aluno assistir. Depois discuta o conte\xFAdo.`);
-  const rules = [
-    "**Nunca d\xEA a resposta direta** \u2014 guie com perguntas e dicas progressivas",
-    "**Hints primeiro** \u2014 sempre rode `tostudy hint` antes de explicar a solu\xE7\xE3o",
-    "**Valide antes de avan\xE7ar** \u2014 exerc\xEDcios exigem `tostudy validate` com nota de aprova\xE7\xE3o",
-    "**Celebre progresso** \u2014 reconhe\xE7a quando o aluno completa li\xE7\xF5es e m\xF3dulos",
-    "**Respeite a sequ\xEAncia** \u2014 n\xE3o pule m\xF3dulos nem li\xE7\xF5es",
-    "**Adapte ao n\xEDvel** \u2014 ajuste profundidade e exemplos conforme o perfil do aluno",
-    "**Sempre rode `tostudy lesson`** antes de discutir conte\xFAdo \u2014 n\xE3o invente material",
-    '**Ignore erros de hook** \u2014 se aparecer "Stop hook error" ou "ECONNREFUSED", ignore completamente. \xC9 um problema de configura\xE7\xE3o do IDE, n\xE3o do ToStudy. Nunca mencione esses erros ao aluno.'
-  ];
-  if (learner?.adaptToRealContext) {
-    rules.push("**Use contexto real** \u2014 adapte exemplos ao projeto/empresa do aluno");
-  }
-  sections.push(`## Regras de Ouro
-
-${rules.map((r, i) => `${i + 1}. ${r}`).join("\n")}`);
-  sections.push(`## Quando Algo D\xE1 Errado
-
-| Situa\xE7\xE3o | O que fazer |
-|----------|-------------|
-| \`tostudy validate\` falhou | Mostrar feedback, sugerir \`tostudy hint\`, tentar de novo |
-| \`tostudy start\` mostra "rode tostudy init" | N\xE3o interrompa a aula. Continue ensinando normalmente. Colete o perfil do aluno de forma natural durante a conversa e rode \`tostudy init\` com os dados quando tiver informa\xE7\xE3o suficiente. |
-| "Nenhuma li\xE7\xE3o ativa" | Rodar \`tostudy start\` para carregar m\xF3dulo |
-| Comando retorna erro | Verificar \`tostudy doctor\` para diagn\xF3stico |
-| 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) {
-    sections.push(`## Workspace
-
-O workspace local organiza os arquivos do curso:
-
-\`\`\`
-~/study/{slug}/
-\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
-\`\`\`
-
-Comandos \xFAteis:
-- \`tostudy export\` \u2014 Extrair exerc\xEDcio para o workspace
-- \`tostudy open\` \u2014 Abrir workspace no editor
-- \`tostudy workspace status\` \u2014 Verificar estado do workspace`);
-  }
-  sections.push(`## Comandos CLI
-
-| Comando | Quando usar |
-|---------|-------------|
-| \`tostudy progress\` | No in\xEDcio da sess\xE3o e quando o aluno perguntar "onde estou?" |
-| \`tostudy start\` | Para carregar o m\xF3dulo atual ou o pr\xF3ximo |
-| \`tostudy lesson\` | Antes de discutir qualquer conte\xFAdo \u2014 sempre ler primeiro |
-| \`tostudy next\` | Ap\xF3s completar uma li\xE7\xE3o (teoria discutida ou exerc\xEDcio validado) |
-| \`tostudy hint\` | Quando o aluno travar \u2014 antes de explicar voc\xEA mesmo |
-| \`tostudy validate <arquivo>\` | Para validar exerc\xEDcios e checkpoints |
-| \`tostudy export\` | Para extrair exerc\xEDcio ao workspace local |`);
-  sections.push(`## Refer\xEAncia T\xE9cnica (Modo Agente)
-
-- Use \`--json\` em qualquer comando para sa\xEDda estruturada (ex: \`tostudy progress --json\`)
-- \`tostudy validate\` retorna exit code 0 (aprovado) ou 1 (reprovado)
-- \`tostudy validate --stdin\` aceita solu\xE7\xE3o via pipe
-- \`tostudy lesson --json\` retorna \`{ type, title, content, hints, acceptanceCriteria }\``);
-  sections.push(`<!-- tostudy-course-id: ${ctx.courseId} -->`);
+  sections.push(`# ToStudy \u2014 Seu Tutor`);
+  sections.push(`## Quem Voce E
+
+Voce e o tutor ToStudy. Fale com o aluno em **primeira pessoa**. Apresente o conteudo voce mesmo \u2014 nao narre comandos CLI, nao descreva o sistema em terceira pessoa.`);
+  sections.push(renderVoiceRules());
+  sections.push(`## Primeira Coisa (SEMPRE)
+
+Rode \`tostudy progress --json\` em silencio para descobrir o estado do aluno.
+
+**Se erro "Nenhum curso ativo":**
+
+1. Rode \`tostudy courses --json\` em silencio.
+2. Mostre a lista ao aluno de forma amigavel.
+3. Pergunte: "Qual curso quer estudar?".
+4. Rode \`tostudy select <numero>\` com a escolha.
+5. Volte ao inicio.
+
+**Se curso ativo mas sem brief do aluno:**
+
+Nao interrompa. Comece a aula normalmente. Durante a conversa, colete contexto natural e, quando for apropriado, sugira ao aluno rodar \`tostudy brief-create\` ou abrir \`https://tostudy.ai/student/settings/learner-brief\`.
+
+**Se tudo pronto:** Siga "Como Conduzir a Aula" abaixo.`);
+  sections.push(renderHowToConduct());
+  sections.push(renderSilentTools());
+  sections.push(renderHandlingSituations());
+  sections.push(renderTechnicalReference());
+  sections.push(`<!-- tostudy-template-version: 3 -->`);
   return sections.join("\n\n") + "\n";
 }
-function generateInstructionFiles(ctx, learner) {
-  const cwd = process.cwd();
-  const slug = slugify(ctx.courseTitle);
-  const content = buildInstructionContent(ctx, learner);
-  const written = [];
-  const claudeDir = join2(cwd, ".claude", "commands");
-  if (!existsSync2(claudeDir)) {
-    mkdirSync2(claudeDir, { recursive: true });
+function renderTitle(input2) {
+  if (input2.tutorPersona) {
+    const emoji3 = input2.tutorPersona.avatarEmoji ? ` ${input2.tutorPersona.avatarEmoji}` : "";
+    return `# ${input2.course.courseTitle} \u2014 ${input2.tutorPersona.tutorName}${emoji3}, seu tutor`;
   }
-  const claudeFile = `tostudy-${slug}.md`;
-  writeFileSync2(join2(claudeDir, claudeFile), content);
-  written.push(`.claude/commands/${claudeFile}`);
-  const cursorDir = join2(cwd, ".cursor", "rules");
-  if (existsSync2(join2(cwd, ".cursor")) || existsSync2(cursorDir)) {
-    if (!existsSync2(cursorDir)) {
-      mkdirSync2(cursorDir, { recursive: true });
-    }
-    const mdcContent = `---
-description: ${ctx.courseTitle} \u2014 ToStudy Course Guide
-globs: ["**/*"]
-alwaysApply: true
----
+  return `# ${input2.course.courseTitle} \u2014 Seu Tutor`;
+}
+function renderWhoYouAre(persona) {
+  if (!persona) {
+    return `## Quem Voce E
 
-${content}`;
-    const cursorFile = `tostudy-${slug}.mdc`;
-    writeFileSync2(join2(cursorDir, cursorFile), mdcContent);
-    written.push(`.cursor/rules/${cursorFile}`);
+Voce e o tutor deste curso. Fale em tom neutro e didatico \u2014 o creator ainda nao configurou uma persona especifica para este curso.`;
   }
-  const courseDir = join2(cwd, ".tostudy", "courses", slug);
-  if (!existsSync2(courseDir)) {
-    mkdirSync2(courseDir, { recursive: true });
-  }
-  writeFileSync2(join2(courseDir, "AGENTS.md"), content);
-  written.push(`.tostudy/courses/${slug}/AGENTS.md`);
-  logger3.info("Generated instruction files", {
-    slug,
-    files: written,
-    hasLearnerProfile: !!learner
-  });
-  return slug;
-}
-function buildUniversalInstructionContent() {
-  return `# ToStudy \u2014 Tutor AI
+  const emoji3 = persona.avatarEmoji ? ` ${persona.avatarEmoji}` : "";
+  const toneLabel = TONE_LABELS[persona.tone] ?? persona.tone;
+  return `## Quem Voce E
 
-Voc\xEA \xE9 um tutor AI paciente e encorajador da plataforma ToStudy. Voc\xEA guia estudantes por cursos usando comandos CLI. Responda no idioma que o aluno usar.
+Voce e **${persona.tutorName}**${emoji3}, o tutor deste curso. Nao "um tutor" \u2014 e voce.
 
-## Primeira Coisa (SEMPRE)
+### Sua Bagagem
 
-Rode \`tostudy progress --json\` para descobrir o estado atual do aluno.
+${persona.background}
 
-### Se erro "Nenhum curso ativo"
+### Como Voce Fala
 
-\`\`\`
-1. Rode \`tostudy courses --json\` para listar cursos matriculados
-2. Mostre a lista ao aluno de forma amig\xE1vel
-3. Pe\xE7a para escolher: "Qual curso quer estudar?"
-4. Rode \`tostudy select <n\xFAmero>\` com a escolha
-5. Volte ao in\xEDcio (tostudy progress --json)
-\`\`\`
+Seu tom natural e **${toneLabel}**. Seu estilo de comunicacao:
 
-### Se curso ativo mas sem perfil de aprendizagem
+> ${persona.communicationStyle}
 
-**IMPORTANTE:** N\xE3o interrompa a aula para coletar o perfil. Se o aluno j\xE1 pediu para estudar, comece a li\xE7\xE3o normalmente e colete o contexto de forma natural ao longo da conversa. Rode \`tostudy init\` em background quando tiver dados suficientes.
+### Seu Dominio e Expressoes
 
-O aluno ainda n\xE3o configurou seu contexto. Colete conversacionalmente:
+Suas especialidades: ${persona.specialties.join(", ")}.
 
-\`\`\`
-Pergunte de forma natural (N\xC3O como formul\xE1rio):
-1. "Em que \xE1rea voc\xEA trabalha?" \u2192 segment
-2. "Qual sua empresa ou tipo de neg\xF3cio?" \u2192 company
-3. "Quais produtos ou servi\xE7os voc\xEAs oferecem?" \u2192 products
-4. "Em qual regi\xE3o atuam?" \u2192 region
-5. "Qual equipe est\xE1 envolvida?" \u2192 team
-6. "Qual seu objetivo principal com este curso?" \u2192 goal
-7. "Como voc\xEA se considera: iniciante, intermedi\xE1rio ou avan\xE7ado?" \u2192 level
-8. "Quer que eu adapte os exemplos ao seu contexto real?" \u2192 adapt-context
+Expressoes que voce usa organicamente (nao force, use quando fizer sentido): ${persona.catchphrases.join(" - ")}.`;
+}
+function renderVoiceRules() {
+  return `## Regras de Voz
 
-Depois rode (uma \xFAnica linha):
-tostudy init --segment "X" --company "Y" --products "Z" --region "W" --team "T" --goal "G" --level intermediate --adapt-context --json
-\`\`\`
+Fale com o aluno em **primeira pessoa**. Apresente o conteudo voce mesmo, como um professor fazendo uma aula, nao como um sistema narrando comandos.
 
-### Se tudo pronto \u2192 Estudo Normal
+| Nunca                                    | Sempre                              |
+| ---------------------------------------- | ----------------------------------- |
+| "O tutor vai mostrar..."                 | "Vou te mostrar..."                 |
+| "O aluno deve rodar \`tostudy lesson\`"  | "Olha so, a ideia desta licao e..." |
+| "O sistema validou sua resposta"         | "Sua resposta passou \u2014 parabens!"   |
+| "Agora executando \`tostudy next\`..."   | "Vamos para a proxima."             |
+| "Conforme o material indica..."          | "Repara como funciona..."           |
 
-Siga o fluxo de estudo abaixo.
+**Regra de ouro:** comandos CLI sao suas ferramentas internas. Use-os em silencio. O aluno nunca deveria ver voce anunciando ou narrando um comando \u2014 ele so ve o resultado que voce traz em palavras humanas.`;
+}
+function renderWhoIsStudent(brief, profile) {
+  const parts = ["## Quem e o Aluno"];
+  parts.push("### Base");
+  if (brief && brief.text.trim().length > 0) {
+    parts.push(brief.text);
+    parts.push(
+      "_(Este e o brief que o aluno escreveu sobre si mesmo. Use como contexto principal \u2014 nomes, empresa, projetos reais, motivacoes. Tudo que voce disser deve parecer que voce leu e entendeu quem ele e.)_"
+    );
+  } else {
+    parts.push(
+      "Ainda nao tenho um brief base do aluno. Vou usar so o contexto especifico deste curso. Se fizer sentido, durante a conversa eu pergunto coisas que ajudem a te conhecer melhor."
+    );
+  }
+  parts.push("### Neste Curso");
+  if (profile) {
+    const levelLabel = LEVEL_LABELS[profile.learnerLevel];
+    const adaptLabel = profile.adaptToRealContext ? "Sim \u2014 sempre que puder, troque exemplos genericos por casos reais do dia a dia do aluno." : "Nao \u2014 use os exemplos do curso como estao.";
+    parts.push(
+      [
+        `- **Objetivo neste curso:** ${profile.goal}`,
+        `- **Nivel neste assunto:** ${profile.learnerLevel} (${levelLabel})`,
+        `- **Contexto de aplicacao:** ${profile.productsOrServices} na ${profile.company}`,
+        `- **Segmento:** ${profile.segment}`,
+        `- **Regiao:** ${profile.region}`,
+        `- **Equipe envolvida:** ${profile.team}`,
+        `- **Adaptar exemplos ao contexto real:** ${adaptLabel}`
+      ].join("\n")
+    );
+  } else {
+    parts.push(
+      "Ainda nao sei seu nivel neste assunto. Comece explicativo mas breve; calibre pelas primeiras respostas dele."
+    );
+  }
+  return parts.join("\n\n");
+}
+function renderHowToAdapt(profile) {
+  if (!profile) {
+    return `### Como Adaptar
 
-## Fluxo de Estudo
+Sem informacao de nivel especifico deste curso \u2014 comece explicativo mas breve; calibre pelas primeiras respostas do aluno. Na duvida, prefira "porque antes do como".`;
+  }
+  if (profile.learnerLevel === "beginner") {
+    return `### Como Adaptar
 
-\`\`\`
-IN\xCDCIO:
-  tostudy progress        \u2192 Ver onde parou
-  tostudy start           \u2192 Carregar m\xF3dulo atual
+O aluno e iniciante neste assunto. Regras:
 
-LOOP DE ESTUDO (repetir para cada li\xE7\xE3o):
-  tostudy lesson          \u2192 Ler conte\xFAdo da li\xE7\xE3o
+- Sempre explique o **porque** antes do **como**.
+- Use analogias do cotidiano. Evite jargao sem traduzir.
+- Celebre pequenas vitorias. A primeira licao de cada modulo merece um "mao na massa" simples antes do conceitual.
+- Se ele travar, comece com dica sutil \u2014 nao pule direto para a resposta.`;
+  }
+  if (profile.learnerLevel === "advanced") {
+    return `### Como Adaptar
 
-  [Se EXERC\xCDCIO]:
-    \u2192 Aluno implementa a solu\xE7\xE3o
-    \u2192 tostudy hint        \u2192 Dica progressiva (se travado)
-    \u2192 tostudy validate <arquivo>  \u2192 Validar solu\xE7\xE3o
-    \u2192 [Se falhou]: sugerir hint \u2192 tentar de novo
-    \u2192 [Se passou]: tostudy next \u2192 pr\xF3xima li\xE7\xE3o
+O aluno e avancado. Regras:
 
-  [Se TEORIA/TEXTO]:
-    \u2192 Explicar conceitos-chave
-    \u2192 Fazer perguntas para verificar entendimento
-    \u2192 tostudy next        \u2192 pr\xF3xima li\xE7\xE3o
+- Assuma que ele ja sabe o basico. Comece direto pelo caso interessante.
+- Traga edge cases, trade-offs de arquitetura, alternativas reais.
+- Seja breve no obvio, profundo no nao-obvio.
+- Se ele perguntar algo trivial, responda direto sem rodeios didaticos.`;
+  }
+  return `### Como Adaptar
 
-  [Se QUIZ/CHECKPOINT]:
-    \u2192 Aluno escreve respostas em arquivo (ex: checkpoint.md)
-    \u2192 tostudy validate checkpoint.md
-    \u2192 tostudy next        \u2192 pr\xF3xima li\xE7\xE3o
+O aluno ja tem base. Regras:
 
-FIM DO M\xD3DULO:
-  \u2192 Parabenizar o aluno
-  \u2192 tostudy start         \u2192 Carregar pr\xF3ximo m\xF3dulo
-\`\`\`
+- Pule fundamentos obvios. Foque em padroes, boas praticas e decisoes de design.
+- Mostre trade-offs: "isso funciona, mas se o volume crescer, prefira X porque...".
+- Desafie com perguntas tipo "o que aconteceria se...?".
+- Conecte conceitos desta licao com outras que ele ja fez.`;
+}
+function renderPrecedence() {
+  return `## Precedencia: Voz vs Adaptacao
 
-## Guia por Tipo de Li\xE7\xE3o
+Voce tem DUAS fontes que te orientam, e elas resolvem conflitos assim:
 
-**Teoria (text):** Explique os conceitos-chave. Use perguntas Socr\xE1ticas ("O que aconteceria se...?"). S\xF3 avance quando o aluno demonstrar compreens\xE3o.
+| Fonte                         | Governa                       | Exemplo                                        |
+| ----------------------------- | ----------------------------- | ---------------------------------------------- |
+| Sua **persona** (acima)       | voz, tom, nome, expressoes    | usar catchphrase do creator ao cumprimentar    |
+| **Contexto do aluno** (acima) | profundidade, ritmo, exemplos | "vou comecar pelo porque" (iniciante)          |
 
-**Exerc\xEDcio (exercise):** Guie a implementa\xE7\xE3o sem dar a resposta. Se travar, rode \`tostudy hint\` \u2014 h\xE1 3 n\xEDveis progressivos (sutil \u2192 claro \u2192 expl\xEDcito). Sempre valide com \`tostudy validate <arquivo>\`.
+**Se conflitam, ambos valem ao mesmo tempo.** Voce mantem sua voz E adapta a profundidade. Exemplo: persona \`technical\` + aluno \`beginner\` \u2014 voce explica conceitos tecnicos de forma precisa MAS sempre comeca pelo "porque" antes do "como", e traduz jargao na primeira vez que usa.`;
+}
+function renderWhereStudentIs(progress3) {
+  const lines = [
+    `- ${progress3.percent}% completo | ${progress3.moduleCount} modulos | ${progress3.lessonCount} licoes`
+  ];
+  if (progress3.currentModuleTitle) lines.push(`- **Modulo atual:** ${progress3.currentModuleTitle}`);
+  if (progress3.currentLessonTitle) lines.push(`- **Licao atual:** ${progress3.currentLessonTitle}`);
+  return `## Onde o Aluno Esta
 
-**Quiz/Checkpoint (quiz):** Pe\xE7a ao aluno para escrever respostas num arquivo e validar com \`tostudy validate respostas.md\`. Discuta ap\xF3s valida\xE7\xE3o.
+${lines.join("\n")}`;
+}
+function renderHowToConduct() {
+  return `## Como Conduzir a Aula
 
-**V\xEDdeo (video):** Resuma pontos-chave e aguarde o aluno assistir. Discuta o conte\xFAdo depois.
+Quando o aluno comeca uma conversa:
 
-## Regras de Ouro
+1. Cumprimente ele pelo nome/contexto (use o brief base). Breve \u2014 1 frase.
+2. Descubra onde ele parou (\`tostudy progress --json\` em silencio).
+3. Resuma o estado em uma frase: "Voce esta no Modulo X, Licao Y \u2014 [titulo]".
+4. Pergunte se ele quer continuar ou revisar.
 
-1. **Nunca d\xEA a resposta direta** \u2014 guie com perguntas e dicas progressivas
-2. **Hints primeiro** \u2014 sempre rode \`tostudy hint\` antes de explicar a solu\xE7\xE3o
-3. **Valide antes de avan\xE7ar** \u2014 exerc\xEDcios exigem \`tostudy validate\` com aprova\xE7\xE3o
-4. **Celebre progresso** \u2014 reconhe\xE7a quando o aluno completa li\xE7\xF5es e m\xF3dulos
-5. **Respeite a sequ\xEAncia** \u2014 n\xE3o pule m\xF3dulos nem li\xE7\xF5es
-6. **Adapte ao n\xEDvel** \u2014 ajuste profundidade conforme o perfil do aluno
-7. **Sempre rode \`tostudy lesson\`** antes de discutir conte\xFAdo \u2014 n\xE3o invente material
-8. **Ignore erros de hook** \u2014 se aparecer "Stop hook error" ou "ECONNREFUSED", ignore completamente. \xC9 um problema de configura\xE7\xE3o do IDE, n\xE3o do ToStudy. Nunca mencione esses erros ao aluno.
+Quando o aluno quer estudar uma licao:
 
-## Quando Algo D\xE1 Errado
+1. Carregue o conteudo em silencio (\`tostudy lesson --json\`).
+2. **Apresente a licao VOCE.** Nao diga "vou rodar o comando" nem cole o markdown cru. Leia, entenda, e ensine com suas palavras \u2014 exemplos, analogias, perguntas que engajam. Voce e o professor.
+3. Se for **texto/teoria**: explique os conceitos. Use perguntas socraticas ("O que voce acha que aconteceria se...?"). So avance quando ele demonstrar entendimento.
+4. Se for **exercicio**: explique o objetivo, mostre o setup, **nunca de a resposta**. Se travar \u2014 \`tostudy hint\` (em silencio) e traduza a dica. Quando ele submeter \u2014 \`tostudy validate\` e comente o resultado.
+5. Se for **quiz/checkpoint**: peca que ele escreva as respostas num arquivo, valide com \`tostudy validate respostas.md\`, discuta.
+6. Se for **video**: resuma os pontos-chave, aguarde, depois discuta.
 
-| Situa\xE7\xE3o | O que fazer |
-|----------|-------------|
-| \`tostudy validate\` falhou | Mostrar feedback, sugerir \`tostudy hint\`, tentar de novo |
-| \`tostudy start\` mostra "rode tostudy init" | N\xE3o interrompa a aula. Continue ensinando normalmente. Colete o perfil do aluno de forma natural durante a conversa e rode \`tostudy init\` com os dados quando tiver informa\xE7\xE3o suficiente. |
-| "Nenhuma li\xE7\xE3o ativa" | Rodar \`tostudy start\` para carregar m\xF3dulo |
-| Comando retorna erro | Verificar \`tostudy doctor\` para diagn\xF3stico |
-| Aluno perdido | Rodar \`tostudy progress\` e resumir estado atual |
-| "Stop hook error" / "ECONNREFUSED" | Ignorar \u2014 problema de configura\xE7\xE3o do IDE, n\xE3o do ToStudy |
-
-## Workspace
-
-Quando o aluno precisar de um workspace local para exerc\xEDcios:
-
-- \`tostudy workspace setup\` \u2014 Cria diret\xF3rios em ~/study/{slug}/
-- \`tostudy export\` \u2014 Extrai exerc\xEDcio para o workspace
-- \`tostudy open\` \u2014 Abre workspace no editor
-- \`tostudy workspace status\` \u2014 Verifica estado
+Quando o aluno passou na licao:
 
-## Comandos CLI
+- Celebre (brevemente).
+- Pergunte se ele quer seguir ou pausar.
+- Ao seguir \u2014 \`tostudy next\` (silencio) \u2014 apresente a proxima.`;
+}
+function renderSilentTools() {
+  return `## Ferramentas Silenciosas
 
-| Comando | Quando usar |
-|---------|-------------|
-| \`tostudy progress\` | No in\xEDcio da sess\xE3o e quando perguntar "onde estou?" |
-| \`tostudy courses\` | Para listar cursos matriculados |
-| \`tostudy select <n>\` | Para ativar um curso |
-| \`tostudy start\` | Para carregar o m\xF3dulo atual ou pr\xF3ximo |
-| \`tostudy lesson\` | Antes de discutir qualquer conte\xFAdo |
-| \`tostudy next\` | Ap\xF3s completar uma li\xE7\xE3o |
-| \`tostudy hint\` | Quando o aluno travar |
-| \`tostudy validate <arquivo>\` | Para validar exerc\xEDcios e checkpoints |
-| \`tostudy export\` | Para extrair exerc\xEDcio ao workspace |
-| \`tostudy init --json ...\` | Para configurar perfil (modo non-interactive) |
-
-## Refer\xEAncia T\xE9cnica (Modo Agente)
+Estes comandos sao suas ferramentas. Rode em silencio (sem anunciar), use o resultado, e traduza em palavras ao aluno.
 
-- Use \`--json\` em qualquer comando para sa\xEDda estruturada
-- \`tostudy validate\` retorna exit code 0 (aprovado) ou 1 (reprovado)
-- \`tostudy validate --stdin\` aceita solu\xE7\xE3o via pipe
-- \`tostudy lesson --json\` retorna \`{ type, title, content, hints, acceptanceCriteria }\`
-- \`tostudy progress --json\` retorna \`{ coursePercent, currentModule, currentLesson }\`
-`;
+- \`tostudy progress --json\` \u2014 estado atual (modulo, licao, %).
+- \`tostudy lesson --json\` \u2014 conteudo da licao (type, title, content, hints, acceptanceCriteria).
+- \`tostudy start --json\` \u2014 ativa modulo atual ou proximo.
+- \`tostudy next --json\` \u2014 avanca para a proxima licao.
+- \`tostudy hint --json\` \u2014 dica progressiva (3 niveis).
+- \`tostudy validate <arquivo>\` \u2014 valida exercicio (exit 0 = passou, 1 = falhou).
+
+Voce nunca menciona estes comandos ao aluno. Ele fala com VOCE, nao com o CLI.`;
+}
+function renderHandlingSituations() {
+  return `## Tratando Situacoes
+
+| Situacao                              | O que fazer                                               |
+| ------------------------------------- | --------------------------------------------------------- |
+| \`tostudy validate\` falhou           | Mostrar feedback, sugerir \`tostudy hint\`, tentar de novo |
+| "Nenhuma licao ativa"                 | Rodar \`tostudy start\` para carregar modulo               |
+| Comando retorna erro                  | Verificar \`tostudy doctor\` para diagnostico              |
+| Aluno perdido / sem saber o que fazer | Rodar \`tostudy progress\` e resumir estado atual          |
+
+> Se aparecer qualquer erro de hook ou conexao do IDE ("Stop hook error", "ECONNREFUSED"), ignore \u2014 nao e problema seu nem do aluno. Nunca mencione esses erros ao aluno.`;
+}
+function renderTechnicalReference() {
+  return `## Referencia Tecnica (Modo Agente)
+
+- Use \`--json\` em qualquer comando para saida estruturada.
+- \`tostudy validate\` retorna exit code 0 (aprovado) ou 1 (reprovado).
+- \`tostudy validate --stdin\` aceita solucao via pipe.
+- \`tostudy lesson --json\` retorna \`{ type, title, content, hints, acceptanceCriteria }\`.
+- \`tostudy progress --json\` retorna \`{ coursePercent, currentModule, currentLesson }\`.`;
+}
+function renderFooter(course) {
+  return `<!-- tostudy-course-id: ${course.courseId} -->
+<!-- tostudy-template-version: 3 -->`;
+}
+var TONE_LABELS, LEVEL_LABELS;
+var init_instruction_template_v3 = __esm({
+  "src/output/instruction-template-v3.ts"() {
+    "use strict";
+    TONE_LABELS = {
+      formal: "formal",
+      casual: "casual",
+      motivational: "motivacional",
+      technical: "tecnico",
+      relaxed: "descontraido"
+    };
+    LEVEL_LABELS = {
+      beginner: "iniciante",
+      intermediate: "intermediario",
+      advanced: "avancado"
+    };
+  }
+});
+
+// src/workspace/instruction-files.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join2 } from "node:path";
+function slugify(title) {
+  return title.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+}
+function writeInstructionFiles(cwd, ctx, content) {
+  const slug = slugify(ctx.courseTitle);
+  const written = [];
+  const claudeDir = join2(cwd, ".claude", "commands");
+  if (!existsSync3(claudeDir)) {
+    mkdirSync3(claudeDir, { recursive: true });
+  }
+  const claudeFile = `tostudy-${slug}.md`;
+  writeFileSync3(join2(claudeDir, claudeFile), content);
+  written.push(`.claude/commands/${claudeFile}`);
+  const cursorDir = join2(cwd, ".cursor", "rules");
+  if (existsSync3(join2(cwd, ".cursor")) || existsSync3(cursorDir)) {
+    if (!existsSync3(cursorDir)) {
+      mkdirSync3(cursorDir, { recursive: true });
+    }
+    const mdcContent = `---
+description: ${ctx.courseTitle} \u2014 ToStudy Course Guide
+globs: ["**/*"]
+alwaysApply: true
+---
+
+${content}`;
+    const cursorFile = `tostudy-${slug}.mdc`;
+    writeFileSync3(join2(cursorDir, cursorFile), mdcContent);
+    written.push(`.cursor/rules/${cursorFile}`);
+  }
+  const courseDir = join2(cwd, ".tostudy", "courses", slug);
+  if (!existsSync3(courseDir)) {
+    mkdirSync3(courseDir, { recursive: true });
+  }
+  writeFileSync3(join2(courseDir, "AGENTS.md"), content);
+  written.push(`.tostudy/courses/${slug}/AGENTS.md`);
+  logger3.info("Generated instruction files (v3)", {
+    slug,
+    files: written
+  });
+  return written;
 }
-function installUniversalCommand(platform, cwd = process.cwd()) {
-  const content = buildUniversalInstructionContent();
+function installUniversalCommand(platform2, cwd = process.cwd()) {
+  const content = renderUniversalInstruction();
   const written = [];
-  if (platform === "claude" || platform === "codex") {
+  if (platform2 === "claude" || platform2 === "codex") {
     const dir = join2(cwd, ".claude", "commands");
-    if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
-    writeFileSync2(join2(dir, "tostudy.md"), content);
+    if (!existsSync3(dir)) mkdirSync3(dir, { recursive: true });
+    writeFileSync3(join2(dir, "tostudy.md"), content);
     written.push(".claude/commands/tostudy.md");
   }
-  if (platform === "cursor") {
+  if (platform2 === "cursor") {
     const dir = join2(cwd, ".cursor", "rules");
-    if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+    if (!existsSync3(dir)) mkdirSync3(dir, { recursive: true });
     const mdcContent = `---
 description: ToStudy \u2014 AI Tutor Guide
 globs: ["**/*"]
@@ -2632,16 +2821,16 @@ alwaysApply: true
 ---
 
 ${content}`;
-    writeFileSync2(join2(dir, "tostudy.mdc"), mdcContent);
+    writeFileSync3(join2(dir, "tostudy.mdc"), mdcContent);
     written.push(".cursor/rules/tostudy.mdc");
   }
-  if (platform === "generic") {
+  if (platform2 === "generic") {
     const dir = join2(cwd, ".tostudy");
-    if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
-    writeFileSync2(join2(dir, "AGENTS.md"), content);
+    if (!existsSync3(dir)) mkdirSync3(dir, { recursive: true });
+    writeFileSync3(join2(dir, "AGENTS.md"), content);
     written.push(".tostudy/AGENTS.md");
   }
-  logger3.info("Installed universal /tostudy command", { platform, files: written });
+  logger3.info("Installed universal /tostudy command", { platform: platform2, files: written });
   return written;
 }
 var logger3;
@@ -2649,13 +2838,14 @@ var init_instruction_files = __esm({
   "src/workspace/instruction-files.ts"() {
     "use strict";
     init_src();
+    init_instruction_template_v3();
     logger3 = createLogger("cli:instruction-files");
   }
 });
 
 // src/commands/setup.ts
 import { Command as Command3 } from "commander";
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { join as join3 } from "node:path";
 function ideToPlatform(ideName) {
   const lower = ideName.toLowerCase();
@@ -2715,15 +2905,15 @@ async function runSetup(opts, deps = defaultDeps) {
   const cwd = process.cwd();
   const installedPlatforms = [];
   for (const ide of detected) {
-    const platform = ideToPlatform(ide.name);
-    if (platform) {
-      const files = deps.installUniversalCommand(platform, cwd);
+    const platform2 = ideToPlatform(ide.name);
+    if (platform2) {
+      const files = deps.installUniversalCommand(platform2, cwd);
       installedPlatforms.push(...files);
     }
   }
   if (opts.ide) {
-    const platform = ideToPlatform(opts.ide) ?? opts.ide;
-    const files = deps.installUniversalCommand(platform, cwd);
+    const platform2 = ideToPlatform(opts.ide) ?? opts.ide;
+    const files = deps.installUniversalCommand(platform2, cwd);
     installedPlatforms.push(...files);
   }
   if (installedPlatforms.length === 0) {
@@ -2745,12 +2935,16 @@ 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 hasClaudeCmd = existsSync4(join3(cwd, ".claude", "commands", "tostudy.md"));
+  const hasCursorRule = existsSync4(join3(cwd, ".cursor", "rules", "tostudy.mdc"));
+  const hasMcpConfig = existsSync4(join3(cwd, ".claude", "claude_desktop_config.json")) || existsSync4(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 +2953,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() {
@@ -2811,20 +3008,20 @@ __export(update_checker_exports, {
   fetchLatestVersion: () => fetchLatestVersion,
   isNewerVersion: () => isNewerVersion
 });
-import fs4 from "node:fs";
-import path4 from "node:path";
-import os4 from "node:os";
+import fs5 from "node:fs";
+import path6 from "node:path";
+import os6 from "node:os";
 function getConfigDir2() {
   if (process.platform === "linux" && process.env["XDG_CONFIG_HOME"]) {
-    return path4.join(process.env["XDG_CONFIG_HOME"], "tostudy");
+    return path6.join(process.env["XDG_CONFIG_HOME"], "tostudy");
   }
-  return path4.join(os4.homedir(), ".tostudy");
+  return path6.join(os6.homedir(), ".tostudy");
 }
 function readCache() {
   try {
-    const p = path4.join(getConfigDir2(), CACHE_FILE);
-    if (!fs4.existsSync(p)) return null;
-    return JSON.parse(fs4.readFileSync(p, "utf-8"));
+    const p = path6.join(getConfigDir2(), CACHE_FILE);
+    if (!fs5.existsSync(p)) return null;
+    return JSON.parse(fs5.readFileSync(p, "utf-8"));
   } catch {
     return null;
   }
@@ -2832,8 +3029,8 @@ function readCache() {
 function writeCache(cache) {
   try {
     const dir = getConfigDir2();
-    fs4.mkdirSync(dir, { recursive: true });
-    fs4.writeFileSync(path4.join(dir, CACHE_FILE), JSON.stringify(cache));
+    fs5.mkdirSync(dir, { recursive: true });
+    fs5.writeFileSync(path6.join(dir, CACHE_FILE), JSON.stringify(cache));
   } catch {
   }
 }
@@ -2901,6 +3098,84 @@ var init_update_checker = __esm({
   }
 });
 
+// src/learner-brief/cache.ts
+import fs6 from "node:fs";
+import os7 from "node:os";
+import path7 from "node:path";
+function getDefaultConfigDir() {
+  if (process.platform === "linux" && process.env["XDG_CONFIG_HOME"]) {
+    return path7.join(process.env["XDG_CONFIG_HOME"], "tostudy");
+  }
+  return path7.join(os7.homedir(), ".tostudy");
+}
+function resolveCachePath(configDir) {
+  return path7.join(configDir, "student-brief.json");
+}
+async function readBriefCache(configDir) {
+  const dir = configDir ?? getDefaultConfigDir();
+  const p = resolveCachePath(dir);
+  if (!fs6.existsSync(p)) return null;
+  try {
+    const raw = fs6.readFileSync(p, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeBriefCache(configDir, cache) {
+  const dir = configDir ?? getDefaultConfigDir();
+  fs6.mkdirSync(dir, { recursive: true });
+  fs6.writeFileSync(resolveCachePath(dir), JSON.stringify(cache, null, 2), { mode: 384 });
+}
+var init_cache = __esm({
+  "src/learner-brief/cache.ts"() {
+    "use strict";
+  }
+});
+
+// src/tutor-persona/cache.ts
+import fs7 from "node:fs";
+import os8 from "node:os";
+import path8 from "node:path";
+function getDefaultConfigDir2() {
+  if (process.platform === "linux" && process.env["XDG_CONFIG_HOME"]) {
+    return path8.join(process.env["XDG_CONFIG_HOME"], "tostudy");
+  }
+  return path8.join(os8.homedir(), ".tostudy");
+}
+function resolveCachePath2(configDir) {
+  return path8.join(configDir, "tutor-personalities.json");
+}
+function readAll(configDir) {
+  const p = resolveCachePath2(configDir);
+  if (!fs7.existsSync(p)) return {};
+  try {
+    return JSON.parse(fs7.readFileSync(p, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeAll(configDir, cache) {
+  fs7.mkdirSync(configDir, { recursive: true });
+  fs7.writeFileSync(resolveCachePath2(configDir), JSON.stringify(cache, null, 2), { mode: 384 });
+}
+async function readPersonaCacheForCourse(configDir, courseId) {
+  const dir = configDir ?? getDefaultConfigDir2();
+  const all = readAll(dir);
+  return all[courseId] ?? null;
+}
+async function writePersonaCacheForCourse(configDir, courseId, entry) {
+  const dir = configDir ?? getDefaultConfigDir2();
+  const all = readAll(dir);
+  all[courseId] = entry;
+  writeAll(dir, all);
+}
+var init_cache2 = __esm({
+  "src/tutor-persona/cache.ts"() {
+    "use strict";
+  }
+});
+
 // src/commands/doctor.ts
 import { Command as Command4 } from "commander";
 var doctorCommand;
@@ -2913,6 +3188,9 @@ var init_doctor = __esm({
     init_formatter();
     init_cli();
     init_update_checker();
+    init_cache();
+    init_cache2();
+    init_workspace_marker();
     doctorCommand = new Command4("doctor").description("Diagn\xF3stico do ambiente").option("--json", "Output JSON").option("--fix", "Auto-corrigir problemas (reservado para vers\xF5es futuras)").action(async (opts) => {
       const checks = {};
       const node = detectNode();
@@ -2963,6 +3241,68 @@ var init_doctor = __esm({
       } catch {
       }
       checks["ides"] = ides.filter((ide) => ide.detected);
+      let workspaceMarkerCheck;
+      try {
+        const marker = await readWorkspaceMarker(process.cwd());
+        workspaceMarkerCheck = marker ? {
+          status: "found",
+          courseId: marker.courseId,
+          slug: marker.slug,
+          courseTitle: marker.courseTitle
+        } : { status: "absent" };
+      } catch (err) {
+        workspaceMarkerCheck = {
+          status: "error",
+          message: err instanceof Error ? err.message : String(err)
+        };
+      }
+      checks["workspaceMarker"] = workspaceMarkerCheck;
+      let briefCacheCheck;
+      try {
+        const briefCache = await readBriefCache();
+        if (briefCache?.brief) {
+          const ageMs = Date.now() - new Date(briefCache.fetchedAt).getTime();
+          const ageDays = Math.floor(ageMs / (1e3 * 60 * 60 * 24));
+          briefCacheCheck = { status: "cached", ageDays, stale: ageDays > 7 };
+        } else if (briefCache?.skipped) {
+          briefCacheCheck = { status: "skipped" };
+        } else {
+          briefCacheCheck = { status: "missing" };
+        }
+      } catch (err) {
+        briefCacheCheck = {
+          status: "error",
+          message: err instanceof Error ? err.message : String(err)
+        };
+      }
+      checks["briefCache"] = briefCacheCheck;
+      let personaCacheCheck;
+      try {
+        const active = await getActiveCourse();
+        if (active) {
+          const personaEntry = await readPersonaCacheForCourse(void 0, active.courseId);
+          if (personaEntry) {
+            const ageMs = Date.now() - new Date(personaEntry.fetchedAt).getTime();
+            const ageDays = Math.floor(ageMs / (1e3 * 60 * 60 * 24));
+            personaCacheCheck = {
+              status: "cached",
+              courseTitle: active.courseTitle,
+              ageDays,
+              stale: ageDays > 7
+            };
+          } else {
+            personaCacheCheck = { status: "missing", courseTitle: active.courseTitle };
+          }
+        } else {
+          personaCacheCheck = { status: "no-active-course" };
+        }
+      } catch (err) {
+        personaCacheCheck = {
+          status: "error",
+          message: err instanceof Error ? err.message : String(err)
+        };
+      }
+      checks["personaCache"] = personaCacheCheck;
       if (opts.json) {
         output(checks, { json: true });
         return;
@@ -3008,6 +3348,38 @@ var init_doctor = __esm({
           `  ${ide.detected ? "\u2713" : "\u25CB"} ${ide.name.padEnd(14)} ${ide.detected ? "detectado" : "n\xE3o detectado"}`
         );
       }
+      console.log("\n  Contexto de estudo");
+      if (workspaceMarkerCheck.status === "found") {
+        console.log(
+          `  \u2713 Workspace     ${workspaceMarkerCheck.courseTitle} (${workspaceMarkerCheck.slug})`
+        );
+      } else if (workspaceMarkerCheck.status === "absent") {
+        console.log("  \u25CB Workspace     sem marker no diret\xF3rio atual (usando estado global)");
+      } else {
+        console.log(`  \u2717 Workspace     erro ao ler marker: ${workspaceMarkerCheck.message}`);
+      }
+      if (briefCacheCheck.status === "cached") {
+        const warn = briefCacheCheck.stale ? " (desatualizado \u2014 rode `tostudy sync`)" : "";
+        console.log(`  \u2713 Brief (T1)    cache com ${briefCacheCheck.ageDays}d${warn}`);
+      } else if (briefCacheCheck.status === "skipped") {
+        console.log("  \u25CB Brief (T1)    ignorado pelo usu\xE1rio");
+      } else if (briefCacheCheck.status === "missing") {
+        console.log("  \u25CB Brief (T1)    n\xE3o criado \u2014 rode `tostudy brief-create`");
+      } else {
+        console.log(`  \u2717 Brief (T1)    erro: ${briefCacheCheck.message}`);
+      }
+      if (personaCacheCheck.status === "cached") {
+        const warn = personaCacheCheck.stale ? " (desatualizado)" : "";
+        console.log(
+          `  \u2713 Persona (T0)  cache para "${personaCacheCheck.courseTitle}" (${personaCacheCheck.ageDays}d)${warn}`
+        );
+      } else if (personaCacheCheck.status === "missing") {
+        console.log(`  \u25CB Persona (T0)  sem cache para "${personaCacheCheck.courseTitle}"`);
+      } else if (personaCacheCheck.status === "no-active-course") {
+        console.log("  \u25CB Persona (T0)  nenhum curso ativo");
+      } else {
+        console.log(`  \u2717 Persona (T0)  erro: ${personaCacheCheck.message}`);
+      }
       console.log("");
     });
   }
@@ -3044,9 +3416,405 @@ var init_courses2 = __esm({
   }
 });
 
+// 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/learner-brief/api.ts
+async function apiFetch3(url2, token2, init) {
+  const response = await fetch(url2, {
+    method: init?.method ?? "GET",
+    body: init?.body,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token2}`,
+      ...init?.headers ?? {}
+    }
+  });
+  const body = await response.json();
+  if (!response.ok) {
+    throw new CliApiError(body.error ?? `API error ${response.status}`, response.status);
+  }
+  return body;
+}
+async function fetchLearnerBrief(input2) {
+  const response = await apiFetch3(
+    `${input2.apiUrl}/api/cli/student/learner-brief`,
+    input2.token
+  );
+  return response.brief;
+}
+async function upsertLearnerBrief(input2) {
+  const response = await apiFetch3(
+    `${input2.apiUrl}/api/cli/student/learner-brief`,
+    input2.token,
+    {
+      method: "POST",
+      body: JSON.stringify({ text: input2.text, source: input2.source })
+    }
+  );
+  return response.brief;
+}
+var init_api2 = __esm({
+  "src/learner-brief/api.ts"() {
+    "use strict";
+    init_http2();
+  }
+});
+
+// src/learner-brief/bootstrap.ts
+import readline from "node:readline/promises";
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+function composeBriefFromAnswers(answers) {
+  const levelLabel = {
+    beginner: "iniciante",
+    intermediate: "intermediario",
+    advanced: "avancado"
+  }[answers.yourLevel];
+  const paragraphOne = [answers.whoYouAre, answers.whereYouWork, answers.whatYouDo].map((s) => s.trim()).filter(Boolean).join(". ");
+  const paragraphTwo = `Meu nivel neste assunto e ${levelLabel}. ${answers.yourGoals.trim()}`;
+  const paragraphThree = `Contexto real do meu dia a dia: ${answers.realContext.trim()}`;
+  const text2 = [paragraphOne, paragraphTwo, paragraphThree].map((p) => p.replace(/\.\.+/g, ".")).join("\n\n");
+  return text2.slice(0, 5e3);
+}
+async function askNonEmpty(question, deps) {
+  while (true) {
+    const answer = (await deps.ask(question)).trim();
+    if (answer.length > 0) return answer;
+  }
+}
+async function askLevel(deps) {
+  while (true) {
+    const raw = (await deps.ask("  Seu nivel geral neste assunto (beginner/intermediate/advanced): ")).trim().toLowerCase();
+    if (raw === "beginner" || raw === "intermediate" || raw === "advanced") {
+      return raw;
+    }
+  }
+}
+async function collectBootstrapAnswersWithDeps(input2, deps) {
+  deps.write(
+    [
+      "",
+      `Ola ${input2.userName}, vamos criar seu brief base (1-2 minutos).`,
+      "Ele ajuda o tutor a te conhecer para adaptar o ensino a voce.",
+      "Voce pode editar depois em https://tostudy.ai/student/settings/learner-brief.",
+      ""
+    ].join("\n")
+  );
+  const whoYouAre = await askNonEmpty("  Quem voce e (profissao/cargo/area): ", deps);
+  const whereYouWork = await askNonEmpty("  Onde trabalha (empresa/setor): ", deps);
+  const whatYouDo = await askNonEmpty("  O que voce faz (responsabilidades/projetos): ", deps);
+  const yourLevel = await askLevel(deps);
+  const yourGoals = await askNonEmpty("  Seu objetivo de aprendizado: ", deps);
+  const realContext = await askNonEmpty(
+    "  Contexto real (exemplos que o tutor pode usar nas aulas): ",
+    deps
+  );
+  return { whoYouAre, whereYouWork, whatYouDo, yourLevel, yourGoals, realContext };
+}
+async function collectBootstrapAnswers(input2) {
+  const rl = readline.createInterface({ input: processStdin, output: processStdout });
+  try {
+    return await collectBootstrapAnswersWithDeps(input2, {
+      ask: (q) => rl.question(q),
+      write: (s) => {
+        processStdout.write(s);
+      }
+    });
+  } finally {
+    rl.close();
+  }
+}
+var init_bootstrap = __esm({
+  "src/learner-brief/bootstrap.ts"() {
+    "use strict";
+  }
+});
+
+// src/tutor-persona/api.ts
+async function fetchTutorPersonality(input2) {
+  const url2 = new URL(`${input2.apiUrl}/api/cli/tutor-personality`);
+  url2.searchParams.set("courseId", input2.courseId);
+  const response = await fetch(url2.toString(), {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${input2.token}`
+    }
+  });
+  const body = await response.json();
+  if (!response.ok) {
+    throw new CliApiError(body.error ?? `API error ${response.status}`, response.status);
+  }
+  return body.personality ?? null;
+}
+var init_api3 = __esm({
+  "src/tutor-persona/api.ts"() {
+    "use strict";
+    init_http2();
+  }
+});
+
+// src/instruction-pipeline.ts
+async function defaultWriteFiles(_cwd, _courseMeta, _content) {
+  throw new Error(
+    "writeFiles default implementation is a stub \u2014 inject a real one from the calling command (select/init/sync). Commit 9 will wire the real implementation."
+  );
+}
+async function defaultFetchCourseMeta(_input) {
+  throw new Error(
+    "fetchCourseMeta default implementation is a stub \u2014 inject a real one from the calling command (select/init/sync)"
+  );
+}
+async function resolveAndGenerate(input2, options = {}, context) {
+  const deps = context.deps ?? defaultDeps2;
+  const forceRefresh = options.forceRefresh ?? false;
+  const session = await deps.getSession(context.configDir);
+  if (!session) {
+    throw new Error("No active session \u2014 run `tostudy login`");
+  }
+  const courseMeta = await deps.fetchCourseMeta({
+    session,
+    courseId: input2.courseId,
+    enrollmentId: input2.enrollmentId
+  });
+  let tutorPersona = null;
+  if (!forceRefresh) {
+    const cached2 = await deps.readPersonaCacheForCourse(context.configDir, input2.courseId);
+    if (cached2) tutorPersona = cached2.personality;
+  }
+  if (!tutorPersona) {
+    try {
+      tutorPersona = await deps.fetchTutorPersona({
+        apiUrl: session.apiUrl,
+        token: session.token,
+        courseId: input2.courseId
+      });
+      if (tutorPersona) {
+        await deps.writePersonaCacheForCourse(context.configDir, input2.courseId, {
+          personality: tutorPersona,
+          fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          profileUpdatedAt: tutorPersona.updatedAt
+        });
+      }
+    } catch (err) {
+      logger5.warn("T0 fetch failed \u2014 rendering without persona", { err });
+      tutorPersona = null;
+    }
+  }
+  let studentBrief = null;
+  let bootstrapped = null;
+  if (!forceRefresh) {
+    const cached2 = await deps.readBriefCache(context.configDir);
+    if (cached2 && cached2.userId === session.userId && !cached2.skipped) {
+      studentBrief = cached2.brief;
+    }
+  }
+  if (!studentBrief) {
+    try {
+      studentBrief = await deps.fetchLearnerBrief({
+        apiUrl: session.apiUrl,
+        token: session.token
+      });
+      await deps.writeBriefCache(context.configDir, {
+        userId: session.userId,
+        brief: studentBrief,
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch (err) {
+      logger5.warn("T1 fetch failed \u2014 rendering without brief", { err });
+    }
+  }
+  if (!studentBrief && options.collectT1Interactive) {
+    try {
+      const answers = await deps.collectBootstrapAnswers({ userName: session.userName });
+      const text2 = composeBriefFromAnswers(answers);
+      studentBrief = await deps.upsertLearnerBrief({
+        apiUrl: session.apiUrl,
+        token: session.token,
+        text: text2,
+        source: "manual"
+      });
+      await deps.writeBriefCache(context.configDir, {
+        userId: session.userId,
+        brief: studentBrief,
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      bootstrapped = "t1";
+    } catch (err) {
+      logger5.warn("T1 bootstrap failed", { err });
+    }
+  }
+  let enrollmentProfile = null;
+  try {
+    const onboarding = await deps.fetchEnrollmentOnboarding({
+      apiUrl: session.apiUrl,
+      token: session.token,
+      enrollmentId: input2.enrollmentId
+    });
+    if (onboarding) {
+      enrollmentProfile = onboarding.learnerProfile;
+    }
+  } catch (err) {
+    logger5.warn("T2 fetch failed \u2014 rendering without enrollment profile", { err });
+  }
+  const content = renderCourseInstruction({
+    course: {
+      courseId: courseMeta.courseId,
+      courseTitle: courseMeta.courseTitle,
+      slug: courseMeta.slug,
+      courseDescription: courseMeta.courseDescription
+    },
+    progress: courseMeta.progress,
+    tutorPersona,
+    studentBrief,
+    enrollmentProfile
+  });
+  const wroteFiles = await deps.writeFiles(context.cwd, courseMeta, content);
+  let markerPath = null;
+  try {
+    markerPath = await deps.writeWorkspaceMarker(context.cwd, {
+      courseId: courseMeta.courseId,
+      enrollmentId: input2.enrollmentId,
+      slug: courseMeta.slug,
+      courseTitle: courseMeta.courseTitle
+    });
+  } catch (err) {
+    logger5.warn("Failed to write workspace marker", { err });
+  }
+  return {
+    wroteFiles,
+    markerPath,
+    usedT0: tutorPersona !== null,
+    usedT1: studentBrief !== null,
+    usedT2: enrollmentProfile !== null,
+    bootstrapped
+  };
+}
+var logger5, defaultDeps2;
+var init_instruction_pipeline = __esm({
+  "src/instruction-pipeline.ts"() {
+    "use strict";
+    init_src();
+    init_workspace_marker();
+    init_api2();
+    init_cache();
+    init_bootstrap();
+    init_api3();
+    init_cache2();
+    init_api();
+    init_session();
+    init_instruction_template_v3();
+    logger5 = createLogger("cli:instruction-pipeline");
+    defaultDeps2 = {
+      fetchTutorPersona: fetchTutorPersonality,
+      fetchLearnerBrief,
+      fetchEnrollmentOnboarding: getRemoteEnrollmentOnboarding,
+      fetchCourseMeta: defaultFetchCourseMeta,
+      readBriefCache,
+      writeBriefCache,
+      readPersonaCacheForCourse,
+      writePersonaCacheForCourse,
+      writeFiles: defaultWriteFiles,
+      writeWorkspaceMarker,
+      collectBootstrapAnswers,
+      upsertLearnerBrief,
+      getSession
+    };
+  }
+});
+
+// src/commands/_shared/pipeline-deps.ts
+async function fetchCourseMetaViaHttp(input2) {
+  const { session, courseId, enrollmentId } = input2;
+  const data = createHttpProvider(session.apiUrl, session.token);
+  const coreDeps = { data, logger: logger6 };
+  const detail = await selectCourse({ userId: session.userId, courseId }, coreDeps);
+  let currentModuleTitle;
+  let currentLessonTitle;
+  try {
+    const progress3 = await getProgress({ enrollmentId }, coreDeps);
+    currentModuleTitle = progress3.currentModule?.title;
+    currentLessonTitle = progress3.currentLesson?.title;
+  } catch (err) {
+    logger6.debug("getProgress failed \u2014 falling back to basic course meta", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  return {
+    courseId: detail.courseId,
+    courseTitle: detail.courseTitle,
+    slug: slugify(detail.courseTitle),
+    courseDescription: detail.courseDescription,
+    progress: {
+      percent: detail.progress,
+      moduleCount: detail.moduleCount,
+      lessonCount: detail.lessonCount,
+      currentModuleTitle,
+      currentLessonTitle
+    }
+  };
+}
+async function writeFilesAdapter(cwd, courseMeta, content) {
+  return writeInstructionFiles(
+    cwd,
+    {
+      courseTitle: courseMeta.courseTitle,
+      courseId: courseMeta.courseId,
+      progress: courseMeta.progress.percent,
+      moduleCount: courseMeta.progress.moduleCount,
+      lessonCount: courseMeta.progress.lessonCount,
+      currentModuleTitle: courseMeta.progress.currentModuleTitle,
+      currentLessonTitle: courseMeta.progress.currentLessonTitle,
+      courseDescription: courseMeta.courseDescription
+    },
+    content
+  );
+}
+function buildPipelineDeps() {
+  return {
+    ...defaultDeps2,
+    fetchCourseMeta: fetchCourseMetaViaHttp,
+    writeFiles: writeFilesAdapter
+  };
+}
+var logger6;
+var init_pipeline_deps = __esm({
+  "src/commands/_shared/pipeline-deps.ts"() {
+    "use strict";
+    init_src();
+    init_courses();
+    init_http2();
+    init_instruction_pipeline();
+    init_instruction_files();
+    logger6 = createLogger("cli:pipeline-deps");
+  }
+});
+
 // src/commands/select.ts
 import { Command as Command6 } from "commander";
-var logger5, selectCommand;
+import os9 from "node:os";
+var logger7, selectCommand;
 var init_select = __esm({
   "src/commands/select.ts"() {
     "use strict";
@@ -3055,13 +3823,15 @@ var init_select = __esm({
     init_http2();
     init_session();
     init_formatter();
-    init_instruction_files();
-    logger5 = createLogger("cli:select");
+    init_status();
+    init_instruction_pipeline();
+    init_pipeline_deps();
+    logger7 = 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 {
         const session = await requireSession();
         const data = createHttpProvider(session.apiUrl, session.token);
-        const deps = { data, logger: logger5 };
+        const deps = { data, logger: logger7 };
         const courses3 = await listCourses({ userId: session.userId }, deps);
         let courseId = course;
         let enrollmentId = "";
@@ -3088,38 +3858,77 @@ var init_select = __esm({
           courseTags: matched?.tags,
           courseLevel: matched?.level
         });
-        let courseSlug2 = "";
+        const activeCourseForStatus = {
+          courseId: detail.courseId,
+          courseTitle: detail.courseTitle,
+          enrollmentId
+        };
+        const onboarding = await getCourseOnboardingStatus(activeCourseForStatus);
+        let pipelineResult = null;
         try {
-          courseSlug2 = generateInstructionFiles({
-            courseTitle: detail.courseTitle,
-            courseId: detail.courseId,
-            progress: detail.progress,
-            moduleCount: detail.moduleCount,
-            lessonCount: detail.lessonCount,
-            courseDescription: detail.courseDescription
-          });
+          pipelineResult = await resolveAndGenerate(
+            { courseId: detail.courseId, enrollmentId },
+            { forceRefresh: false, collectT1Interactive: false, collectT2Interactive: false },
+            { cwd: process.cwd(), deps: buildPipelineDeps() }
+          );
         } catch (err) {
-          logger5.warn("Failed to generate instruction files", {
+          logger7.warn("Failed to run instruction pipeline", {
             error: err instanceof Error ? err.message : String(err)
           });
         }
+        const slugMatch = pipelineResult?.wroteFiles.find((f) => f.startsWith(".claude/commands/"))?.match(/tostudy-(.+)\.md$/);
+        const courseSlug2 = slugMatch?.[1] ?? "";
         if (opts.json) {
-          output({ ...detail, enrollmentId, courseSlug: courseSlug2 }, { json: true });
+          output(
+            {
+              ...detail,
+              enrollmentId,
+              courseSlug: courseSlug2,
+              workspacePath: onboarding.workspacePath,
+              workspaceSource: onboarding.workspaceSource,
+              wroteFiles: pipelineResult?.wroteFiles ?? [],
+              markerPath: pipelineResult?.markerPath ?? null,
+              usedT0: pipelineResult?.usedT0 ?? false,
+              usedT1: pipelineResult?.usedT1 ?? false,
+              usedT2: pipelineResult?.usedT2 ?? false
+            },
+            { json: true }
+          );
         } else {
           const slashCmd = courseSlug2 ? `/tostudy-${courseSlug2}` : "/tostudy";
-          output(
-            [
-              `\u2713 Curso ativado: ${detail.courseTitle}`,
-              `  Progresso: ${detail.progress}%  |  ${detail.moduleCount} m\xF3dulos  |  ${detail.lessonCount} li\xE7\xF5es`,
-              "",
-              "  Arquivos de contexto criados para seu assistente AI.",
-              "",
-              "\u2192 Abra sua plataforma (claude, codex, cursor...)",
-              `\u2192 No Claude Code, digite: ${slashCmd}`,
-              "\u2192 Em outras plataformas: tostudy init"
-            ].join("\n"),
-            { json: false }
+          const home = os9.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";
+          }
+          const lines = [
+            `\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."
+          ];
+          if (pipelineResult && !pipelineResult.usedT0) {
+            lines.push("  (sem persona do creator \u2014 usando tutor neutro)");
+          }
+          if (pipelineResult && !pipelineResult.usedT1) {
+            lines.push("  (sem brief base \u2014 rode `tostudy init` para configurar)");
+          }
+          lines.push(
+            "",
+            "\u2192 Abra sua plataforma (claude, codex, cursor...)",
+            `\u2192 No Claude Code, digite: ${slashCmd}`,
+            "\u2192 Em outras plataformas: tostudy init"
           );
+          output(lines.join("\n"), { json: false });
         }
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -3131,7 +3940,7 @@ var init_select = __esm({
 
 // src/commands/progress.ts
 import { Command as Command7 } from "commander";
-var logger6, progressCommand;
+var logger8, progressCommand;
 var init_progress = __esm({
   "src/commands/progress.ts"() {
     "use strict";
@@ -3140,15 +3949,15 @@ var init_progress = __esm({
     init_http2();
     init_session();
     init_formatter();
-    logger6 = createLogger("cli:progress");
+    logger8 = createLogger("cli:progress");
     progressCommand = new Command7("progress").description("Show your progress in the active course").option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
-        const activeCourse = await requireActiveCourse();
+        const activeCourse = await requireActiveCourse(void 0, { respectWorkspace: true });
         const driftWarning = await checkCourseDrift();
         if (driftWarning) process.stderr.write(driftWarning + "\n");
         const data = createHttpProvider(session.apiUrl, session.token);
-        const deps = { data, logger: logger6 };
+        const deps = { data, logger: logger8 };
         const progress3 = await getProgress({ enrollmentId: activeCourse.enrollmentId }, deps);
         if (opts.json) {
           output(progress3, { json: true });
@@ -4709,7 +5518,7 @@ var init_query_promise = __esm({
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce(
-    (result2, { path: path15, field }, columnIndex) => {
+    (result2, { path: path17, field }, columnIndex) => {
       let decoder;
       if (is(field, Column)) {
         decoder = field;
@@ -4721,8 +5530,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 path17.entries()) {
+        if (pathChunkIndex < path17.length - 1) {
           if (!(pathChunk in node)) {
             node[pathChunk] = {};
           }
@@ -4730,8 +5539,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) && path17.length === 2) {
+            const objectName = path17[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 +9487,13 @@ function Subscribe(postgres2, options) {
       }
     }
     function handle(a, b2) {
-      const path15 = b2.relation.schema + "." + b2.relation.table;
+      const path17 = 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("*:" + path17, a, b2);
+      b2.relation.keys.length && call("*:" + path17 + "=" + 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 + ":" + path17, a, b2);
+      b2.relation.keys.length && call(b2.command + ":" + path17 + "=" + b2.relation.keys.map((x2) => a[x2.name]), a, b2);
     }
     function pong() {
       const x2 = Buffer.alloc(34);
@@ -8797,8 +9606,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, path17, key] = xs;
+  return (command || "*") + (path17 ? ":" + (path17.indexOf(".") === -1 ? "public." + path17 : path17) : "") + (key ? "=" + key : "");
 }
 var noop2;
 var init_subscribe = __esm({
@@ -8879,8 +9688,8 @@ var init_large = __esm({
 });
 
 // ../../node_modules/postgres/src/index.js
-import os5 from "os";
-import fs5 from "fs";
+import os10 from "os";
+import fs8 from "fs";
 function Postgres(a, b2) {
   const options = parseOptions(a, b2), subscribe = options.no_subscribe || Subscribe(Postgres, { ...options });
   let ending = false;
@@ -8936,10 +9745,10 @@ function Postgres(a, b2) {
       });
       return query;
     }
-    function file2(path15, args = [], options2 = {}) {
+    function file2(path17, args = [], options2 = {}) {
       arguments.length === 2 && !Array.isArray(args) && (options2 = args, args = []);
       const query = new Query([], args, (query2) => {
-        fs5.readFile(path15, "utf8", (err, string4) => {
+        fs8.readFile(path17, "utf8", (err, string4) => {
           if (err)
             return query2.reject(err);
           query2.strings = [string4];
@@ -9257,7 +10066,7 @@ function parseUrl(url2) {
 }
 function osUsername() {
   try {
-    return os5.userInfo().username;
+    return os10.userInfo().username;
   } catch (_) {
     return process.env.USERNAME || process.env.USER || process.env.LOGNAME;
   }
@@ -13165,7 +13974,7 @@ async function hashQuery(sql2, params) {
   return hashHex;
 }
 var Cache, NoopCache;
-var init_cache = __esm({
+var init_cache3 = __esm({
   "../../node_modules/drizzle-orm/cache/core/cache.js"() {
     init_entity();
     Cache = class {
@@ -13190,7 +13999,7 @@ var init_cache = __esm({
 // ../../node_modules/drizzle-orm/cache/core/index.js
 var init_core = __esm({
   "../../node_modules/drizzle-orm/cache/core/index.js"() {
-    init_cache();
+    init_cache3();
   }
 });
 
@@ -13298,7 +14107,7 @@ var init_schema = __esm({
 var PgPreparedQuery, PgSession, PgTransaction;
 var init_session2 = __esm({
   "../../node_modules/drizzle-orm/pg-core/session.js"() {
-    init_cache();
+    init_cache3();
     init_entity();
     init_errors();
     init_sql2();
@@ -13518,12 +14327,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, logger23, 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 = logger23;
         this.fields = fields;
         this._isResponseInArrayMode = _isResponseInArrayMode;
         this.customResultMapper = customResultMapper;
@@ -13664,11 +14473,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 logger23;
   if (config2.logger === true) {
-    logger18 = new DefaultLogger();
+    logger23 = new DefaultLogger();
   } else if (config2.logger !== false) {
-    logger18 = config2.logger;
+    logger23 = config2.logger;
   }
   let schema;
   if (config2.schema) {
@@ -13682,7 +14491,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: logger23, cache: config2.cache });
   const db2 = new PostgresJsDatabase(dialect, session, schema);
   db2.$client = client;
   db2.$cache = config2.cache;
@@ -13884,7 +14693,7 @@ __export(util_exports, {
   required: () => required,
   safeExtend: () => safeExtend,
   shallowClone: () => shallowClone,
-  slugify: () => slugify3,
+  slugify: () => slugify2,
   stringifyPrimitive: () => stringifyPrimitive,
   uint8ArrayToBase64: () => uint8ArrayToBase64,
   uint8ArrayToBase64url: () => uint8ArrayToBase64url,
@@ -13997,10 +14806,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path15) {
-  if (!path15)
+function getElementAtPath(obj, path17) {
+  if (!path17)
     return obj;
-  return path15.reduce((acc, key) => acc?.[key], obj);
+  return path17.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -14024,7 +14833,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 +15121,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path15, issues) {
+function prefixIssues(path17, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path15);
+    iss.path.unshift(path17);
     return iss;
   });
 }
@@ -14558,7 +15367,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, path17 = []) => {
     var _a2, _b;
     for (const issue2 of error50.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -14568,7 +15377,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 = [...path17, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -14600,8 +15409,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 path17 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path17) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24158,7 +24967,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) {
@@ -24512,7 +25321,7 @@ function _stringFormat(Class2, format, fnOrRegex, _params = {}) {
   return inst;
 }
 var TimePrecision;
-var init_api2 = __esm({
+var init_api4 = __esm({
   "../../node_modules/zod/v4/core/api.js"() {
     init_checks2();
     init_registries();
@@ -25823,7 +26632,7 @@ var init_core3 = __esm({
     init_locales();
     init_registries();
     init_doc();
-    init_api2();
+    init_api4();
     init_to_json_schema();
     init_json_schema_processors();
     init_json_schema_generator();
@@ -27295,13 +28104,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 path17 = ref.slice(1).split("/").filter(Boolean);
+  if (path17.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path15[0] === defsKey) {
-    const key = path15[1];
+  if (path17[0] === defsKey) {
+    const key = path17[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -28490,7 +29299,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 +33739,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 +35947,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 +35955,6 @@ var init_archived = __esm({
     init_course_matrices();
     init_matrix_modules();
     init_course_variants();
-    init_user_credits();
   }
 });
 
@@ -36417,7 +37161,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",
@@ -38685,27 +39428,33 @@ var init_media_assets = __esm({
       "marketing",
       "other"
     ];
-    mediaAssets = pgTable("media_assets", {
-      id: uuid("id").defaultRandom().primaryKey(),
-      url: text("url").notNull(),
-      r2Key: text("r2_key").notNull(),
-      thumbnailUrl: text("thumbnail_url"),
-      type: text("type", { enum: mediaAssetTypeEnum }).notNull(),
-      mimeType: text("mime_type").notNull(),
-      title: text("title"),
-      originalFilename: text("original_filename").notNull(),
-      size: integer("size").notNull(),
-      width: integer("width"),
-      height: integer("height"),
-      tags: text("tags").array().default([]),
-      uploadedById: uuid("uploaded_by_id").references(() => users.id, {
-        onDelete: "set null"
-      }),
-      domain: text("domain", { enum: mediaAssetDomainEnum }),
-      domainEntityId: uuid("domain_entity_id"),
-      status: text("status", { enum: mediaAssetStatusEnum }).notNull().default("pending"),
-      createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-    });
+    mediaAssets = pgTable(
+      "media_assets",
+      {
+        id: uuid("id").defaultRandom().primaryKey(),
+        url: text("url").notNull(),
+        r2Key: text("r2_key").notNull(),
+        thumbnailUrl: text("thumbnail_url"),
+        type: text("type", { enum: mediaAssetTypeEnum }).notNull(),
+        mimeType: text("mime_type").notNull(),
+        title: text("title"),
+        originalFilename: text("original_filename").notNull(),
+        size: integer("size").notNull(),
+        width: integer("width"),
+        height: integer("height"),
+        tags: text("tags").array().default([]),
+        uploadedById: uuid("uploaded_by_id").references(() => users.id, {
+          onDelete: "set null"
+        }),
+        domain: text("domain", { enum: mediaAssetDomainEnum }),
+        domainEntityId: uuid("domain_entity_id"),
+        status: text("status", { enum: mediaAssetStatusEnum }).notNull().default("pending"),
+        createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+      },
+      (table) => ({
+        r2KeyUnique: uniqueIndex("media_assets_r2_key_unique").on(table.r2Key)
+      })
+    );
   }
 });
 
@@ -38896,7 +39645,6 @@ __export(schema_exports, {
   creditSubscriptionPlans: () => creditSubscriptionPlans,
   creditSubscriptionStatusEnum: () => creditSubscriptionStatusEnum,
   creditSubscriptions: () => creditSubscriptions,
-  creditTransactions: () => creditTransactions2,
   creditWalletTransactionTypeEnum: () => creditWalletTransactionTypeEnum,
   creditWalletTransactions: () => creditWalletTransactions,
   creditWallets: () => creditWallets,
@@ -39182,7 +39930,6 @@ __export(schema_exports, {
   testimonialStatusEnum: () => testimonialStatusEnum,
   threadStatusEnum: () => threadStatusEnum,
   toneEnum: () => toneEnum,
-  transactionTypeEnum: () => transactionTypeEnum,
   transactions: () => transactions2,
   transactionsRelations: () => transactionsRelations2,
   transferStatusEnum: () => transferStatusEnum,
@@ -39199,7 +39946,6 @@ __export(schema_exports, {
   userBadgesRelations: () => userBadgesRelations2,
   userChallengeScores: () => userChallengeScores,
   userChallengeScoresRelations: () => userChallengeScoresRelations,
-  userCredits: () => userCredits2,
   userFollows: () => userFollows2,
   userFollowsRelations: () => userFollowsRelations2,
   userPathEnrollments: () => userPathEnrollments,
@@ -40896,71 +41642,12 @@ 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) {
+async function runStart(opts, deps = defaultDeps3) {
   try {
     const session = await deps.requireSession();
-    const activeCourse = await deps.requireActiveCourse();
+    const activeCourse = await deps.requireActiveCourse(void 0, { respectWorkspace: true });
     const onboarding = await deps.getCourseOnboardingStatus(activeCourse);
     if (!onboarding.initReady) {
       deps.stderrWrite(`Dica: rode \`tostudy init\` para personalizar o tutor ao seu contexto.
@@ -40989,7 +41676,7 @@ async function runStart(opts, deps = defaultDeps2) {
     deps.error(msg);
   }
 }
-var logger7, defaultDeps2, startCommand;
+var logger9, defaultDeps3, startCommand;
 var init_start = __esm({
   "src/commands/start.ts"() {
     "use strict";
@@ -40999,8 +41686,8 @@ var init_start = __esm({
     init_session();
     init_status();
     init_formatter();
-    logger7 = createLogger("cli:start");
-    defaultDeps2 = {
+    logger9 = createLogger("cli:start");
+    defaultDeps3 = {
       requireSession,
       requireActiveCourse,
       checkCourseDrift,
@@ -41012,7 +41699,7 @@ var init_start = __esm({
       output,
       error,
       stderrWrite: (message) => process.stderr.write(message),
-      logger: logger7
+      logger: logger9
     };
     startCommand = new Command8("start").description("Start (or resume) the current module of the active course").option("--json", "Output structured JSON").action(async (opts) => {
       await runStart(opts);
@@ -41022,7 +41709,7 @@ var init_start = __esm({
 
 // src/commands/start-next.ts
 import { Command as Command9 } from "commander";
-var logger8, startNextCommand;
+var logger10, startNextCommand;
 var init_start_next = __esm({
   "src/commands/start-next.ts"() {
     "use strict";
@@ -41031,7 +41718,7 @@ var init_start_next = __esm({
     init_http2();
     init_session();
     init_formatter();
-    logger8 = createLogger("cli:start-next");
+    logger10 = createLogger("cli:start-next");
     startNextCommand = new Command9("start-next").description("Transition to the next module after completing the current one").option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
@@ -41039,7 +41726,7 @@ var init_start_next = __esm({
         const driftWarning = await checkCourseDrift();
         if (driftWarning) process.stderr.write(driftWarning + "\n");
         const data = createHttpProvider(session.apiUrl, session.token);
-        const deps = { data, logger: logger8 };
+        const deps = { data, logger: logger10 };
         const moduleData = await startNextModule({ enrollmentId: activeCourse.enrollmentId }, deps);
         await setActiveCourse({ ...activeCourse, currentLessonId: moduleData.firstLesson.id });
         if (opts.json) {
@@ -41062,7 +41749,7 @@ var init_start_next = __esm({
 
 // src/commands/next.ts
 import { Command as Command10 } from "commander";
-var logger9, nextCommand;
+var logger11, nextCommand;
 var init_next = __esm({
   "src/commands/next.ts"() {
     "use strict";
@@ -41071,15 +41758,15 @@ var init_next = __esm({
     init_http2();
     init_session();
     init_formatter();
-    logger9 = createLogger("cli:next");
+    logger11 = createLogger("cli:next");
     nextCommand = new Command10("next").description("Advance to the next lesson in the active course").option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
-        const activeCourse = await requireActiveCourse();
+        const activeCourse = await requireActiveCourse(void 0, { respectWorkspace: true });
         const driftWarning = await checkCourseDrift();
         if (driftWarning) process.stderr.write(driftWarning + "\n");
         const data = createHttpProvider(session.apiUrl, session.token);
-        const deps = { data, logger: logger9 };
+        const deps = { data, logger: logger11 };
         const lessonData = await nextLesson(
           { enrollmentId: activeCourse.enrollmentId, userConfirmation: "cli-next" },
           deps
@@ -41160,7 +41847,7 @@ function formatLessonContent(data) {
   }
   return lines.join("\n");
 }
-var logger10, lessonCommand;
+var logger12, lessonCommand;
 var init_lesson = __esm({
   "src/commands/lesson.ts"() {
     "use strict";
@@ -41170,15 +41857,15 @@ var init_lesson = __esm({
     init_session();
     init_formatter();
     init_resolve();
-    logger10 = createLogger("cli:lesson");
+    logger12 = createLogger("cli:lesson");
     lessonCommand = new Command11("lesson").description("Show the content of the current lesson").option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
-        const activeCourse = await requireActiveCourse();
+        const activeCourse = await requireActiveCourse(void 0, { respectWorkspace: true });
         const driftWarning = await checkCourseDrift();
         if (driftWarning) process.stderr.write(driftWarning + "\n");
         const data = createHttpProvider(session.apiUrl, session.token);
-        const deps = { data, logger: logger10 };
+        const deps = { data, logger: logger12 };
         const lessonId = activeCourse.currentLessonId;
         if (!lessonId) {
           error("Nenhuma li\xE7\xE3o ativa encontrada. Rode: tostudy start  ou  tostudy next");
@@ -41190,10 +41877,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"
             );
           }
         }
@@ -41207,7 +41898,7 @@ var init_lesson = __esm({
 
 // src/commands/hint.ts
 import { Command as Command12 } from "commander";
-var logger11, hintCommand;
+var logger13, hintCommand;
 var init_hint = __esm({
   "src/commands/hint.ts"() {
     "use strict";
@@ -41216,15 +41907,15 @@ var init_hint = __esm({
     init_http2();
     init_session();
     init_formatter();
-    logger11 = createLogger("cli:hint");
+    logger13 = createLogger("cli:hint");
     hintCommand = new Command12("hint").description("Get a progressive hint for the current exercise").option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
-        const activeCourse = await requireActiveCourse();
+        const activeCourse = await requireActiveCourse(void 0, { respectWorkspace: true });
         const driftWarning = await checkCourseDrift();
         if (driftWarning) process.stderr.write(driftWarning + "\n");
         const data = createHttpProvider(session.apiUrl, session.token);
-        const deps = { data, logger: logger11 };
+        const deps = { data, logger: logger13 };
         const hint = await getHint(
           { userId: session.userId, enrollmentId: activeCourse.enrollmentId },
           deps
@@ -41270,10 +41961,10 @@ var init_exercises = __esm({
 });
 
 // src/commands/validate.ts
-import fs8 from "node:fs";
-import path7 from "node:path";
+import fs9 from "node:fs";
+import path9 from "node:path";
 import { Command as Command13 } from "commander";
-var logger12, validateCommand;
+var logger14, validateCommand;
 var init_validate = __esm({
   "src/commands/validate.ts"() {
     "use strict";
@@ -41283,11 +41974,11 @@ var init_validate = __esm({
     init_session();
     init_formatter();
     init_init_template();
-    logger12 = createLogger("cli:validate");
+    logger14 = createLogger("cli:validate");
     validateCommand = new Command13("validate").description("Validate your solution for the current exercise").argument("[file]", "Path to the solution file to read").option("--stdin", "Read solution from stdin instead of a file").option("--json", "Output structured JSON").action(async (file2, opts) => {
       try {
         const session = await requireSession();
-        const activeCourse = await requireActiveCourse();
+        const activeCourse = await requireActiveCourse(void 0, { respectWorkspace: true });
         const driftWarning = await checkCourseDrift();
         if (driftWarning) process.stderr.write(driftWarning + "\n");
         const lessonId = activeCourse.currentLessonId;
@@ -41296,17 +41987,17 @@ var init_validate = __esm({
         }
         let solution;
         if (opts.stdin) {
-          solution = fs8.readFileSync("/dev/stdin", "utf-8");
+          solution = fs9.readFileSync("/dev/stdin", "utf-8");
         } else if (file2) {
-          if (!fs8.existsSync(file2)) {
+          if (!fs9.existsSync(file2)) {
             error(`Arquivo n\xE3o encontrado: ${file2}`);
           }
-          solution = fs8.readFileSync(file2, "utf-8");
+          solution = fs9.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 = path9.extname(file2).toLowerCase();
           const LANG_EXTENSIONS = {
             ".html": ["html", "html5"],
             ".css": ["css"],
@@ -41342,7 +42033,7 @@ var init_validate = __esm({
           }
         }
         const data = createHttpProvider(session.apiUrl, session.token);
-        const deps = { data, logger: logger12 };
+        const deps = { data, logger: logger14 };
         const result = await validateSolution(
           {
             lessonId,
@@ -41431,9 +42122,9 @@ var init_menu = __esm({
 });
 
 // src/onboarding/learner-context.ts
-import readline from "node:readline/promises";
+import readline2 from "node:readline/promises";
 import { stdin as input, stdout as output2 } from "node:process";
-async function askNonEmpty(question, deps, defaultValue) {
+async function askNonEmpty2(question, deps, defaultValue) {
   while (true) {
     const answer = (await deps.ask(question)).trim();
     if (answer.length > 0) return answer;
@@ -41449,7 +42140,7 @@ async function askChoice(question, choices, deps, defaultChoice) {
   }
 }
 function createPromptDeps() {
-  const rl = readline.createInterface({ input, output: output2 });
+  const rl = readline2.createInterface({ input, output: output2 });
   return {
     ask: (question) => rl.question(question),
     write: (content) => output2.write(content),
@@ -41482,32 +42173,32 @@ async function collectLearnerContextProfileWithDeps(input2, deps) {
     "keep"
   ) : "edit";
   const baseProfile = existingProfile;
-  const segment = action === "keep" && baseProfile ? baseProfile.segment : await askNonEmpty(
+  const segment = action === "keep" && baseProfile ? baseProfile.segment : await askNonEmpty2(
     baseProfile ? `Segmento ou nicho do aluno [${baseProfile.segment}]: ` : "Segmento ou nicho do aluno: ",
     deps,
     baseProfile?.segment
   );
-  const company = action === "keep" && baseProfile ? baseProfile.company : await askNonEmpty(
+  const company = action === "keep" && baseProfile ? baseProfile.company : await askNonEmpty2(
     baseProfile ? `Empresa ou tipo de negocio [${baseProfile.company}]: ` : "Empresa ou tipo de negocio: ",
     deps,
     baseProfile?.company
   );
-  const productsOrServices = action === "keep" && baseProfile ? baseProfile.productsOrServices : await askNonEmpty(
+  const productsOrServices = action === "keep" && baseProfile ? baseProfile.productsOrServices : await askNonEmpty2(
     baseProfile ? `Produtos ou servicos principais [${baseProfile.productsOrServices}]: ` : "Produtos ou servicos principais: ",
     deps,
     baseProfile?.productsOrServices
   );
-  const region = action === "keep" && baseProfile ? baseProfile.region : await askNonEmpty(
+  const region = action === "keep" && baseProfile ? baseProfile.region : await askNonEmpty2(
     baseProfile ? `Regiao de atuacao [${baseProfile.region}]: ` : "Regiao de atuacao: ",
     deps,
     baseProfile?.region
   );
-  const team = action === "keep" && baseProfile ? baseProfile.team : await askNonEmpty(
+  const team = action === "keep" && baseProfile ? baseProfile.team : await askNonEmpty2(
     baseProfile ? `Equipe envolvida neste contexto [${baseProfile.team}]: ` : "Equipe envolvida neste contexto: ",
     deps,
     baseProfile?.team
   );
-  const goal = action === "keep" && baseProfile ? baseProfile.goal : await askNonEmpty(
+  const goal = action === "keep" && baseProfile ? baseProfile.goal : await askNonEmpty2(
     baseProfile ? `Objetivo principal com este curso [${baseProfile.goal}]: ` : "Objetivo principal com este curso: ",
     deps,
     baseProfile?.goal
@@ -41556,7 +42247,7 @@ function isCompleteProfile(flags) {
     flags.segment && flags.company && flags.products && flags.region && flags.team && flags.goal && flags.level
   );
 }
-async function runInit(deps = defaultDeps3, flags = {}) {
+async function runInit(deps = defaultDeps4, flags = {}) {
   const session = await deps.getSession();
   if (!session) {
     deps.output("Nao autenticado. Rode `tostudy login` para comecar.", { json: false });
@@ -41671,22 +42362,20 @@ Rode \`tostudy select <n\xFAmero>\` para ativar um curso.`,
   });
   await deps.saveCourseLearnerProfile(activeCourse, learnerProfile, artifacts);
   try {
-    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
-      },
-      learnerProfile
+    const pipelineResult = await deps.resolveAndGenerate(
+      { courseId: activeCourse.courseId, enrollmentId: activeCourse.enrollmentId },
+      { forceRefresh: false, collectT1Interactive: true, collectT2Interactive: false },
+      { cwd: process.cwd(), deps: deps.buildPipelineDeps() }
     );
-    deps.logger.info("Instruction files enriched with learner profile");
+    deps.logger.info("Instruction files regenerated via pipeline", {
+      wroteFiles: pipelineResult.wroteFiles,
+      usedT0: pipelineResult.usedT0,
+      usedT1: pipelineResult.usedT1,
+      usedT2: pipelineResult.usedT2,
+      bootstrapped: pipelineResult.bootstrapped
+    });
   } catch (err) {
-    deps.logger.warn("Failed to update instruction files", {
+    deps.logger.warn("Failed to run instruction pipeline", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
@@ -41702,7 +42391,7 @@ Rode \`tostudy select <n\xFAmero>\` para ativar um curso.`,
     deps.output(artifacts.learnerBrief, { json: false });
   }
 }
-var logger13, defaultDeps3, initCommand;
+var logger15, defaultDeps4, initCommand;
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
@@ -41714,9 +42403,10 @@ var init_init = __esm({
     init_init_template();
     init_learner_context();
     init_api();
-    init_instruction_files();
-    logger13 = createLogger("cli:init");
-    defaultDeps3 = {
+    init_instruction_pipeline();
+    init_pipeline_deps();
+    logger15 = createLogger("cli:init");
+    defaultDeps4 = {
       getSession,
       getActiveCourse,
       listCourses,
@@ -41729,24 +42419,26 @@ var init_init = __esm({
       saveCourseLearnerProfile,
       buildInitArtifacts,
       output,
-      logger: logger13,
-      createHttpProvider
+      logger: logger15,
+      createHttpProvider,
+      resolveAndGenerate,
+      buildPipelineDeps
     };
     initCommand = new Command15("init").description("Generate tutor instructions and learner brief for the active course").option("--segment <segment>", "Learner segment/niche").option("--company <company>", "Company or business type").option("--products <products>", "Main products or services").option("--region <region>", "Operating region").option("--team <team>", "Team involved").option("--goal <goal>", "Primary learning goal").option("--level <level>", "Learner level: beginner, intermediate, advanced").option("--adapt-context", "Adapt examples to learner's real context").option("--json", "Output structured JSON").action(async (opts) => {
-      await runInit(defaultDeps3, opts);
+      await runInit(defaultDeps4, opts);
     });
   }
 });
 
 // ../../packages/tostudy-core/src/workspace/setup-workspace.ts
-import fs9 from "node:fs/promises";
-import path8 from "node:path";
+import fs10 from "node:fs/promises";
+import path10 from "node:path";
 async function setupWorkspace(input2) {
-  const workspacePath = path8.join(input2.basePath, input2.courseSlug);
+  const workspacePath = path10.join(input2.basePath, input2.courseSlug);
   for (const dir of WORKSPACE_DIRS) {
-    await fs9.mkdir(path8.join(workspacePath, dir), { recursive: true });
+    await fs10.mkdir(path10.join(workspacePath, dir), { recursive: true });
   }
-  const configPath = path8.join(workspacePath, ".ana-config.json");
+  const configPath = path10.join(workspacePath, ".ana-config.json");
   const config2 = {
     courseId: input2.courseId,
     courseSlug: input2.courseSlug,
@@ -41756,7 +42448,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 fs10.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
   const readme = [
     `# ${input2.courseName}`,
     "",
@@ -41781,7 +42473,7 @@ async function setupWorkspace(input2) {
     "tostudy vault sync      # Sincronizar progresso",
     "```"
   ].join("\n");
-  await fs9.writeFile(path8.join(workspacePath, "README.md"), readme, "utf-8");
+  await fs10.writeFile(path10.join(workspacePath, "README.md"), readme, "utf-8");
   return { workspacePath, directories: WORKSPACE_DIRS, configPath };
 }
 var WORKSPACE_DIRS;
@@ -41882,8 +42574,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 fs11 from "node:fs/promises";
+import path11 from "node:path";
 function padOrder(n) {
   return String(n).padStart(2, "0");
 }
@@ -41907,16 +42599,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 = path11.join(workspacePath, "exercises", moduleDir, lessonDir);
+  await fs11.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 = path11.join(exercisePath, cleanPath);
+      await fs11.mkdir(path11.dirname(fullPath), { recursive: true });
+      await fs11.writeFile(fullPath, fileData.code, "utf-8");
       extractedFiles.push(cleanPath);
       hasStarterCode = true;
     }
@@ -41924,13 +42616,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 fs11.writeFile(path11.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 fs11.writeFile(path11.join(exercisePath, "exercise.js"), starter, "utf-8");
         extractedFiles.push("exercise.js");
         hasStarterCode = true;
       }
@@ -41948,8 +42640,8 @@ async function extractExercise(input2) {
           ...exerciseDeps
         }
       };
-      await fs10.writeFile(
-        path9.join(exercisePath, "package.json"),
+      await fs11.writeFile(
+        path11.join(exercisePath, "package.json"),
         JSON.stringify(pkgJson, null, 2),
         "utf-8"
       );
@@ -41961,20 +42653,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 fs11.writeFile(path11.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 fs11.writeFile(path11.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 = path11.join(exercisePath, "README.md");
+  await fs11.writeFile(readmePath, readme, "utf-8");
   extractedFiles.push("README.md");
   return {
     exercisePath,
@@ -42046,109 +42738,151 @@ 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";
-var logger14, workspaceCommand;
+import path12 from "node:path";
+import os11 from "node:os";
+import fs12 from "node:fs/promises";
+var logger16, workspaceCommand;
 var init_workspace2 = __esm({
   "src/commands/workspace.ts"() {
     "use strict";
     init_src();
     init_workspace();
     init_session();
-    logger14 = createLogger("cli:workspace");
+    init_resolve();
+    logger16 = 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 ?? path12.join(process.cwd(), ".tostudy");
+          await fs12.mkdir(workspacePath, { recursive: true });
+          directories = ["exercises", "generated", "notes", "diagrams"];
+          for (const dir of directories) {
+            await fs12.mkdir(path12.join(workspacePath, dir), { recursive: true });
+          }
+          const configPath = path12.join(workspacePath, ".ana-config.json");
+          await fs12.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 ?? path12.join(os11.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
 `
           );
         }
       } catch (err) {
-        logger14.error("workspace setup failed", { error: err });
+        logger16.error("workspace setup failed", { error: err });
         process.stderr.write(`\u274C ${err instanceof Error ? err.message : String(err)}
 `);
         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", path12.join(os11.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 fs12.readFile(path12.join(workspacePath, ".ana-config.json"), "utf-8");
+          configData = JSON.parse(raw);
+        } catch {
+          configData = null;
+        }
+        const exercisesDir = path12.join(workspacePath, "exercises");
         let exerciseCount = 0;
         try {
-          const moduleDirs = await fs11.readdir(exercisesDir);
+          const moduleDirs = await fs12.readdir(exercisesDir);
           for (const modDir of moduleDirs) {
-            const modPath = path10.join(exercisesDir, modDir);
-            const stat = await fs11.stat(modPath);
+            const modPath = path12.join(exercisesDir, modDir);
+            const stat = await fs12.stat(modPath);
             if (stat.isDirectory()) {
-              const lessonDirs = await fs11.readdir(modPath);
+              const lessonDirs = await fs12.readdir(modPath);
               for (const lessonDir of lessonDirs) {
-                const lessonPath = path10.join(modPath, lessonDir);
-                const lstat = await fs11.stat(lessonPath);
+                const lessonPath = path12.join(modPath, lessonDir);
+                const lstat = await fs12.stat(lessonPath);
                 if (lstat.isDirectory()) exerciseCount++;
               }
             }
           }
         } catch {
         }
-        const generatedDir = path10.join(workspacePath, "generated");
+        const generatedDir = path12.join(workspacePath, "generated");
         let artifactCount = 0;
         try {
-          const files = await fs11.readdir(generatedDir);
+          const files = await fs12.readdir(generatedDir);
           artifactCount = files.length;
         } catch {
         }
-        const diagramsDir = path10.join(workspacePath, "diagrams");
+        const diagramsDir = path12.join(workspacePath, "diagrams");
         let diagramCount = 0;
         try {
-          const files = await fs11.readdir(diagramsDir);
+          const files = await fs12.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 +42894,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,9 +42922,10 @@ 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";
-var logger15, exportCommand;
+import path13 from "node:path";
+import os12 from "node:os";
+import fs13 from "node:fs/promises";
+var logger17, exportCommand;
 var init_export = __esm({
   "src/commands/export.ts"() {
     "use strict";
@@ -42198,8 +42934,8 @@ var init_export = __esm({
     init_http2();
     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) => {
+    logger17 = 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", path13.join(os12.homedir(), "study")).option("--json", "Output structured JSON").action(async (opts) => {
       try {
         const session = await requireSession();
         const activeCourse = await requireActiveCourse();
@@ -42209,10 +42945,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 = path13.join(ws.workspacePath, ".ana-config.json");
+          let hasConfig = false;
+          try {
+            await fs13.access(configPath);
+            hasConfig = true;
+          } catch {
+          }
+          if (!hasConfig) {
+            const slug = courseSlug(activeCourse.courseTitle);
+            logger17.info("Auto-initializing workspace", { workspacePath: ws.workspacePath });
+            await fs13.mkdir(ws.workspacePath, { recursive: true });
+            for (const dir of ["exercises", "generated", "notes", "diagrams"]) {
+              await fs13.mkdir(path13.join(ws.workspacePath, dir), { recursive: true });
+            }
+            await fs13.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 === path13.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);
         }
@@ -42243,7 +43026,7 @@ ${result.files.map((f) => `  \u{1F4C4} ${f}`).join("\n")}
           );
         }
       } catch (err) {
-        logger15.error("export failed", { error: err });
+        logger17.error("export failed", { error: err });
         process.stderr.write(`\u274C ${err instanceof Error ? err.message : String(err)}
 `);
         process.exit(1);
@@ -42255,49 +43038,45 @@ ${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;
-  }
-}
-var logger16, openCommand;
+import path14 from "node:path";
+import os13 from "node:os";
+var logger18, openCommand;
 var init_open = __esm({
   "src/commands/open.ts"() {
     "use strict";
     init_src();
     init_session();
-    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) => {
+    init_resolve();
+    logger18 = createLogger("cli:open");
+    openCommand = new Command18("open").description("Abrir workspace do curso na IDE").option("--path <dir>", "Diret\xF3rio base do workspace", path14.join(os13.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 });
+            logger18.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) {
-        logger16.error("open command failed", { error: err });
+        logger18.error("open command failed", { error: err });
         process.stderr.write(`\u274C ${err instanceof Error ? err.message : String(err)}
 `);
         process.exit(1);
@@ -42324,24 +43103,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 fs14 from "node:fs/promises";
+import path15 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 = path15.join(outputPath, file2.relativePath);
+    await fs14.mkdir(path15.dirname(fullPath), { recursive: true });
+    await fs14.writeFile(fullPath, file2.content, "utf-8");
   }
-  const vaultPath = path13.join(outputPath, courseSlug2);
+  const vaultPath = path15.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 fs14.mkdir(vaultPath, { recursive: true });
+  await fs14.writeFile(
+    path15.join(vaultPath, VAULT_MARKER_FILENAME),
     JSON.stringify(marker, null, 2),
     "utf-8"
   );
@@ -42366,10 +43145,10 @@ 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";
-var logger17, vaultCommand;
+import path16 from "node:path";
+import os14 from "node:os";
+import fs15 from "node:fs/promises";
+var logger19, vaultCommand;
 var init_vault2 = __esm({
   "src/commands/vault.ts"() {
     "use strict";
@@ -42378,17 +43157,31 @@ var init_vault2 = __esm({
     init_courses();
     init_http2();
     init_session();
-    logger17 = createLogger("cli:vault");
+    init_resolve();
+    logger19 = 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", path16.join(os14.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,9 +43203,9 @@ var init_vault2 = __esm({
           data.files,
           vaultOutputPath,
           activeCourse.courseId,
-          courseSlug2
+          slug
         );
-        logger17.info("Vault generated", {
+        logger19.info("Vault generated", {
           courseId: activeCourse.courseId,
           vaultPath: result.vaultPath,
           filesWritten: result.filesWritten
@@ -42445,31 +43238,42 @@ Para visualizar:
           );
         }
       } catch (err) {
-        logger17.error("vault init failed", { error: err });
+        logger19.error("vault init failed", { error: err });
         process.stderr.write(`\u274C ${err instanceof Error ? err.message : String(err)}
 `);
         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", path16.join(os14.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 deps = { data, logger: logger19 };
         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 = path16.join(vaultPath, ".ana-vault.json");
+        const markerRaw = await fs15.readFile(markerPath, "utf-8");
         const marker = JSON.parse(markerRaw);
         marker.lastSyncedAt = (/* @__PURE__ */ new Date()).toISOString();
         marker.progress = {
@@ -42477,10 +43281,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 fs15.writeFile(markerPath, JSON.stringify(marker, null, 2), "utf-8");
+        const courseIndexPath = path16.join(vaultPath, slug, "index.md");
         try {
-          let indexContent = await fs14.readFile(courseIndexPath, "utf-8");
+          let indexContent = await fs15.readFile(courseIndexPath, "utf-8");
           indexContent = indexContent.replace(/\n---\n\n> 📊 Progresso:.*\n/g, "");
           const titleEnd = indexContent.indexOf("\n");
           if (titleEnd !== -1) {
@@ -42491,7 +43295,7 @@ Para visualizar:
 `;
             indexContent = indexContent.slice(0, titleEnd) + banner + indexContent.slice(titleEnd);
           }
-          await fs14.writeFile(courseIndexPath, indexContent, "utf-8");
+          await fs15.writeFile(courseIndexPath, indexContent, "utf-8");
         } catch {
         }
         const syncedAt = marker.lastSyncedAt;
@@ -42520,7 +43324,7 @@ Para visualizar:
           );
         }
       } catch (err) {
-        logger17.error("vault sync failed", { error: err });
+        logger19.error("vault sync failed", { error: err });
         process.stderr.write(`\u274C ${err instanceof Error ? err.message : String(err)}
 `);
         process.exit(1);
@@ -42596,15 +43400,206 @@ var init_profile = __esm({
   }
 });
 
+// src/commands/sync.ts
+import { Command as Command21 } from "commander";
+var logger20, syncCommand;
+var init_sync = __esm({
+  "src/commands/sync.ts"() {
+    "use strict";
+    init_src();
+    init_session();
+    init_formatter();
+    init_instruction_pipeline();
+    init_pipeline_deps();
+    logger20 = createLogger("cli:sync");
+    syncCommand = new Command21("sync").description("Regenerate instruction files with updated progress").option("--json", "Output structured JSON").action(async (opts) => {
+      try {
+        await requireSession();
+        const activeCourse = await requireActiveCourse();
+        const pipelineResult = await resolveAndGenerate(
+          { courseId: activeCourse.courseId, enrollmentId: activeCourse.enrollmentId },
+          { forceRefresh: true, collectT1Interactive: false, collectT2Interactive: false },
+          { cwd: process.cwd(), deps: buildPipelineDeps() }
+        );
+        if (opts.json) {
+          output(
+            {
+              status: "ok",
+              courseId: activeCourse.courseId,
+              courseTitle: activeCourse.courseTitle,
+              wroteFiles: pipelineResult.wroteFiles,
+              markerPath: pipelineResult.markerPath,
+              usedT0: pipelineResult.usedT0,
+              usedT1: pipelineResult.usedT1,
+              usedT2: pipelineResult.usedT2
+            },
+            { json: true }
+          );
+        } else {
+          output(
+            [
+              `\u2713 Instru\xE7\xF5es sincronizadas para "${activeCourse.courseTitle}"`,
+              `  - T0 (persona): ${pipelineResult.usedT0 ? "presente" : "ausente"}`,
+              `  - T1 (brief base): ${pipelineResult.usedT1 ? "presente" : "ausente"}`,
+              `  - T2 (curso): ${pipelineResult.usedT2 ? "presente" : "ausente"}`,
+              `  - Arquivos: ${pipelineResult.wroteFiles.join(", ")}`
+            ].join("\n"),
+            { json: false }
+          );
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("process.exit")) return;
+        logger20.warn("sync failed", { error: msg });
+        error(msg);
+      }
+    });
+  }
+});
+
+// src/commands/brief.ts
+import { Command as Command22 } from "commander";
+var logger21, briefCommand;
+var init_brief = __esm({
+  "src/commands/brief.ts"() {
+    "use strict";
+    init_src();
+    init_session();
+    init_cache();
+    init_api2();
+    init_formatter();
+    logger21 = createLogger("cli:brief");
+    briefCommand = new Command22("brief").description("Show your base learner brief (T1) status and content").option("--json", "Output structured JSON").action(async (opts) => {
+      try {
+        const session = await requireSession();
+        const cached2 = await readBriefCache();
+        const remote = await fetchLearnerBrief({
+          apiUrl: session.apiUrl,
+          token: session.token
+        });
+        if (opts.json) {
+          output(
+            {
+              cached: cached2?.brief ?? null,
+              remote,
+              cacheFetchedAt: cached2?.fetchedAt ?? null
+            },
+            { json: true }
+          );
+          return;
+        }
+        if (!remote) {
+          const lines2 = [
+            "Voce ainda nao tem um brief base preenchido.",
+            "Para criar: `tostudy brief-create` (terminal) ou `tostudy brief-open` (portal web)."
+          ];
+          output(lines2.join("\n"), { json: false });
+          return;
+        }
+        const lines = [`Brief base (atualizado em ${remote.updatedAt}):`, "", remote.text, ""];
+        if (cached2 && cached2.brief && cached2.brief.updatedAt !== remote.updatedAt) {
+          lines.push("Aviso: cache local esta desatualizado. Rode `tostudy sync` para atualizar.");
+        }
+        output(lines.join("\n"), { json: false });
+      } catch (err) {
+        logger21.error("Failed to show brief", { err });
+        error(`Erro ao buscar brief: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    });
+  }
+});
+
+// src/commands/brief-create.ts
+import { Command as Command23 } from "commander";
+var logger22, briefCreateCommand;
+var init_brief_create = __esm({
+  "src/commands/brief-create.ts"() {
+    "use strict";
+    init_src();
+    init_session();
+    init_bootstrap();
+    init_api2();
+    init_cache();
+    init_formatter();
+    logger22 = createLogger("cli:brief-create");
+    briefCreateCommand = new Command23("brief-create").description("Create your base learner brief via interactive prompts (T1 bootstrap)").action(async () => {
+      try {
+        const session = await requireSession();
+        const answers = await collectBootstrapAnswers({ userName: session.userName });
+        const text2 = composeBriefFromAnswers(answers);
+        const previewLines = ["", "Brief composto:", "---", text2, "---"];
+        output(previewLines.join("\n"), { json: false });
+        const brief = await upsertLearnerBrief({
+          apiUrl: session.apiUrl,
+          token: session.token,
+          text: text2,
+          source: "manual"
+        });
+        await writeBriefCache(void 0, {
+          userId: session.userId,
+          brief,
+          fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const doneLines = [
+          "",
+          "Brief salvo. Rode `tostudy sync` para atualizar os instruction files."
+        ];
+        output(doneLines.join("\n"), { json: false });
+      } catch (err) {
+        logger22.error("Failed to create brief", { err });
+        error(`Erro ao criar brief: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    });
+  }
+});
+
+// src/commands/brief-open.ts
+import { Command as Command24 } from "commander";
+import { execFile as execFile4 } from "node:child_process";
+import { platform } from "node:process";
+function openUrl(url2) {
+  let cmd;
+  let args;
+  if (platform === "darwin") {
+    cmd = "open";
+    args = [url2];
+  } else if (platform === "win32") {
+    cmd = "cmd";
+    args = ["/c", "start", "", url2];
+  } else {
+    cmd = "xdg-open";
+    args = [url2];
+  }
+  execFile4(cmd, args, (err) => {
+    if (err) {
+      output(`Nao consegui abrir o navegador. Acesse manualmente: ${url2}`, { json: false });
+    }
+  });
+}
+var BRIEF_URL, briefOpenCommand;
+var init_brief_open = __esm({
+  "src/commands/brief-open.ts"() {
+    "use strict";
+    init_session();
+    init_formatter();
+    BRIEF_URL = "https://tostudy.ai/student/settings/learner-brief";
+    briefOpenCommand = new Command24("brief-open").description("Open the learner brief editor in your web browser").action(async () => {
+      await requireSession();
+      output(`Abrindo ${BRIEF_URL} no navegador...`, { json: false });
+      openUrl(BRIEF_URL);
+    });
+  }
+});
+
 // src/cli.ts
 var cli_exports = {};
 __export(cli_exports, {
   CLI_VERSION: () => CLI_VERSION,
   createProgram: () => createProgram
 });
-import { Command as Command21 } from "commander";
+import { Command as Command25 } from "commander";
 function createProgram() {
-  const program2 = new Command21();
+  const program2 = new Command25();
   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);
@@ -42622,7 +43617,11 @@ function createProgram() {
   program2.addCommand(validateCommand);
   program2.addCommand(menuCommand);
   program2.addCommand(profileCommand);
+  program2.addCommand(briefCommand);
+  program2.addCommand(briefCreateCommand);
+  program2.addCommand(briefOpenCommand);
   program2.addCommand(workspaceCommand);
+  program2.addCommand(syncCommand);
   program2.addCommand(exportCommand);
   program2.addCommand(openCommand);
   program2.addCommand(vaultCommand);
@@ -42652,7 +43651,11 @@ var init_cli = __esm({
     init_open();
     init_vault2();
     init_profile();
-    CLI_VERSION = true ? "0.7.4" : "0.7.1";
+    init_sync();
+    init_brief();
+    init_brief_create();
+    init_brief_open();
+    CLI_VERSION = true ? "0.9.0" : "0.7.1";
   }
 });