paris-immersion 0.1.25 → 0.1.27

package/dist/commands/doctor.js

@@ -9,6 +9,27 @@ import { readCredentials, credentialsPath } from '../lib/credentials.js';
 import { findMarker } from '../lib/marker.js';
 import { c } from '../lib/colors.js';
 const execFileAsync = promisify(execFile);
+/** `<bin> --version` responde? Best-effort com timeout curto — um binário
+ *  ausente ou travado nunca pode segurar o doctor. */
+async function hasCommand(bin) {
+    try {
+        await execFileAsync(bin, ['--version'], { timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Roda `<bin> <args>` só pelo exit code (usado nos checks de login). */
+async function commandSucceeds(bin, args) {
+    try {
+        await execFileAsync(bin, args, { timeout: 8000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export async function doctorCommand(opts = {}) {
     const checks = [];
     // 1. Credentials file
@@ -94,6 +115,68 @@ export async function doctorCommand(opts = {}) {
         ok: ptyOk,
         detail: ptyOk ? 'ok' : 'falhou ao carregar — o terminal embutido não abre. Reinstale: npm i -g paris-immersion@latest',
     });
+    // 9. Kit da imersão (gh, railway, orca, skills) — TODOS informativos: entram
+    // no doctor pra o aluno/mentor ver o que falta, mas NÃO bloqueiam o gate do
+    // install-status. Um aluno sem `gh auth` ainda faz o curso; ele conecta depois.
+    const ghPresent = await hasCommand('gh');
+    if (!ghPresent) {
+        checks.push({ name: 'github cli', ok: false, info: true, detail: 'não instalado — rode o instalador de novo ou veja https://cli.github.com' });
+    }
+    else {
+        const ghAuthed = await commandSucceeds('gh', ['auth', 'status']);
+        checks.push({
+            name: 'github cli',
+            ok: ghAuthed,
+            info: true,
+            detail: ghAuthed ? 'instalado e conectado' : 'instalado, mas sem conta conectada — rode: gh auth login',
+        });
+    }
+    const railwayPresent = await hasCommand('railway');
+    if (!railwayPresent) {
+        checks.push({ name: 'railway cli', ok: false, info: true, detail: 'não instalado — rode: npm i -g @railway/cli' });
+    }
+    else {
+        const railwayAuthed = await commandSucceeds('railway', ['whoami']);
+        checks.push({
+            name: 'railway cli',
+            ok: railwayAuthed,
+            info: true,
+            detail: railwayAuthed ? 'instalado e conectado' : 'instalado, mas sem conta conectada — rode: railway login',
+        });
+    }
+    // Orca: o CLI fica dentro do bundle do app, então checamos o symlink que o
+    // instalador cria E o .app em si (o aluno pode ter instalado só o app).
+    const orcaOnPath = await hasCommand('orca');
+    const orcaApp = orcaOnPath ||
+        (await Promise.all([
+            path.join(homedir(), '.local', 'bin', 'orca'),
+            '/Applications/Orca.app',
+            path.join(process.env.LOCALAPPDATA ?? '', 'Programs', 'Orca', 'Orca.exe'),
+        ].map((p) => (p ? fs.access(p).then(() => true).catch(() => false) : Promise.resolve(false)))).then((r) => r.some(Boolean)));
+    checks.push({
+        name: 'orca',
+        ok: orcaApp,
+        info: true,
+        detail: orcaApp ? 'instalado' : 'não encontrado — baixe em https://www.onorca.dev/download',
+    });
+    if (claudeInstalled) {
+        let pluginOk = false;
+        try {
+            const { stdout } = await execFileAsync('claude', ['plugin', 'list'], { timeout: 10_000 });
+            pluginOk = /imersao/i.test(stdout);
+        }
+        catch {
+            pluginOk = false;
+        }
+        checks.push({
+            name: 'skills da imersão',
+            ok: pluginOk,
+            info: true,
+            detail: pluginOk
+                ? 'plugin instalado'
+                : 'plugin ausente — no Claude Code rode: /plugin marketplace add https://github.com/parisgroup-ai/imersao-ia-setup e /plugin install imersao@imersao-ia',
+        });
+    }
     // Report
     console.log();
     console.log(c.bold('paris doctor'));

package/dist/commands/graduate.js

@@ -1,9 +1,20 @@
 import { apiAuthFetch } from '../lib/api.js';
+import { findMarker, writeMarker } from '../lib/marker.js';
 import { c } from '../lib/colors.js';
 export async function graduateCommand() {
     const res = await apiAuthFetch('/immersion-app/v1/graduate', {
         method: 'POST',
     });
+    // Silencia o watcher IMEDIATAMENTE: o PostToolUse só consulta o marker local
+    // (caminho quente, sem API) — sem esta escrita ele continuaria reportando até
+    // a próxima session-start refrescar o marker.
+    const found = await findMarker();
+    if (found) {
+        try {
+            await writeMarker(found.dir, { ...found.marker, status: 'graduated' });
+        }
+        catch { /* best-effort */ }
+    }
     if (res.status === 'already_graduated') {
         console.log(c.yellow(`Já estava graduado em ${res.graduated_at.slice(0, 10)}.`));
     }

package/dist/commands/mentor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `paris mentor` — instala o MCP paris-admin no Claude Code do MENTOR/ADMIN.
+ *
+ * O mentor loga com `paris login` (mesmo device-flow do aluno; o token carrega
+ * a role) e roda `paris mentor` uma vez: o bundle vendorizado vai pra
+ * ~/.paris/admin-mcp/index.mjs e é registrado no Claude Code em escopo de
+ * 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.
+ */
+export declare function mentorCommand(): Promise<void>;

package/dist/commands/mentor.js

@@ -0,0 +1,62 @@
+import { promises as fs } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execFile } from 'node:child_process';
+import { readCredentials } from '../lib/credentials.js';
+import { c } from '../lib/colors.js';
+/**
+ * `paris mentor` — instala o MCP paris-admin no Claude Code do MENTOR/ADMIN.
+ *
+ * O mentor loga com `paris login` (mesmo device-flow do aluno; o token carrega
+ * a role) e roda `paris mentor` uma vez: o bundle vendorizado vai pra
+ * ~/.paris/admin-mcp/index.mjs e é registrado no Claude Code em escopo de
+ * 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.
+ */
+export async function mentorCommand() {
+    const creds = await readCredentials();
+    if (!creds) {
+        console.log(c.red('Você precisa estar logado. Rode `paris login` com sua conta de mentor/admin primeiro.'));
+        process.exitCode = 1;
+        return;
+    }
+    // 1. Vendoriza o bundle admin em ~/.paris/admin-mcp/index.mjs
+    const bundlePath = fileURLToPath(new URL('../../templates/mcp/admin.mjs', import.meta.url));
+    let bundle;
+    try {
+        bundle = await fs.readFile(bundlePath, 'utf-8');
+    }
+    catch {
+        console.log(c.red(`Bundle do MCP admin não encontrado (${bundlePath}). Reinstale a CLI: npm i -g paris-immersion`));
+        process.exitCode = 1;
+        return;
+    }
+    const targetDir = path.join(homedir(), '.paris', 'admin-mcp');
+    await fs.mkdir(targetDir, { recursive: true });
+    const target = path.join(targetDir, 'index.mjs');
+    await fs.writeFile(target, bundle, { mode: 0o755 });
+    console.log(c.green(`✓ MCP paris-admin vendorizado em ${target}`));
+    // 2. Registra no Claude Code (escopo do usuário — funciona de qualquer pasta).
+    const registered = await new Promise((resolve) => {
+        try {
+            execFile('claude', ['mcp', 'add', '--scope', 'user', 'paris-admin', '--', 'node', target], { timeout: 15000, windowsHide: true }, (err) => resolve(!err));
+        }
+        catch {
+            resolve(false);
+        }
+    });
+    if (registered) {
+        console.log(c.green('✓ Registrado no Claude Code (escopo user) como "paris-admin".'));
+        console.log('');
+        console.log('Abra o Claude Code em qualquer pasta e pergunte, por exemplo:');
+        console.log(c.dim('  "Como está a turma?" · "Quem travou hoje?" · "O que o João fez na última hora?"'));
+    }
+    else {
+        console.log(c.yellow('Não consegui registrar automaticamente (o binário `claude` não respondeu).'));
+        console.log('Registre manualmente com:');
+        console.log(c.dim(`  claude mcp add --scope user paris-admin -- node ${target}`));
+    }
+}

package/dist/commands/serve.js

@@ -8,6 +8,7 @@ import { ensureWorkspace } from './install.js';
 import { startRelayAgent } from '../lib/relay-agent.js';
 import { renderTostudyCommand } from '../templates/tostudy-command.js';
 import { renderHookScript } from '../templates/hook.js';
+import { renderSettingsJson } from '../templates/settings.js';
 import { fileURLToPath } from 'node:url';
 import { maybeSelfUpdate } from '../lib/self-update.js';
 import { c } from '../lib/colors.js';
@@ -195,6 +196,24 @@ function ensureWorkspaceVendored(cwd) {
     catch {
         /* best-effort */
     }
+    // CRÍTICO (watcher): é o settings.json que DECLARA os hooks (inclusive o
+    // PostToolUse). Workspaces criados antes da 0.1.24 têm o hook novo no disco
+    // mas um settings velho sem PostToolUse → watcher mudo. Reescrever aqui
+    // (como já fazemos com o hook e o MCP) auto-cura toda a base instalada.
+    try {
+        const raw = readFileSync(path.join(cwd, '.paris', 'workspace.json'), 'utf-8');
+        const marker = JSON.parse(raw);
+        if (marker.api_url) {
+            const claudeDir = path.join(cwd, '.claude');
+            mkdirSync(claudeDir, { recursive: true });
+            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);
+        }
+    }
+    catch {
+        /* best-effort */
+    }
     try {
         const mcpSrc = fileURLToPath(new URL('../../templates/mcp/index.mjs', import.meta.url));
         const mcpDir = path.join(cwd, '.paris', 'mcp');

package/dist/index.js

@@ -11,10 +11,11 @@ import { logoutCommand } from './commands/logout.js';
 import { serveCommand } from './commands/serve.js';
 import { daemonCommand, restartCommand } from './commands/daemon.js';
 import { tostudyLoginCommand } from './commands/tostudy-login.js';
+import { mentorCommand } from './commands/mentor.js';
 const program = new Command()
     .name('paris')
     .description('Paris Immersion — CLI do aluno (login, workspace, tarefas)')
-    .version('0.1.25');
+    .version('0.1.27');
 program
     .command('login')
     .description('Autenticar com sua conta Paris (device-code OR --token direto)')
@@ -71,6 +72,10 @@ program
     .description('Conecta o ToStudy CLI à conta da imersão (rede de segurança quando o curso não abre). Respeita sessão existente.')
     .option('--force', 'Re-loga mesmo se já houver sessão ToStudy')
     .action(tostudyLoginCommand);
+program
+    .command('mentor')
+    .description('Instala o MCP paris-admin no Claude Code do mentor/admin (consulta da turma em linguagem natural).')
+    .action(mentorCommand);
 program.parseAsync().catch((err) => {
     console.error('\n[paris] erro:', err?.message ?? err);
     process.exit(1);

package/dist/templates/claude-md.js

@@ -15,12 +15,13 @@ export function renderClaudeMd(opts) {
 1. **Coach, não tribunal.** Antes de marcar uma tarefa como concluída, você DEVE:
    - Rodar os testes/validações pertinentes ao \`deliverable_type\` da tarefa.
    - Pedir evidência objetiva ao aluno (link, arquivo, número, screenshot).
-   - Checar o \`socio_prompt\` da tarefa pra garantir que o aluno respondeu o que a imersão pediu.
+   - Checar a instrução da tarefa (campo \`socio_prompt\` na API) pra garantir que o aluno respondeu o que a imersão pediu.
    - Apresentar um mini-checklist do que falta ANTES de aceitar um "acabei".
 2. **Respeite a decisão final do aluno.** Se ele disser "acabei" depois do checklist, marque (via MCP \`mark_task_complete\`). Você não é juiz.
 3. **Transparência total.** Tudo aqui é gravado em audit_logs e o instrutor pode reabrir qualquer tarefa.
 4. **Nunca invente progresso.** Só marque o que de fato foi feito nessa sessão.
 5. **Inicie a sessão falando primeiro.** O hook SessionStart te entrega o cronograma + a tarefa atual antes do aluno digitar — abra o dia com um resumo claro (fase, tarefa, primeiro passo sugerido).
+6. **O dossiê do projeto é sagrado.** \`produto/visao.md\` precisa SEMPRE refletir o que é o projeto, a dor, a ideia, como resolve e pra quem (o /visao do Prototipador escreve nesse formato). Toda decisão nova de escopo vai pro arquivo na hora. Ele sincroniza sozinho com a equipe no fim do turno e é pré-requisito pra concluir missões de entregável — sem dossiê, o mark_task_complete recusa.
 
 ## MCP tools que você tem
 

package/dist/templates/hook.d.ts

@@ -1,12 +1,18 @@
 /**
  * The hook script that Claude Code invokes on SessionStart / UserPromptSubmit /
- * Stop. We ship it as a string so `paris install` can write it verbatim into
- * the workspace without needing the @paris/cli package to be installed in the
- * student's node_modules.
+ * Stop / PostToolUse. We ship it as a string so `paris install` can write it
+ * verbatim into the workspace without needing the @paris/cli package to be
+ * installed in the student's node_modules.
  *
  * The script is pure stdlib: walks up to find the marker, reads credentials,
  * calls the API, prints a system-reminder to stdout (which Claude Code feeds
  * back to the model). Failures degrade gracefully — they print to stderr so
  * the student can still get useful debug info, but never block the session.
+ *
+ * Watcher (2026-08): PostToolUse NÃO faz rede — dá append numa fila NDJSON
+ * local (.paris/activity-queue.ndjsonl) e sai em ~1ms. O flush em lote
+ * acontece no Stop/SessionStart (ou quando a fila passa de 25 linhas), via
+ * POST /api/activity/claude-code { events: [...] }. Todo fetch tem timeout
+ * de 4s pra nunca segurar o loop do aluno.
  */
 export declare function renderHookScript(): string;

package/dist/templates/hook.js

@@ -1,25 +1,37 @@
 /**
  * The hook script that Claude Code invokes on SessionStart / UserPromptSubmit /
- * Stop. We ship it as a string so `paris install` can write it verbatim into
- * the workspace without needing the @paris/cli package to be installed in the
- * student's node_modules.
+ * Stop / PostToolUse. We ship it as a string so `paris install` can write it
+ * verbatim into the workspace without needing the @paris/cli package to be
+ * installed in the student's node_modules.
  *
  * The script is pure stdlib: walks up to find the marker, reads credentials,
  * calls the API, prints a system-reminder to stdout (which Claude Code feeds
  * back to the model). Failures degrade gracefully — they print to stderr so
  * the student can still get useful debug info, but never block the session.
+ *
+ * Watcher (2026-08): PostToolUse NÃO faz rede — dá append numa fila NDJSON
+ * local (.paris/activity-queue.ndjsonl) e sai em ~1ms. O flush em lote
+ * acontece no Stop/SessionStart (ou quando a fila passa de 25 linhas), via
+ * POST /api/activity/claude-code { events: [...] }. Todo fetch tem timeout
+ * de 4s pra nunca segurar o loop do aluno.
  */
 export function renderHookScript() {
     return `#!/usr/bin/env node
 // Auto-generated by \`paris install\`. Do not edit — regenerate via \`paris install\`.
 
 import { promises as fs } from 'node:fs'
+import { appendFileSync } from 'node:fs'
 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 FETCH_TIMEOUT_MS = 4000
+const QUEUE_FLUSH_AT = 25    // flush quando a fila acumula isso
+const QUEUE_MAX_LINES = 2000 // cap duro — descarta o mais antigo
+const BATCH_SIZE = 50        // eventos por request de flush
+
 async function loadCredentials() {
   try {
     const file = process.env.PARIS_CREDENTIALS_FILE || path.join(homedir(), '.paris', 'credentials')
@@ -41,26 +53,42 @@ async function loadMarker() {
   }
 }
 
+function timeoutSignal() {
+  try { return AbortSignal.timeout(FETCH_TIMEOUT_MS) } catch { return undefined }
+}
+
 async function apiGet(apiUrl, pathname, token) {
-  const res = await fetch(new URL(pathname, apiUrl), {
-    headers: { authorization: 'Bearer ' + token, accept: 'application/json' },
-  })
-  if (!res.ok) return null
-  return res.json()
+  try {
+    const res = await fetch(new URL(pathname, apiUrl), {
+      headers: { authorization: 'Bearer ' + token, accept: 'application/json' },
+      signal: timeoutSignal(),
+    })
+    if (!res.ok) return null
+    return res.json()
+  } catch { return null }
+}
+
+// Retorna o status HTTP (0 = rede/timeout) — o flush da fila decide reter/descartar.
+async function apiPostStatus(apiUrl, pathname, token, body) {
+  try {
+    const res = await fetch(new URL(pathname, apiUrl), {
+      method: 'POST',
+      headers: { authorization: 'Bearer ' + token, 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: timeoutSignal(),
+    })
+    return res.status
+  } catch { return 0 }
 }
 
 async function apiPost(apiUrl, pathname, token, body) {
-  const res = await fetch(new URL(pathname, apiUrl), {
-    method: 'POST',
-    headers: { authorization: 'Bearer ' + token, 'content-type': 'application/json' },
-    body: JSON.stringify(body),
-  })
-  if (!res.ok) return null
-  return res.json().catch(() => null)
+  const status = await apiPostStatus(apiUrl, pathname, token, body)
+  return status >= 200 && status < 300
 }
 
-// Claude Code passa o payload do hook (session_id, tool_name, tool_input, prompt,
-// cwd, ...) como JSON no stdin. Lê com timeout curto pra NUNCA travar a sessão.
+// Claude Code passa o payload do hook (session_id, tool_name, tool_input,
+// tool_response, prompt, cwd, ...) como JSON no stdin. Lê com timeout curto
+// pra NUNCA travar a sessão.
 function readStdin() {
   return new Promise((resolve) => {
     try {
@@ -87,6 +115,139 @@ function runCmd(cmd, args, cwd) {
   })
 }
 
+// ---------------------------------------------------------------------------
+// Fila local de atividade (watcher). PostToolUse só faz appendFileSync (~1ms).
+// ---------------------------------------------------------------------------
+
+function queuePath(markerDir) {
+  return path.join(markerDir, '.paris', 'activity-queue.ndjsonl')
+}
+
+function truncate(str, max) {
+  if (typeof str !== 'string') return str
+  return str.length > max ? str.slice(0, max) + '…' : str
+}
+
+// Mantém só o que interessa do tool_input/tool_response, com caps de tamanho —
+// o exit code / stderr do Bash é o sinal mais útil pro mentor.
+function slimToolInput(input) {
+  if (!input || typeof input !== 'object') return {}
+  const out = {}
+  if (typeof input.file_path === 'string') out.file_path = truncate(input.file_path, 500)
+  if (typeof input.command === 'string') out.command = truncate(input.command, 1000)
+  if (typeof input.description === 'string') out.description = truncate(input.description, 300)
+  if (Object.keys(out).length === 0) {
+    try { out.raw = truncate(JSON.stringify(input), 2000) } catch {}
+  }
+  return out
+}
+
+function slimToolResponse(resp) {
+  if (!resp || typeof resp !== 'object') return undefined
+  const out = {}
+  for (const k of ['exit_code', 'exitCode', 'interrupted', 'is_error', 'isError']) {
+    if (resp[k] !== undefined) out[k] = resp[k]
+  }
+  if (typeof resp.stderr === 'string' && resp.stderr) out.stderr = truncate(resp.stderr, 1000)
+  if (typeof resp.stdout === 'string' && resp.stdout) out.stdout = truncate(resp.stdout, 500)
+  return Object.keys(out).length > 0 ? out : undefined
+}
+
+function enqueueActivity(markerDir, event) {
+  try {
+    appendFileSync(queuePath(markerDir), JSON.stringify(event) + '\\n')
+  } catch { /* fila é best-effort */ }
+}
+
+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
+  } catch { return [] }
+}
+
+async function writeQueue(markerDir, events) {
+  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')
+    }
+  } 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.
+async function flushActivityQueue(apiUrl, token, markerDir) {
+  const events = await readQueue(markerDir)
+  if (events.length === 0) return
+  let idx = 0
+  while (idx < events.length) {
+    const chunk = events.slice(idx, idx + BATCH_SIZE)
+    const status = await apiPostStatus(apiUrl, '/api/activity/claude-code', token, {
+      session_id: chunk[chunk.length - 1].session_id,
+      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
+    idx += chunk.length
+  }
+  await writeQueue(markerDir, events.slice(idx))
+}
+
+async function refreshMarkerStatus(markerDir, marker, status) {
+  if (!status || marker.status === status) return
+  try {
+    await fs.writeFile(
+      path.join(markerDir, '.paris', 'workspace.json'),
+      JSON.stringify({ ...marker, status }, null, 2),
+    )
+  } catch { /* best-effort */ }
+}
+
+// ---------------------------------------------------------------------------
+// Dossiê do projeto (produto/visao.md + roadmap.md do Prototipador) → Caso do
+// aluno no servidor. DETERMINÍSTICO: roda em todo Stop/SessionStart e envia
+// quando o arquivo mudou — o mentor sempre vê o que é o projeto, a dor e o
+// plano, sem depender do modelo lembrar de anotar.
+// ---------------------------------------------------------------------------
+
+async function syncCaseDossier(apiUrl, token, markerDir) {
+  const statePath = path.join(markerDir, '.paris', 'case-sync.json')
+  let state = {}
+  try { state = JSON.parse(await fs.readFile(statePath, 'utf-8')) } catch {}
+
+  const files = {
+    visao: path.join(markerDir, 'produto', 'visao.md'),
+    roadmap: path.join(markerDir, 'produto', 'roadmap.md'),
+  }
+  const payload = {}
+  const newState = { ...state }
+  for (const [key, fp] of Object.entries(files)) {
+    try {
+      const st = await fs.stat(fp)
+      const mtime = st.mtimeMs
+      if (state[key] !== mtime) {
+        const content = await fs.readFile(fp, 'utf-8')
+        payload[key] = content.slice(0, 16384)
+        newState[key] = mtime
+      }
+    } catch { /* arquivo ainda não existe — normal antes do /visao */ }
+  }
+  if (Object.keys(payload).length === 0) return
+
+  const ok = await apiPost(apiUrl, '/immersion-app/v1/case/sync', token, payload)
+  if (ok) {
+    try { await fs.writeFile(statePath, JSON.stringify(newState)) } catch {}
+  }
+}
+
 // Sincroniza o progresso REAL do curso da ToStudy pro nosso lado. O aluno faz o
 // curso pela tostudy CLI no terminal embutido, e essa conclusão NÃO dispara o
 // webhook do cursos — então é daqui que a gestão aprende o progresso. A ToStudy
@@ -117,26 +278,32 @@ async function main() {
 
   const apiUrl = marker.marker.api_url || creds.api_url
 
-  // Atividade do Claude Code do aluno → endpoint pronto (/api/activity/claude-code)
-  // que alimenta socio_messages, o coaching proativo do Sócio e a visão do mentor.
   const hookInput = (PHASE === 'post-tool-use' || PHASE === 'user-prompt-submit') ? await readStdin() : null
 
   if (PHASE === 'post-tool-use') {
-    // Rápido e silencioso (sem stdout, sem apiGets) — roda após cada Write/Edit/Bash.
+    // ZERO rede no caminho quente — só append local. Flush quando acumula.
     if (hookInput && hookInput.tool_name) {
-      await apiPost(apiUrl, '/api/activity/claude-code', creds.token, {
+      enqueueActivity(marker.dir, {
         hook_event_name: 'PostToolUse',
         tool_name: hookInput.tool_name,
-        tool_input: hookInput.tool_input || {},
+        tool_input: slimToolInput(hookInput.tool_input),
+        tool_response: slimToolResponse(hookInput.tool_response),
         session_id: hookInput.session_id,
         cwd: hookInput.cwd,
+        at: Date.now(),
       })
+      const queued = await readQueue(marker.dir)
+      if (queued.length >= QUEUE_FLUSH_AT) {
+        await flushActivityQueue(apiUrl, creds.token, marker.dir)
+      }
     }
     return
   }
 
   if (PHASE === 'stop') {
     await apiPost(apiUrl, '/immersion-app/v1/events', creds.token, { type: 'turn_ended' })
+    await flushActivityQueue(apiUrl, creds.token, marker.dir)
+    await syncCaseDossier(apiUrl, creds.token, marker.dir)
     // Logo após cada interação é o melhor momento pra capturar uma lição que o
     // aluno acabou de concluir no curso da ToStudy.
     await syncTostudyProgress(apiUrl, creds.token, marker.dir)
@@ -153,6 +320,9 @@ async function main() {
     process.stderr.write('[paris-hook] não foi possível buscar contexto. Está offline?\\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
 
   // Onboarding: enquanto o curso não termina, o terminal roda o tutor do curso
@@ -194,7 +364,7 @@ async function main() {
       if (current.current.description) lines.push('- **descrição:** ' + current.current.description)
       if (current.current.socio_prompt) {
         lines.push('')
-        lines.push('### Sócio prompt')
+        lines.push('### Instrução da tarefa')
         lines.push(current.current.socio_prompt)
       }
     } else {
@@ -203,27 +373,17 @@ async function main() {
     }
   }
 
-  // #3: proativos do Sócio pendentes → injeta no contexto (servidor marca
-  // entregue ao ler). É assim que o coaching proativo chega ao terminal do aluno.
-  const pending = await apiGet(apiUrl, '/immersion-app/v1/socio/pending', creds.token)
-  if (pending && Array.isArray(pending.messages) && pending.messages.length > 0) {
-    lines.push('')
-    lines.push('## Mensagens do Sócio pra você (proativo)')
-    lines.push('Repasse isto ao aluno com naturalidade, no momento certo:')
-    for (const m of pending.messages) {
-      lines.push('- ' + String(m.content || '').split('\\n').join(' '))
-    }
-  }
-
   process.stdout.write(lines.join('\\n') + '\\n')
 
   if (PHASE === 'session-start') {
     await apiPost(apiUrl, '/immersion-app/v1/events', creds.token, { type: 'session_started' })
+    // Restos de fila de sessões anteriores (crash, rede) sobem agora.
+    await flushActivityQueue(apiUrl, creds.token, marker.dir)
+    await syncCaseDossier(apiUrl, creds.token, marker.dir)
   }
 
-  // user-prompt-submit: encaminha o prompt do aluno pro Sócio (gera coaching
-  // proativo server-side, agora não-bloqueante) + dá ao mentor o "o que ele
-  // pediu". Best-effort, depois do contexto já impresso.
+  // user-prompt-submit: dá ao mentor o "o que ele pediu" em tempo real.
+  // Best-effort, depois do contexto já impresso.
   if (PHASE === 'user-prompt-submit') {
     // 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".

package/dist/templates/settings.js

@@ -47,9 +47,9 @@ export function renderSettingsJson(opts) {
                 },
             ],
             // PostToolUse: telemetria da atividade REAL do aluno (arquivos editados +
-            // comandos) → /api/activity/claude-code, pra o mentor enxergar o trabalho
-            // e o Sócio coachar. Matcher de alto sinal (Write|Edit|Bash); Read fica de
-            // fora pra não inundar o feed.
+            // comandos) → /api/activity/claude-code, pra o mentor enxergar o trabalho.
+            // Matcher de alto sinal (Write|Edit|Bash); Read fica de fora pra não
+            // inundar o feed.
             PostToolUse: [
                 {
                     matcher: 'Write|Edit|Bash',

package/dist/templates/skill.js

@@ -15,7 +15,7 @@ Tarefa exige uma resposta escrita (validação, análise, plano, reflexão).
 Checklist:
 1. O aluno produziu pelo menos 1 parágrafo concreto, não 1 frase genérica.
 2. Inclui exemplos ou evidência (números, citação, comparação).
-3. Responde diretamente ao \`socio_prompt\` da tarefa (releia antes de marcar).
+3. Responde diretamente à instrução da tarefa (campo \`socio_prompt\` na API — releia antes de marcar).
 4. Aluno releu antes de você marcar.
 
 Se algo falta: explique o que e ofereça pra ajudar a estruturar.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "paris-immersion",
-  "version": "0.1.25",
-  "description": "Paris Immersion CLI \u2014 login, install workspace, status, task control. Para alunos das imers\u00f5es da Paris Group.",
+  "version": "0.1.27",
+  "description": "Paris Immersion CLI — login, install workspace, status, task control. Para alunos das imersões da Paris Group.",
   "homepage": "https://parisgroup.ai",
   "repository": {
     "type": "git",
@@ -13,7 +13,7 @@
     "paris-group",
     "paris-immersion",
     "cli",
-    "imers\u00e3o"
+    "imersão"
   ],
   "type": "module",
   "bin": {