paris-immersion 0.1.35 → 0.1.38

package/dist/commands/conectar.d.ts

@@ -0,0 +1,3 @@
+export declare function conectarCommand(opts?: {
+    open?: boolean;
+}): Promise<void>;

package/dist/commands/conectar.js

@@ -0,0 +1,168 @@
+import { execFile, spawnSync } from 'node:child_process';
+import { promisify } from 'node:util';
+import { promises as fs } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { findMarker } from '../lib/marker.js';
+import { apiAuthFetch, ApiError } from '../lib/api.js';
+import { readCredentials } from '../lib/credentials.js';
+import { c } from '../lib/colors.js';
+import { loginCommand } from './login.js';
+import { installCommand, ensureWorkspace } from './install.js';
+import { locateWorkspace } from './repair.js';
+import { maybeSelfUpdate } from '../lib/self-update.js';
+const execFileAsync = promisify(execFile);
+async function tokenOk() {
+    try {
+        const ws = await apiAuthFetch('/immersion-app/v1/workspace');
+        return { ok: true, slug: ws.immersion?.slug };
+    }
+    catch (err) {
+        if (err instanceof ApiError)
+            return { ok: false, status: err.status, detail: err.message };
+        return { ok: false, status: 0, detail: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * A pasta da TURMA ATUAL (slug que o servidor devolve). O aluno pode ter a pasta
+ * do treino e a da turma lado a lado — consertar a errada deixaria o mentor cego.
+ * Ordem: a pasta onde ele está (se for da turma) → ~/paris-<slug> → qualquer
+ * ~/paris-* da turma → null (o chamador cria ~/paris-<slug>).
+ */
+async function workspaceForSlug(slug) {
+    if (!slug)
+        return locateWorkspace();
+    const here = await findMarker();
+    if (here && here.marker.immersion_slug === slug)
+        return here.dir;
+    const home = homedir();
+    const names = await fs.readdir(home).catch(() => []);
+    const ordered = [`paris-${slug}`, ...names.filter((n) => n.startsWith('paris-') && n !== `paris-${slug}`)];
+    for (const name of ordered) {
+        const m = await findMarker(path.join(home, name)).catch(() => null);
+        if (m && m.dir === path.join(home, name) && m.marker.immersion_slug === slug)
+            return m.dir;
+    }
+    return null;
+}
+async function runHookCheck(dir) {
+    const hook = path.join(dir, '.paris', 'hooks', 'paris-hook.mjs');
+    try {
+        // `node` do PATH, igual ao Claude Code — se não achar, o hook do aluno
+        // também não roda, e é isso que queremos descobrir.
+        const { stdout } = await execFileAsync('node', [hook, 'check'], {
+            cwd: dir,
+            timeout: 60_000,
+            env: { ...process.env, CLAUDE_PROJECT_DIR: dir },
+        });
+        const line = stdout.trim().split('\n').pop() ?? '';
+        return JSON.parse(line);
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === 'ENOENT')
+            return { error: '`node` não está no PATH — o Claude Code não consegue rodar o hook. Reinstale pelo instalador da imersão.' };
+        return { error: (e.stderr || e.message || String(err)).trim().slice(0, 300) };
+    }
+}
+// Windows: `paris`/`claude` são shims .cmd — precisam de shell pra resolver.
+const SHELL = process.platform === 'win32';
+export async function conectarCommand(opts = {}) {
+    console.log(c.bold('paris conectar'));
+    console.log();
+    // 0. Versão mais nova no npm? Atualiza e roda o conectar DA VERSÃO NOVA (o
+    // hook que vai pro workspace sai do template dela). É isto que substitui o
+    // `npm i -g paris-immersion@latest && ...` colado à mão no treino de 30/09.
+    if (!process.env.PARIS_CONECTAR_UPDATED) {
+        const updated = await maybeSelfUpdate((m) => console.log(c.dim(m)), true);
+        if (updated) {
+            const args = ['conectar', ...(opts.open === false ? ['--no-open'] : [])];
+            const r = spawnSync('paris', args, {
+                stdio: 'inherit',
+                shell: SHELL,
+                env: { ...process.env, PARIS_CONECTAR_UPDATED: '1' },
+            });
+            if (!r.error) {
+                process.exitCode = r.status ?? 0;
+                return;
+            }
+            console.log(c.yellow('○ Atualizei, mas não consegui reabrir o paris — seguindo nesta versão.'));
+        }
+    }
+    // 1. Login
+    let creds = await readCredentials().catch(() => null);
+    let tk = creds ? await tokenOk() : { ok: false, status: 401 };
+    if (!tk.ok && tk.status === 0) {
+        console.log(c.red(`✗ Sem conexão com o servidor (${tk.detail}).`));
+        console.log(c.dim('  Confira o Wi-Fi (ou use o roteador do celular) e rode `paris conectar` de novo.'));
+        console.log(c.dim('  Nada se perde: o que você fizer offline fica guardado e sobe quando a conexão voltar.'));
+        process.exitCode = 1;
+        return;
+    }
+    if (!tk.ok && (tk.status === 401 || tk.status === 403)) {
+        console.log(c.yellow('○ Seu login venceu ou não existe — vamos entrar de novo.'));
+        await loginCommand({ apiUrl: creds?.api_url });
+        creds = await readCredentials().catch(() => null);
+        tk = creds ? await tokenOk() : { ok: false, status: 401 };
+    }
+    if (!tk.ok) {
+        const why = tk.status === 410 ? 'a imersão já foi encerrada pra esta conta' : `${tk.status ?? ''} ${tk.detail ?? ''}`.trim();
+        console.log(c.red(`✗ Login não funcionou: ${why}.`));
+        console.log(c.dim('  Chame o mentor da sua mesa.'));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(c.green(`✓ Login ok (${creds.email})`));
+    // 2. Workspace + hooks frescos
+    let wsDir = await workspaceForSlug(tk.slug);
+    if (!wsDir) {
+        // Mesmo lugar previsível que o terminal embutido usa (~/paris-<slug>).
+        console.log(c.yellow('○ Não achei a pasta da turma — criando agora.'));
+        wsDir = tk.slug ? path.join(homedir(), `paris-${tk.slug}`) : (await ensureWorkspace()).dir;
+    }
+    await installCommand({ dir: wsDir });
+    console.log(c.green(`✓ Pasta e ferramentas do Claude atualizadas (${wsDir})`));
+    // 3. Envio real pelo hook
+    const r = await runHookCheck(wsDir);
+    if ('error' in r) {
+        console.log(c.red(`✗ O hook do Claude não rodou: ${r.error}`));
+        process.exitCode = 1;
+        return;
+    }
+    if (r.lastStatus < 200 || r.lastStatus >= 300) {
+        const why = r.lastStatus === 0 ? 'sem resposta do servidor (rede)' : `servidor respondeu ${r.lastStatus}`;
+        console.log(c.red(`✗ Envio falhou: ${why}. ${r.pending} evento(s) seguem guardados.`));
+        console.log(c.dim('  Rode `paris conectar` de novo em 1 minuto.'));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(c.green(`✓ Envio ok (${r.sent} evento(s) enviados${r.pending ? `, ${r.pending} ainda na fila` : ''})`));
+    // 4. Prova do lado do servidor
+    try {
+        const st = await apiAuthFetch('/api/activity/status/me');
+        const age = st.lastActivity ? Date.now() - new Date(st.lastActivity).getTime() : Infinity;
+        if (age > 5 * 60_000) {
+            console.log(c.red('✗ O servidor não registrou o evento — a conta logada não está na turma.'));
+            console.log(c.dim(`  Você entrou como ${creds.email}. Se não é o e-mail da inscrição, rode \`paris logout\` e \`paris conectar\`.`));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    catch (err) {
+        console.log(c.yellow(`○ Não consegui confirmar no servidor (${err instanceof Error ? err.message : String(err)}), mas o envio passou.`));
+    }
+    console.log();
+    console.log(c.green(c.bold('Conectado. O mentor está vendo seu terminal.')));
+    // Hooks e MCP só recarregam num Claude novo — reabre na pasta da imersão,
+    // continuando a última conversa (igual ao `paris repair`).
+    if (opts.open === false) {
+        console.log(c.dim('Se o Claude já estava aberto: saia com /exit e abra de novo na pasta da imersão com `claude --continue`.'));
+        return;
+    }
+    console.log(c.dim('Abrindo o Claude na pasta da imersão (continuando a última conversa)...'));
+    console.log();
+    const cont = spawnSync('claude', ['--continue'], { cwd: wsDir, stdio: 'inherit', shell: SHELL });
+    if (cont.error || (cont.status !== 0 && cont.status !== null)) {
+        spawnSync('claude', [], { cwd: wsDir, stdio: 'inherit', shell: SHELL });
+    }
+}

package/dist/commands/install.js

@@ -7,7 +7,7 @@ import { findMarker, writeMarker } from '../lib/marker.js';
 import { readCredentials } from '../lib/credentials.js';
 import { c } from '../lib/colors.js';
 import { renderClaudeMd } from '../templates/claude-md.js';
-import { renderSettingsJson } from '../templates/settings.js';
+import { renderSettingsJson, renderMcpJson } from '../templates/settings.js';
 import { renderParisCoachSkill } from '../templates/skill.js';
 import { renderHookScript } from '../templates/hook.js';
 import { renderTostudyCommand } from '../templates/tostudy-command.js';
@@ -119,6 +119,8 @@ async function writeWorkspaceFiles(targetDir, boot, apiUrl, email) {
     const settingsPayload = renderSettingsJson({ apiUrl });
     await fs.writeFile(path.join(claudeDir, 'settings.json'), JSON.stringify(settingsPayload, null, 2));
     await fs.writeFile(path.join(claudeDir, 'settings.local.json'), JSON.stringify(settingsPayload, null, 2));
+    // .mcp.json — é daqui que o Claude Code carrega o MCP do projeto (não do settings).
+    await fs.writeFile(path.join(targetDir, '.mcp.json'), JSON.stringify(renderMcpJson({ apiUrl }), null, 2));
     // .claude/skills/paris-coach/SKILL.md
     const skillDir = path.join(claudeDir, 'skills', 'paris-coach');
     await fs.mkdir(skillDir, { recursive: true });

package/dist/commands/mentor.d.ts

@@ -7,6 +7,6 @@
  * usuário (`claude mcp add --scope user`). A partir daí ele pergunta em
  * linguagem natural ("como está o João?", "quem travou hoje?") e o Claude
  * responde com dado real via tools turma_overview / find_student /
- * student_activity / who_needs_help / add_note.
+ * student_activity / who_needs_help / add_note / minha_mesa.
  */
 export declare function mentorCommand(): Promise<void>;

package/dist/commands/mentor.js

@@ -14,7 +14,7 @@ import { c } from '../lib/colors.js';
  * usuário (`claude mcp add --scope user`). A partir daí ele pergunta em
  * linguagem natural ("como está o João?", "quem travou hoje?") e o Claude
  * responde com dado real via tools turma_overview / find_student /
- * student_activity / who_needs_help / add_note.
+ * student_activity / who_needs_help / add_note / minha_mesa.
  */
 export async function mentorCommand() {
     const creds = await readCredentials();

package/dist/commands/repair.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `paris repair` — uma palavra só, sem `cd` nem `&&`. Existe porque o comando
+ * longo colado do WhatsApp quebrava (o app troca espaços por NBSP e o shell lê
+ * `cd: too many arguments`). Acha o workspace sozinho (a partir da pasta atual,
+ * subindo; senão o `~/paris-*` mais recente), reescreve hooks, MCP (.mcp.json),
+ * settings e CLAUDE.md SEM tocar no trabalho do aluno, e reabre o Claude na
+ * raiz continuando a última conversa.
+ */
+export declare function locateWorkspace(): Promise<string | null>;
+export declare function repairCommand(opts: {
+    open?: boolean;
+}): Promise<void>;

package/dist/commands/repair.js

@@ -0,0 +1,48 @@
+import { promises as fs } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { findMarker } from '../lib/marker.js';
+import { c } from '../lib/colors.js';
+import { installCommand } from './install.js';
+/**
+ * `paris repair` — uma palavra só, sem `cd` nem `&&`. Existe porque o comando
+ * longo colado do WhatsApp quebrava (o app troca espaços por NBSP e o shell lê
+ * `cd: too many arguments`). Acha o workspace sozinho (a partir da pasta atual,
+ * subindo; senão o `~/paris-*` mais recente), reescreve hooks, MCP (.mcp.json),
+ * settings e CLAUDE.md SEM tocar no trabalho do aluno, e reabre o Claude na
+ * raiz continuando a última conversa.
+ */
+export async function locateWorkspace() {
+    const here = await findMarker();
+    if (here)
+        return here.dir;
+    const home = homedir();
+    const entries = await fs.readdir(home).catch(() => []);
+    let best = null;
+    for (const name of entries) {
+        if (!name.startsWith('paris-'))
+            continue;
+        const marker = path.join(home, name, '.paris', 'workspace.json');
+        const st = await fs.stat(marker).catch(() => null);
+        if (st && (!best || st.mtimeMs > best.mtime))
+            best = { dir: path.join(home, name), mtime: st.mtimeMs };
+    }
+    return best?.dir ?? null;
+}
+export async function repairCommand(opts) {
+    const dir = await locateWorkspace();
+    if (!dir) {
+        console.error(c.red('Não achei a pasta da imersão. Rode `paris install` primeiro.'));
+        process.exit(1);
+    }
+    console.log(c.dim(`Consertando o workspace em ${dir}...`));
+    await installCommand({ dir });
+    if (opts.open === false)
+        return;
+    console.log(c.green('✓ Pronto. Abrindo o Claude na pasta da imersão (continuando a última conversa)...'));
+    const cont = spawnSync('claude', ['--continue'], { cwd: dir, stdio: 'inherit' });
+    if (cont.error || (cont.status !== 0 && cont.status !== null)) {
+        spawnSync('claude', [], { cwd: dir, stdio: 'inherit' });
+    }
+}

package/dist/commands/serve.js

@@ -9,7 +9,7 @@ import { startRelayAgent } from '../lib/relay-agent.js';
 import { parseMissionAction, startMissionInOrca } from '../lib/orca-launcher.js';
 import { renderTostudyCommand } from '../templates/tostudy-command.js';
 import { renderHookScript } from '../templates/hook.js';
-import { renderSettingsJson } from '../templates/settings.js';
+import { renderSettingsJson, renderMcpJson } from '../templates/settings.js';
 import { fileURLToPath } from 'node:url';
 import { maybeSelfUpdate } from '../lib/self-update.js';
 import { c } from '../lib/colors.js';
@@ -210,6 +210,7 @@ function ensureWorkspaceVendored(cwd) {
             const payload = JSON.stringify(renderSettingsJson({ apiUrl: marker.api_url }), null, 2);
             writeFileSync(path.join(claudeDir, 'settings.json'), payload);
             writeFileSync(path.join(claudeDir, 'settings.local.json'), payload);
+            writeFileSync(path.join(cwd, '.mcp.json'), JSON.stringify(renderMcpJson({ apiUrl: marker.api_url }), null, 2));
         }
     }
     catch {
@@ -478,6 +479,10 @@ export async function serveCommand(opts) {
     try {
         const { dir, created } = await ensureWorkspace({});
         cwd = dir;
+        // Auto-cura já no boot do daemon (não só quando o terminal embutido abre):
+        // quem usa o Claude no terminal próprio/Orca também recebe .mcp.json/hook novos
+        // assim que o self-update reinicia o serve.
+        ensureWorkspaceVendored(dir);
         console.log(created
             ? `  ${c.green('✓')} workspace criado em ${c.bold(dir)}`
             : `  ${c.dim('workspace:')} ${dir}`);

package/dist/index.js

@@ -3,6 +3,8 @@ import { Command } from 'commander';
 import { createRequire } from 'node:module';
 import { loginCommand } from './commands/login.js';
 import { installCommand } from './commands/install.js';
+import { repairCommand } from './commands/repair.js';
+import { conectarCommand } from './commands/conectar.js';
 import { doctorCommand } from './commands/doctor.js';
 import { tasksCommand } from './commands/tasks.js';
 import { statusCommand } from './commands/status.js';
@@ -32,6 +34,16 @@ program
     .option('-d, --dir <path>', 'pasta destino (padrão: cria uma nova com o slug da imersão)')
     .option('--immersion <slug>', 'imersão específica (caso o aluno esteja em mais de uma)')
     .action(installCommand);
+program
+    .command('repair')
+    .description('Conserta a pasta da imersão (hooks, ferramentas do Claude) sem apagar nada e reabre o Claude')
+    .option('--no-open', 'só conserta, não abre o Claude')
+    .action(repairCommand);
+program
+    .command('conectar')
+    .description('Comando de emergência: atualiza a CLI, reloga se preciso, conserta a pasta, prova que o mentor está te vendo e reabre o Claude')
+    .option('--no-open', 'só conecta, não abre o Claude')
+    .action(conectarCommand);
 program
     .command('doctor')
     .description('Diagnostica credentials, marker, hooks, conectividade')

package/dist/templates/hook.js

@@ -25,7 +25,7 @@ import { homedir } from 'node:os'
 import path from 'node:path'
 import { execFile } from 'node:child_process'
 
-const PHASE = process.argv[2] // session-start | user-prompt-submit | stop | post-tool-use
+const PHASE = process.argv[2] // session-start | user-prompt-submit | stop | post-tool-use | check
 
 const FETCH_TIMEOUT_MS = 4000
 const QUEUE_FLUSH_AT = 25    // flush quando a fila acumula isso
@@ -159,34 +159,78 @@ function enqueueActivity(markerDir, event) {
   } catch { /* fila é best-effort */ }
 }
 
+function parseLines(raw) {
+  const events = []
+  for (const l of raw.split('\\n')) {
+    if (!l) continue
+    try { events.push(JSON.parse(l)) } catch {}
+  }
+  return events
+}
+
 async function readQueue(markerDir) {
   try {
-    const raw = await fs.readFile(queuePath(markerDir), 'utf-8')
-    const lines = raw.split('\\n').filter(Boolean)
-    // Cap duro: descarta o mais antigo.
-    const kept = lines.length > QUEUE_MAX_LINES ? lines.slice(lines.length - QUEUE_MAX_LINES) : lines
-    const events = []
-    for (const l of kept) { try { events.push(JSON.parse(l)) } catch {} }
-    return events
+    return parseLines(await fs.readFile(queuePath(markerDir), 'utf-8'))
   } catch { return [] }
 }
 
-async function writeQueue(markerDir, events) {
+// Devolve eventos não enviados pra fila com APPEND (nunca sobrescreve — o que
+// outro hook enfileirou enquanto a rede rodava continua lá). Cap duro aplicado
+// no próximo claim.
+function requeue(markerDir, events) {
+  if (events.length === 0) return
   try {
-    if (events.length === 0) {
-      await fs.rm(queuePath(markerDir), { force: true })
-    } else {
-      await fs.writeFile(queuePath(markerDir), events.map((e) => JSON.stringify(e)).join('\\n') + '\\n')
-    }
+    appendFileSync(queuePath(markerDir), events.map((e) => JSON.stringify(e)).join('\\n') + '\\n')
   } catch { /* best-effort */ }
 }
 
-// Flush em lotes de BATCH_SIZE. Trunca em 2xx E em 4xx (fila envenenada não
-// pode travar pra sempre); retém em 5xx/rede pra tentar de novo depois.
+// Status em que o lote é VENENO (nunca vai passar) → descarta. Todo o resto
+// (rede, 5xx, 401/403 de token, 408, 429 de rate-limit) RETÉM pra tentar depois.
+// Antes, qualquer 4xx descartava — um token vencido ou um 429 apagava a fila.
+function isPoison(status) {
+  return status === 400 || status === 413 || status === 422
+}
+
+// Flush em lotes de BATCH_SIZE com CLAIM ATÔMICO: renomeia a fila pra um arquivo
+// .sending exclusivo deste processo antes de ler. Assim hooks concorrentes
+// (tool calls em paralelo, Stop + PostToolUse) nunca mandam o mesmo evento duas
+// vezes nem apagam o que foi enfileirado durante o envio (o writeFile antigo
+// sobrescrevia a fila inteira — eventos e PROMPTS sumiam). Também adota .sending
+// órfãos (> 2 min) de um hook que morreu no meio.
+// Retorna { sent, pending, lastStatus }.
 async function flushActivityQueue(apiUrl, token, markerDir) {
-  const events = await readQueue(markerDir)
-  if (events.length === 0) return
+  const dir = path.join(markerDir, '.paris')
+  const claimed = path.join(dir, 'activity-queue.' + process.pid + '-' + Date.now() + '.sending')
+  let events = []
+  try {
+    await fs.rename(queuePath(markerDir), claimed)
+    events = parseLines(await fs.readFile(claimed, 'utf-8'))
+  } catch { /* fila vazia ou outro hook pegou */ }
+  try {
+    const now = Date.now()
+    for (const name of await fs.readdir(dir)) {
+      if (!name.endsWith('.sending')) continue
+      const fp = path.join(dir, name)
+      if (fp === claimed) continue
+      const st = await fs.stat(fp).catch(() => null)
+      if (!st || now - st.mtimeMs < 120000) continue
+      const orphan = path.join(dir, name + '.adopt-' + process.pid)
+      try {
+        await fs.rename(fp, orphan)
+        events = events.concat(parseLines(await fs.readFile(orphan, 'utf-8')))
+        await fs.rm(orphan, { force: true })
+      } catch {}
+    }
+  } catch {}
+  if (events.length > QUEUE_MAX_LINES) events = events.slice(events.length - QUEUE_MAX_LINES)
+  if (events.length === 0) {
+    await fs.rm(claimed, { force: true }).catch(() => {})
+    return { sent: 0, pending: 0, lastStatus: 200 }
+  }
+
   let idx = 0
+  let sent = 0
+  let lastStatus = 0
   while (idx < events.length) {
     const chunk = events.slice(idx, idx + BATCH_SIZE)
     const status = await apiPostStatus(apiUrl, '/api/activity/claude-code', token, {
@@ -194,11 +238,16 @@ async function flushActivityQueue(apiUrl, token, markerDir) {
       cwd: chunk[chunk.length - 1].cwd,
       events: chunk,
     })
-    const dropChunk = (status >= 200 && status < 300) || (status >= 400 && status < 500)
-    if (!dropChunk) break // 5xx/rede: para e retém o resto
+    lastStatus = status
+    const ok = status >= 200 && status < 300
+    if (!ok && !isPoison(status)) break // rede/5xx/401/429: retém o resto
+    if (ok) sent += chunk.length
     idx += chunk.length
   }
-  await writeQueue(markerDir, events.slice(idx))
+  const rest = events.slice(idx)
+  requeue(markerDir, rest)
+  await fs.rm(claimed, { force: true }).catch(() => {})
+  return { sent, pending: rest.length, lastStatus }
 }
 
 async function refreshMarkerStatus(markerDir, marker, status) {
@@ -315,6 +364,33 @@ async function main() {
     return
   }
 
+  // PROMPT PRIMEIRO, antes de qualquer rede: vai pra fila local com o horário
+  // real. Antes o prompt só subia DEPOIS de 3 GETs de contexto — se a API
+  // demorasse/caísse o hook saía cedo e o prompt sumia; e não havia retry.
+  // Agora ele fica na fila até o servidor confirmar.
+  let promptFlush = null
+  if (PHASE === 'user-prompt-submit' && hookInput && typeof hookInput.prompt === 'string' && hookInput.prompt.trim()) {
+    enqueueActivity(marker.dir, {
+      hook_event_name: 'UserPromptSubmit',
+      prompt: truncate(hookInput.prompt, 8000),
+      session_id: hookInput.session_id,
+      cwd: hookInput.cwd,
+      at: Date.now(),
+    })
+    // Sobe em paralelo com a busca de contexto (não soma latência).
+    promptFlush = flushActivityQueue(apiUrl, creds.token, marker.dir).catch(() => null)
+  }
+
+  // \`paris conectar\` roda o PRÓPRIO hook com 'check': enfileira um evento de
+  // conexão e faz o flush pelo caminho real (mesmo node, mesma fila, mesmo
+  // token, mesma URL). Imprime o resultado em JSON pro comando ler.
+  if (PHASE === 'check') {
+    enqueueActivity(marker.dir, { hook_event_name: 'ConnectionCheck', cwd: marker.dir, at: Date.now() })
+    const r = await flushActivityQueue(apiUrl, creds.token, marker.dir)
+    process.stdout.write(JSON.stringify({ ...r, apiUrl }) + '\\n')
+    return
+  }
+
   if (PHASE === 'stop') {
     await apiPost(apiUrl, '/immersion-app/v1/events', creds.token, { type: 'turn_ended' })
     await flushActivityQueue(apiUrl, creds.token, marker.dir)
@@ -332,18 +408,23 @@ async function main() {
   ])
 
   if (!workspace) {
-    process.stderr.write('[paris-hook] não foi possível buscar contexto. Está offline?\\n')
+    if (promptFlush) await promptFlush
+    process.stderr.write('[paris-hook] não foi possível buscar contexto. Está offline? (seu prompt ficou salvo e sobe quando a conexão voltar)\\n')
     return
   }
   // Mantém o marker em dia com o servidor — é o marker que silencia o
   // PostToolUse pós-graduação (o caminho quente não consulta a API).
   await refreshMarkerStatus(marker.dir, marker.marker, workspace.status)
-  if (workspace.status === 'graduated') return
+  if (workspace.status === 'graduated') { if (promptFlush) await promptFlush; return }
 
   // Onboarding: enquanto o curso não termina, o terminal roda o tutor do curso
   // (/tostudy) — isso tem prioridade sobre as missões da imersão (que nem existem
   // na fase pre).
   const inCourse = !!(course && course.courseCompleted === false)
+  // Timer da turma: a Missão 1 (o curso) ainda não abriu — D1 cedo, na abertura
+  // com o apresentador. Sem isto o hook mandava rodar /tostudy às 08:00 e o
+  // Claude começava o curso no meio da apresentação.
+  const courseNotOpenYet = inCourse && !!(current && current.reason === 'waiting_next_window' && current.current && current.current.status === 'locked')
 
   const lines = []
   if (PHASE === 'session-start') {
@@ -357,7 +438,14 @@ async function main() {
     lines.push('')
   }
 
-  if (inCourse) {
+  if (courseNotOpenYet) {
+    lines.push('## ANTES DA PRIMEIRA MISSÃO')
+    lines.push(current.current.socio_prompt || ('A primeira missão abre no horário do bloco dela. Não rode /tostudy antes.'))
+    if (PHASE === 'session-start') {
+      lines.push('')
+      lines.push('**Comece falando primeiro**, em 2 ou 3 linhas: confirme que está tudo conectado e diga a que horas a Missão 1 começa.')
+    }
+  } else if (inCourse) {
     lines.push('## FASE DO CURSO DE ONBOARDING')
     lines.push('O aluno está na etapa do curso **' + course.title + '** (progresso: **' + course.lessonsCompleted + '/' + course.totalLessons + '**).')
     lines.push('Rode **/tostudy** pra conduzir o curso da ToStudy (o comando está instalado no workspace e o aluno já chega logado). Ele ativa o curso e ensina lição por lição. NÃO trabalhe em missões da imersão enquanto o curso não terminar. (Fallback: ferramentas MCP **get_course**/**complete_lesson** do paris.)')
@@ -406,14 +494,8 @@ async function main() {
     // turn_started fecha o ciclo do turno (com turn_ended no stop) → permite medir
     // cadência/duração de turno e detectar "mandou prompt e não houve resposta".
     await apiPost(apiUrl, '/immersion-app/v1/events', creds.token, { type: 'turn_started' })
-    if (hookInput && hookInput.prompt) {
-      await apiPost(apiUrl, '/api/activity/claude-code', creds.token, {
-        hook_event_name: 'UserPromptSubmit',
-        prompt: hookInput.prompt,
-        session_id: hookInput.session_id,
-        cwd: hookInput.cwd,
-      })
-    }
+    // O prompt já está na fila (topo do main) — aqui só espera o envio terminar.
+    if (promptFlush) await promptFlush
   }
 
   // Na fase do curso, sincroniza o progresso da ToStudy também ao abrir/retomar

package/dist/templates/settings.d.ts

@@ -10,3 +10,11 @@
 export declare function renderSettingsJson(opts: {
     apiUrl: string;
 }): Record<string, unknown>;
+/**
+ * `.mcp.json` do workspace — o ÚNICO lugar de onde o Claude Code carrega MCP de
+ * projeto. Sem ele o aluno fica sem get_current_task/mark_task_complete/
+ * log_event e a missão não conclui sozinha (só pelo botão da War Room).
+ */
+export declare function renderMcpJson(opts: {
+    apiUrl: string;
+}): Record<string, unknown>;

package/dist/templates/settings.js

@@ -7,6 +7,10 @@
  * already a prerequisite. Paths are relative to the workspace root, which is
  * the cwd Claude Code uses when launching hooks and MCP servers.
  */
+// Hooks apontam pra RAIZ do projeto ($CLAUDE_PROJECT_DIR, setado pelo Claude Code
+// em todo hook). Com caminho relativo, bastava o Claude dar `cd` numa subpasta
+// (ex.: vault/10-SOPs) pra TODO hook falhar com MODULE_NOT_FOUND — o aluno some
+// do painel e a sessão enche de "Stop hook error" (treino 30/09, 2026-09-30).
 export function renderSettingsJson(opts) {
     return {
         $schema: 'https://json.schemastore.org/claude-code-settings.json',
@@ -14,6 +18,12 @@ export function renderSettingsJson(opts) {
         // pode não conectar o server numa sessão não-interativa (terminal embutido),
         // e o tutor abre sem as tools get_course/complete_lesson.
         enableAllProjectMcpServers: true,
+        // O Claude Code NÃO carrega `mcpServers` do settings.json — MCP de projeto
+        // vive no `.mcp.json` (renderMcpJson abaixo). Este bloco fica só por
+        // compatibilidade; o que liga o server de verdade é o .mcp.json + esta
+        // pré-aprovação (sem ela o server fica "Pending approval"). Achado no
+        // teste real de 2026-09-29: o Claude do aluno abria SEM mark_task_complete.
+        enabledMcpjsonServers: ['paris-immersion'],
         mcpServers: {
             'paris-immersion': {
                 command: 'node',
@@ -30,7 +40,7 @@ export function renderSettingsJson(opts) {
                     hooks: [
                         {
                             type: 'command',
-                            command: 'node .paris/hooks/paris-hook.mjs session-start',
+                            command: 'node "$CLAUDE_PROJECT_DIR/.paris/hooks/paris-hook.mjs" session-start',
                         },
                     ],
                 },
@@ -41,7 +51,7 @@ export function renderSettingsJson(opts) {
                     hooks: [
                         {
                             type: 'command',
-                            command: 'node .paris/hooks/paris-hook.mjs user-prompt-submit',
+                            command: 'node "$CLAUDE_PROJECT_DIR/.paris/hooks/paris-hook.mjs" user-prompt-submit',
                         },
                     ],
                 },
@@ -56,7 +66,7 @@ export function renderSettingsJson(opts) {
                     hooks: [
                         {
                             type: 'command',
-                            command: 'node .paris/hooks/paris-hook.mjs post-tool-use',
+                            command: 'node "$CLAUDE_PROJECT_DIR/.paris/hooks/paris-hook.mjs" post-tool-use',
                         },
                     ],
                 },
@@ -67,7 +77,7 @@ export function renderSettingsJson(opts) {
                     hooks: [
                         {
                             type: 'command',
-                            command: 'node .paris/hooks/paris-hook.mjs stop',
+                            command: 'node "$CLAUDE_PROJECT_DIR/.paris/hooks/paris-hook.mjs" stop',
                         },
                     ],
                 },
@@ -75,3 +85,19 @@ export function renderSettingsJson(opts) {
         },
     };
 }
+/**
+ * `.mcp.json` do workspace — o ÚNICO lugar de onde o Claude Code carrega MCP de
+ * projeto. Sem ele o aluno fica sem get_current_task/mark_task_complete/
+ * log_event e a missão não conclui sozinha (só pelo botão da War Room).
+ */
+export function renderMcpJson(opts) {
+    return {
+        mcpServers: {
+            'paris-immersion': {
+                command: 'node',
+                args: ['.paris/mcp/index.mjs'],
+                env: { PARIS_API_URL: opts.apiUrl },
+            },
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paris-immersion",
-  "version": "0.1.35",
+  "version": "0.1.38",
   "description": "Paris Immersion CLI — login, install workspace, status, task control. Para alunos das imersões da Paris Group.",
   "homepage": "https://parisgroup.ai",
   "repository": {