paris-immersion 0.1.34 → 0.1.36

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';
@@ -27,6 +27,7 @@ export async function installCommand(opts) {
     const boot = await bootstrapWorkspace(opts.immersion);
     const targetDir = path.resolve(opts.dir ?? `paris-${boot.immersion.slug}`);
     await writeWorkspaceFiles(targetDir, boot, creds.api_url, creds.email);
+    await ensurePrototipador(targetDir);
     console.log();
     console.log(c.green(`✓ Workspace pronto em ${targetDir}`));
     console.log();
@@ -55,8 +56,40 @@ export async function ensureWorkspace(opts = {}) {
     // Predictable, findable location regardless of where `paris serve` was run.
     const targetDir = path.join(homedir(), `paris-${boot.immersion.slug}`);
     await writeWorkspaceFiles(targetDir, boot, creds.api_url, creds.email);
+    await ensurePrototipador(targetDir);
     return { dir: targetDir, created: true };
 }
+/**
+ * Prototipador (fork literal do buildermethods/design-os, 2026-08-17): é um
+ * TEMPLATE que o aluno trabalha dentro — clona pra `<ws>/prototipador`.
+ * Preferência: copiar do clone que o instalador deixou em ~/prototipador
+ * (offline-friendly); fallback: clone direto. Best-effort — sem git/rede, a
+ * missão 4 instrui o clone manual.
+ */
+async function ensurePrototipador(targetDir) {
+    const dest = path.join(targetDir, 'prototipador');
+    try {
+        await fs.stat(dest);
+        return; // já existe
+    }
+    catch { /* segue */ }
+    const { execFile } = await import('node:child_process');
+    const { promisify } = await import('node:util');
+    const execFileP = promisify(execFile);
+    const homeClone = path.join(homedir(), 'prototipador');
+    try {
+        await fs.stat(path.join(homeClone, '.git'));
+        await execFileP('git', ['clone', homeClone, dest], { timeout: 30_000 });
+        // Aponta o origin pro remoto real (o clone local viraria origin=~/prototipador).
+        await execFileP('git', ['-C', dest, 'remote', 'set-url', 'origin', 'https://github.com/parisgroup-ai/prototipador.git'], { timeout: 10_000 }).catch(() => { });
+        return;
+    }
+    catch { /* sem clone local — tenta a rede */ }
+    try {
+        await execFileP('git', ['clone', 'https://github.com/parisgroup-ai/prototipador', dest], { timeout: 60_000 });
+    }
+    catch { /* best-effort */ }
+}
 async function bootstrapWorkspace(immersion) {
     const slugQuery = immersion ? `?immersion=${encodeURIComponent(immersion)}` : '';
     return apiAuthFetch(`/immersion-app/v1/workspace/bootstrap${slugQuery}`, {
@@ -86,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/repair.d.ts

@@ -0,0 +1,3 @@
+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.
+ */
+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,7 @@ 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 { doctorCommand } from './commands/doctor.js';
 import { tasksCommand } from './commands/tasks.js';
 import { statusCommand } from './commands/status.js';
@@ -32,6 +33,11 @@ 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('doctor')
     .description('Diagnostica credentials, marker, hooks, conectividade')

package/dist/templates/claude-md.js

@@ -21,7 +21,8 @@ export function renderClaudeMd(opts) {
 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.
+6. **O dossiê do projeto é sagrado.** O \`product/product-overview.md\` do Prototipador (gerado pelo /visao dentro da pasta \`prototipador/\` deste workspace — fork do design-os) precisa SEMPRE refletir o que é o projeto, a dor, a ideia, como resolve e pra quem. 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.
+7. **O Prototipador é a pasta \`prototipador/\` deste workspace.** No dia 2, trabalhe DENTRO dela: /visao → /roadmap → /dados → /estilo → /estrutura → /secao → /dados-exemplo → /tela, e /exportar pra fechar. Se a pasta não existir: \`git clone https://github.com/parisgroup-ai/prototipador\`.
 
 ## MCP tools que você tem
 

package/dist/templates/hook.js

@@ -212,7 +212,7 @@ async function refreshMarkerStatus(markerDir, marker, status) {
 }
 
 // ---------------------------------------------------------------------------
-// Dossiê do projeto (produto/visao.md + roadmap.md do Prototipador) → Caso do
+// Dossiê do projeto (product/product-overview.md + product-roadmap.md) → 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.
@@ -223,22 +223,37 @@ async function syncCaseDossier(apiUrl, token, markerDir) {
   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'),
+  // Prototipador virou fork literal do design-os (2026-08-17): a saída canônica
+  // é product/product-overview.md + product/product-roadmap.md — na raiz do
+  // workspace OU dentro do clone do template (<ws>/prototipador). Os caminhos
+  // legados (produto/visao.md) seguem como fallback pra quem começou antes.
+  const candidates = {
+    visao: [
+      path.join(markerDir, 'product', 'product-overview.md'),
+      path.join(markerDir, 'prototipador', 'product', 'product-overview.md'),
+      path.join(markerDir, 'produto', 'visao.md'),
+    ],
+    roadmap: [
+      path.join(markerDir, 'product', 'product-roadmap.md'),
+      path.join(markerDir, 'prototipador', 'product', 'product-roadmap.md'),
+      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 */ }
+  for (const [key, paths] of Object.entries(candidates)) {
+    for (const fp of paths) {
+      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
+        }
+        break // primeiro caminho existente vence
+      } catch { /* tenta o próximo candidato */ }
+    }
   }
   if (Object.keys(payload).length === 0) return
 

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.34",
+  "version": "0.1.36",
   "description": "Paris Immersion CLI — login, install workspace, status, task control. Para alunos das imersões da Paris Group.",
   "homepage": "https://parisgroup.ai",
   "repository": {