paris-immersion 0.1.36 → 0.1.39

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,217 @@
+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';
+import { restartDaemon } from '../lib/daemon.js';
+import net from 'node:net';
+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;
+}
+/**
+ * Religa o agente local (o `paris serve` que o botão do curso na War Room usa) e
+ * só aprova quando ELE disser que conectou no relay. Um agente preso com login
+ * antigo deixava a War Room em "Não achei o paris rodando" (D1 de outubro).
+ * Dentro do terminal embutido não religa: este terminal É o agente.
+ */
+async function ensureLocalAgent() {
+    if (process.env.PARIS_MCP_ENABLED === '1')
+        return { ok: true, detail: 'você já está no terminal do curso' };
+    const logFile = path.join(homedir(), '.paris', 'serve.log');
+    const offset = await fs.stat(logFile).then((s) => s.size).catch(() => 0);
+    try {
+        await restartDaemon();
+    }
+    catch (err) {
+        return { ok: false, detail: `não consegui religar o serviço: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    const portOpen = () => new Promise((resolve) => {
+        const s = net.connect(31000, '127.0.0.1');
+        s.once('connect', () => { s.destroy(); resolve(true); });
+        s.once('error', () => resolve(false));
+        s.setTimeout(1000, () => { s.destroy(); resolve(false); });
+    });
+    for (let i = 0; i < 40; i++) {
+        await new Promise((r) => setTimeout(r, 750));
+        const fresh = await fs
+            .readFile(logFile)
+            .then((b) => b.subarray(offset).toString('utf8'))
+            .catch(() => '');
+        if (/relay: conectado|relay ativo/.test(fresh))
+            return { ok: true, detail: 'conectado' };
+        if (/login expirado/.test(fresh))
+            return { ok: false, detail: 'o login do agente não vale — rode `paris logout` e `paris conectar`' };
+    }
+    // Sem relay configurado (dev local) o agente só escuta a porta local.
+    return (await portOpen())
+        ? { ok: true, detail: 'rodando (sem relay)' }
+        : { ok: false, detail: 'o agente não subiu' };
+}
+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. Agente local do curso (botão "abrir o curso" da War Room)
+    const agent = await ensureLocalAgent();
+    if (!agent.ok) {
+        console.log(c.red(`✗ Agente do curso: ${agent.detail}. Chame um mentor técnico.`));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(c.green(`✓ Agente do curso ${agent.detail}`));
+    // 5. 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/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

@@ -1,3 +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

@@ -13,7 +13,7 @@ import { installCommand } from './install.js';
  * settings e CLAUDE.md SEM tocar no trabalho do aluno, e reabre o Claude na
  * raiz continuando a última conversa.
  */
-async function locateWorkspace() {
+export async function locateWorkspace() {
     const here = await findMarker();
     if (here)
         return here.dir;

package/dist/index.js

@@ -4,6 +4,7 @@ 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';
@@ -38,6 +39,11 @@ program
     .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/lib/relay-agent.d.ts

@@ -13,4 +13,8 @@ export declare function startRelayAgent(opts: {
     loginToken: string;
     cwd: string;
     log?: (msg: string) => void;
+    /** Lê o token de login atual do disco (default: ~/.paris/credentials). Teste injeta. */
+    readLoginToken?: () => Promise<string | null>;
+    /** Intervalo entre releituras do login enquanto ele está inválido (default 15s). */
+    unauthRetryMs?: number;
 }): Promise<RelayAgentHandle | null>;

package/dist/lib/relay-agent.js

@@ -39,6 +39,11 @@ function open(key, frame) {
         return null;
     }
 }
+async function defaultReadLoginToken() {
+    const { readCredentials } = await import('./credentials.js');
+    const creds = await readCredentials().catch(() => null);
+    return creds?.token ?? null;
+}
 /**
  * Inicia o agente relay. Busca o serve-token + info do relay na API (Bearer
  * creds.token), e se o relay estiver configurado, mantém a conexão wss e spawna
@@ -48,10 +53,28 @@ export async function startRelayAgent(opts) {
     if (!opts.apiUrl || !opts.loginToken)
         return null;
     const log = opts.log ?? (() => { });
+    // O loginToken NÃO é fixo: o aluno pode relogar (`paris login`/`paris conectar`)
+    // com o daemon rodando. Antes o agente guardava o token do boot pra sempre e,
+    // depois de um re-login, ficava a noite inteira em "login expirado" até alguém
+    // rodar `paris restart` (visto no D1 de outubro, 06/10 07:59). Agora, a cada
+    // 'unauthorized', ele relê ~/.paris/credentials e troca pelo token novo.
+    let loginToken = opts.loginToken;
+    const reloadLoginToken = async () => {
+        try {
+            const creds = await (opts.readLoginToken ?? defaultReadLoginToken)();
+            if (creds && creds !== loginToken) {
+                loginToken = creds;
+                log('paris: login novo detectado — reconectando');
+                return true;
+            }
+        }
+        catch { /* sem arquivo de credenciais: segue esperando */ }
+        return false;
+    };
     const fetchInfo = async () => {
         try {
             const res = await fetch(`${opts.apiUrl.replace(/\/$/, '')}/api/onboarding/v2/serve-token`, {
-                headers: { authorization: `Bearer ${opts.loginToken}` },
+                headers: { authorization: `Bearer ${loginToken}` },
                 signal: AbortSignal.timeout(8000),
             });
             if (res.ok)
@@ -85,9 +108,15 @@ export async function startRelayAgent(opts) {
         await sleep(5000);
         initial = await fetchInfo();
     }
-    if (initial.kind === 'unauthorized') {
+    // Login inválido no boot: em vez de desistir do relay (o agente ficava fora até
+    // um restart manual), espera o aluno relogar — relê o arquivo de login a cada
+    // `unauthRetryMs` e segue assim que ele mudar e a API aceitar.
+    const unauthRetryMs = opts.unauthRetryMs ?? 15_000;
+    while (initial.kind === 'unauthorized') {
         log(RELOGIN_HINT);
-        return null;
+        await sleep(unauthRetryMs);
+        await reloadLoginToken();
+        initial = await fetchInfo(); // mesmo token pode passar (ex.: participante criado depois)
     }
     if (initial.kind !== 'ok' || !initial.info.relayUrl || !initial.info.token || !initial.info.e2eKeyB64)
         return null;
@@ -255,8 +284,16 @@ export async function startRelayAgent(opts) {
             // Token de login morto: NÃO re-disca com o velho (o relay 401-a e o loop
             // nunca surfacing). Loga o caminho de re-login e agenda uma tentativa
             // espaçada — se o aluno rodar `paris login`, a próxima busca passa e reata.
+            // Login trocado no disco (re-login com o daemon rodando)? Usa o novo e
+            // reconecta já. Senão espaça e loga o caminho de re-login.
+            if (await reloadLoginToken()) {
+                nextRetryMs = RETRY_FAST_MS;
+                if (!closed)
+                    reconnect = setTimeout(connect, 0);
+                return;
+            }
             log(RELOGIN_HINT);
-            nextRetryMs = RETRY_UNAUTH_MS;
+            nextRetryMs = opts.unauthRetryMs ?? RETRY_UNAUTH_MS;
             if (!closed)
                 reconnect = setTimeout(connect, nextRetryMs);
             return;

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/package.json

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

package/templates/mcp/admin.mjs

@@ -3107,9 +3107,9 @@ var require_data = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fast-uri@3.1.7/node_modules/fast-uri/lib/utils.js
+// ../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/utils.js
 var require_utils = __commonJS({
-  "../../node_modules/.pnpm/fast-uri@3.1.7/node_modules/fast-uri/lib/utils.js"(exports, module) {
+  "../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/utils.js"(exports, module) {
     "use strict";
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
@@ -3609,9 +3609,9 @@ var require_utils = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fast-uri@3.1.7/node_modules/fast-uri/lib/schemes.js
+// ../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/schemes.js
 var require_schemes = __commonJS({
-  "../../node_modules/.pnpm/fast-uri@3.1.7/node_modules/fast-uri/lib/schemes.js"(exports, module) {
+  "../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/schemes.js"(exports, module) {
     "use strict";
     var { isUUID } = require_utils();
     var URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
@@ -3820,9 +3820,9 @@ var require_schemes = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fast-uri@3.1.7/node_modules/fast-uri/index.js
+// ../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/index.js
 var require_fast_uri = __commonJS({
-  "../../node_modules/.pnpm/fast-uri@3.1.7/node_modules/fast-uri/index.js"(exports, module) {
+  "../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/index.js"(exports, module) {
     "use strict";
     var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
@@ -4152,13 +4152,14 @@ var require_fast_uri = __commonJS({
         if (!malformedIPLiteral) {
           malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
         }
-        if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-          if (uri.indexOf("%") !== -1) {
-            if (parsed.host !== void 0 && !malformedIPLiteral) {
-              const host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
-              parsed.host = reescapeHostDelimiters(host, isIP);
-            }
+        if (uri.indexOf("%") !== -1 && parsed.host !== void 0 && !malformedIPLiteral) {
+          let host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+          if (!isIP) {
+            host = normalizePercentEncoding(host.toLowerCase());
           }
+          parsed.host = reescapeHostDelimiters(host, isIP);
+        }
+        if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
           if (parsed.path) {
             parsed.path = normalizePathEncoding(parsed.path);
           }
@@ -18485,6 +18486,12 @@ function buildAdminTools() {
         note: external_exports.string().min(1)
       }),
       handler: async ({ participantId, note }, { client }) => client.post(`/api/participants/${participantId}/notes`, { note })
+    },
+    {
+      name: "minha_mesa",
+      description: 'Sua mesa de mentoria HOJE: r\xF3tulo da mesa, dia da imers\xE3o, os alunos dela (status ao vivo, miss\xE3o atual, pedidos de ajuda pendentes), compara\xE7\xE3o mesa \xD7 turma e o hist\xF3rico das suas mesas por dia. Use quando o mentor perguntar "como est\xE1 a minha mesa?". Se voc\xEA ainda n\xE3o tem mesa hoje, mostra os alunos sem mesa (assuma pelo painel web em Minha mesa).',
+      inputSchema: external_exports.object({}),
+      handler: async (_, { client }) => client.get("/api/mesas/minha")
     }
   ];
 }

package/templates/mcp/index.mjs

@@ -3107,9 +3107,9 @@ var require_data = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fast-uri@3.1.7/node_modules/fast-uri/lib/utils.js
+// ../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/utils.js
 var require_utils = __commonJS({
-  "../../node_modules/.pnpm/fast-uri@3.1.7/node_modules/fast-uri/lib/utils.js"(exports, module) {
+  "../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/utils.js"(exports, module) {
     "use strict";
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
@@ -3609,9 +3609,9 @@ var require_utils = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fast-uri@3.1.7/node_modules/fast-uri/lib/schemes.js
+// ../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/schemes.js
 var require_schemes = __commonJS({
-  "../../node_modules/.pnpm/fast-uri@3.1.7/node_modules/fast-uri/lib/schemes.js"(exports, module) {
+  "../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/schemes.js"(exports, module) {
     "use strict";
     var { isUUID } = require_utils();
     var URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
@@ -3820,9 +3820,9 @@ var require_schemes = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fast-uri@3.1.7/node_modules/fast-uri/index.js
+// ../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/index.js
 var require_fast_uri = __commonJS({
-  "../../node_modules/.pnpm/fast-uri@3.1.7/node_modules/fast-uri/index.js"(exports, module) {
+  "../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/index.js"(exports, module) {
     "use strict";
     var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
@@ -4152,13 +4152,14 @@ var require_fast_uri = __commonJS({
         if (!malformedIPLiteral) {
           malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
         }
-        if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-          if (uri.indexOf("%") !== -1) {
-            if (parsed.host !== void 0 && !malformedIPLiteral) {
-              const host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
-              parsed.host = reescapeHostDelimiters(host, isIP);
-            }
+        if (uri.indexOf("%") !== -1 && parsed.host !== void 0 && !malformedIPLiteral) {
+          let host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+          if (!isIP) {
+            host = normalizePercentEncoding(host.toLowerCase());
           }
+          parsed.host = reescapeHostDelimiters(host, isIP);
+        }
+        if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
           if (parsed.path) {
             parsed.path = normalizePathEncoding(parsed.path);
           }