primocode 8.42.1 → 9.0.0

package/lib/acervo.js

@@ -358,7 +358,14 @@ async function tirarFundo(arquivo, { destino, cor = '0x00FF00', tolerancia = 0.3
     });
     if (!metodo) {
         return { ok: false, error: 'nada nesta máquina sabe recortar fundo',
-            comoResolver: 'instale com: pip install rembg  (ou pipx install rembg)' };
+            // Os dois caminhos, porque servem a casos diferentes: o rembg
+            // recorta qualquer foto (é modelo de segmentação), o ffmpeg só
+            // resolve fundo de cor chapada — mas o ffmpeg já é preciso para
+            // o resto do estúdio, então quem tiver um vídeo rodando aqui
+            // provavelmente já o tem.
+            comoResolver: 'para recortar qualquer imagem: pip install rembg (ou pipx install rembg). '
+                + 'Para fundo de cor chapada basta o ffmpeg, que o estúdio já usa: '
+                + 'brew install ffmpeg / sudo apt install ffmpeg.' };
     }
 
     const rodar = (cmd, args) => new Promise((ok) => {

package/lib/act.js

@@ -18,6 +18,10 @@ const api = require('./api');
 const cfg = require('./config');
 const catalogo = require('./catalogo');
 const repeticao = require('./repeticao');
+const diff = require('./diff');
+const registro = require('./registro');
+const permissao = require('./permissao');
+const skills = require('./skills');
 
 // 40, não 15: com o freio de repetição (repeticao.js) e o de rodada parada,
 // volta a mais não é volta em círculo — é trabalho. Quinze acabavam no meio
@@ -103,6 +107,29 @@ function ident(profundidade) {
     return '  '.repeat(profundidade);
 }
 
+/* O bloco de diff embaixo do resultado.
+ *
+ * O `_antes`/`_depois` vem das tools de arquivo e existe só para isto: são as
+ * duas versões do texto, que o `limparParaOModelo` apaga antes de a conversa
+ * seguir. Sem essa limpeza, cada edição mandaria o arquivo inteiro de volta
+ * ao modelo — que acabou de escrevê-lo e não aprende nada relendo. */
+function mostrarDiff(result, profundidade) {
+    if (!result || typeof result._antes !== 'string' || typeof result._depois !== 'string') return;
+    const bloco = diff.desenhar(result._antes, result._depois, {
+        prefixo: fala.recuo(profundidade),
+    });
+    if (bloco) console.log(bloco);
+}
+
+/* O que NÃO pode ir para a conversa. Chave com `_` é desenho de tela: o
+   arquivo inteiro, duas vezes, por edição. */
+function limparParaOModelo(result) {
+    if (!result || typeof result !== 'object') return result;
+    const limpo = {};
+    for (const [k, v] of Object.entries(result)) if (!k.startsWith('_')) limpo[k] = v;
+    return limpo;
+}
+
 function logResult(kind, result, profundidade) {
     const p = fala.resultado(profundidade);
     if (!result) return;
@@ -118,11 +145,16 @@ function logResult(kind, result, profundidade) {
     switch (kind) {
         case 'write_file':
             console.log(p + c.muted(`${result.created ? 'criado' : 'atualizado'} · ${tools.fmtBytes(result.bytes)}`));
+            // Reescrever arquivo que já existia apaga o que estava lá. O
+            // número de bytes não conta isso; o bloco embaixo conta.
+            mostrarDiff(result, profundidade);
             return;
-        case 'edit_file': {
+        case 'edit_file':
+        case 'multi_edit': {
             const delta = result.linhasDepois - result.linhasAntes;
             const sinal = delta > 0 ? c.ok(`+${delta}`) : delta < 0 ? c.err(`${delta}`) : c.muted('±0');
             console.log(p + c.muted(`${result.substituicoes} troca${result.substituicoes > 1 ? 's' : ''} · `) + sinal + c.muted(' linhas'));
+            mostrarDiff(result, profundidade);
             return;
         }
         case 'read_file':
@@ -188,20 +220,6 @@ function logResult(kind, result, profundidade) {
             }
             return;
         }
-        case 'buscar_audio': {
-            console.log(p + c.muted(`${result.tipo === 'efeito' ? 'efeito' : 'música'}: `) + c.white(`${result.titulo}`)
-                + c.muted(` — ${result.autor || 'autor desconhecido'}${result.duracao ? ` · ${result.duracao}s` : ''} · ${result.licenca}`));
-            console.log(p + c.dim(`${result.url}`));
-            return;
-        }
-        case 'marca_da_empresa': {
-            const cores = (result.cores && result.cores.paleta || []).slice(0, 4).join(' ');
-            console.log(p + c.white(result.nome || '') + c.muted(` · ${result.site || ''}`));
-            console.log(p + c.dim(`cor ${(result.cores && result.cores.principal) || '—'}${cores ? ` · paleta ${cores}` : ''}`
-                + `${(result.fontes || []).length ? ` · fonte ${result.fontes[0]}` : ''}`
-                + `${result.logo ? ` · logo ${result.logo.formato} (${result.logo.fonte})` : ' · sem logo'}`));
-            return;
-        }
         case 'desktop_windows': {
             console.log(p + c.muted(`${result.total} janela${result.total === 1 ? '' : 's'}`));
             for (const j of (result.janelas || []).slice(0, 5)) console.log(p + c.dim(`${j.app ? j.app + ' · ' : ''}${j.titulo}`.slice(0, 120)));
@@ -249,7 +267,10 @@ function logResult(kind, result, profundidade) {
 // O que volta para o modelo. Cortamos saídas gigantes para não estourar a
 // janela de contexto na iteração seguinte.
 function summarizeForModel(result) {
-    const json = JSON.stringify(result);
+    // As chaves com `_` são desenho de tela (as duas versões do arquivo, para
+    // o diff). Se escapassem daqui, cada edição mandaria o arquivo inteiro,
+    // duas vezes, de volta a um modelo que acabou de escrevê-lo.
+    const json = JSON.stringify(limparParaOModelo(result));
     return json.length > 6000 ? json.slice(0, 6000) + '…(truncado)' : json;
 }
 
@@ -369,23 +390,22 @@ async function pausar(ms, subagent) {
  *
  *   1. Há um plano (write_todos) com item por fazer — ele mesmo disse que
  *      não acabou.
- *   2. O texto é INTENÇÃO: começa ou termina anunciando o próximo passo
- *      ("vou", "em seguida", "próximo passo", dois-pontos no fim, reticências).
+ *   2. O texto é INTENÇÃO: anuncia o próximo passo ("vou", "em seguida",
+ *      "próximo passo"), ou termina em dois-pontos e reticências.
  *   3. É curto. Uma resposta de verdade a "explique este erro" tem corpo; um
  *      "vou abrir o arquivo agora" não tem.
  *
  * Pergunta ao usuário NÃO conta como parada: o prompt proíbe perguntar, mas
  * se o modelo perguntou, empurrá-lo faria ele decidir sozinho o que talvez
- * não devesse — e o texto de conversa ("oi, sou o PrimoCode") também não é
- * parada. Só intenção declarada e plano aberto.
+ * não devesse.
  */
-const INTENCAO = /(^|[.!\n]\s*)(agora\s+)?(vou|irei|deixa eu|deixe-me|preciso (agora )?(de )?(criar|ler|abrir|rodar|ver|conferir|pesquisar|mandar|fazer|gerar|escrever|ajustar)|primeiro (vou|eu)|em seguida|pr[óo]ximo passo|a seguir,?\s+(vou|eu)|vamos (criar|ler|abrir|rodar|ver|conferir|come[çc]ar|fazer|gerar|escrever))\b/i;
+const INTENCAO = /(^|[.!\n]\s*)(agora\s+)?(vou|irei|deixa eu|deixe-me|preciso (agora )?(de )?(criar|ler|abrir|rodar|ver|conferir|pesquisar|mandar|fazer|gerar|escrever)|primeiro (vou|eu)|em seguida|pr[óo]ximo passo|a seguir,?\s+(vou|eu)|vamos (criar|ler|abrir|rodar|ver|conferir|come[çc]ar|fazer|gerar|escrever))\b/i;
 function pareceParadaNoMeio(texto, { todosPendentes = 0, rodouTool = false } = {}) {
     const t = String(texto || '').trim();
     if (!t) return false;
     if (todosPendentes > 0) return true;
-    if (t.length > 700) return false;                       // resposta com corpo
-    if (/\?\s*$/.test(t)) return false;                      // perguntou: não é parada
+    if (t.length > 700) return false;                              // resposta com corpo
+    if (/\?\s*$/.test(t)) return false;                            // perguntou: não é parada
     if (INTENCAO.test(t)) return true;
     if (rodouTool && /[:…]\s*$|\.\.\.\s*$/.test(t)) return true;   // "Criando as cenas:" e nada depois
     return false;
@@ -422,6 +442,17 @@ async function runAct(userPrompt, opts) {
     const {
         server, model, token, history, projectDir, projectName,
         ensureWorkDir, profundidade = 0, subagent = false, effort,
+        /* Quem responde ao pedido de controle do computador, e o estado da
+           resposta. Vêm de fora porque quem sabe perguntar é o terminal, e
+           quem sabe lembrar é a SESSÃO — um subagente não pode começar do
+           zero e pedir de novo o que já foi autorizado. */
+        autorizar = null, controle = null,
+        /* O cliente HTTP, injetável. NÃO é mais um comutador de motor — o
+           PrimoCode tem um motor só, o do servidor, e não há provedor para o
+           usuário escolher. Continua um parâmetro porque é por aqui que o
+           teste põe um servidor de mentira no lugar da rede: sem ele,
+           `test/repeticao.js` e `test/continuar.js` teriam de falar com a
+           internet para verificar o loop do agente. */
         motor = api,
     } = opts || {};
 
@@ -436,6 +467,35 @@ async function runAct(userPrompt, opts) {
     let tentativasDeEncerrar = 0;
     // Quem já foi chamado, e quantas vezes. Ver lib/repeticao.js.
     const jaChamado = repeticao.novo();
+    /* O livro deste pedido: arquivos, comandos, links, testes e falhas. Sai
+       no fim como balanço (ver lib/registro.js). O subagente tem o seu, que
+       não se mistura com o do principal — mas o que ele fez também precisa
+       aparecer, então o de cima incorpora o de baixo no retorno. */
+    const livro = registro.novo();
+    /* A autorização do computador vale pela SESSÃO, então o estado vem de
+       fora. Um subagente que criasse o seu perguntaria de novo o que já foi
+       respondido — e uma pergunta repetida é uma pergunta que se responde
+       sem ler. Sem ninguém de fora (teste, pipe), nasce um aqui, que começa
+       fechado. */
+    const portaoControle = controle || permissao.novo();
+
+    /* AS SKILLS entram na frente do pedido, e só as que casam com ele.
+     *
+     * No pedido principal, não no subagente: o subagente já recebe o briefing
+     * do especialista dele, e empilhar os dois gastaria o teto de tokens
+     * duas vezes para dizer coisas parecidas.
+     *
+     * O que decide quais entram é o `quando:` de cada skill — ver
+     * lib/skills.js, que também explica por que mandar todas em todo pedido
+     * não é uma opção num plano limitado por token. */
+    let pedido = userPrompt;
+    if (!subagent) {
+        const comSkills = skills.montar(userPrompt);
+        pedido = comSkills.texto;
+        if (comSkills.skills.length) {
+            fala.pensamento(`seguindo: ${comSkills.skills.map((s) => s.titulo).join(', ')}`, profundidade);
+        }
+    }
     let voltasEmFalso = 0;
     // Pesquisas que voltaram de mãos vazias. A partir da terceira, a tool
     // para de rodar e devolve ORDEM DE SEGUIR: sem isto o agente entrava em
@@ -444,10 +504,10 @@ async function runAct(userPrompt, opts) {
     // assim que "crie um vídeo para a tostudy" morreu sem entregar nada.
     let pesquisasSecas = 0;
     let rodadasParadas = 0;
-    // Para o `pareceParadaNoMeio`: alguma tool já rodou nesta tarefa, e o
-    // último plano que o modelo escreveu (write_todos) — desta tarefa, não da
-    // sessão: um plano velho de um pedido interrompido não pode empurrar o
-    // pedido seguinte.
+    /* Para o `pareceParadaNoMeio`: se alguma tool já rodou nesta tarefa, e o
+       último plano que o modelo escreveu (write_todos) — desta TAREFA, não da
+       sessão: um plano velho, de um pedido interrompido, não pode empurrar o
+       pedido seguinte. */
     let rodouTool = false;
     let todosDaTarefa = [];
     let empurroes = 0;
@@ -460,32 +520,38 @@ async function runAct(userPrompt, opts) {
             if (m && m.role && m.content) messages.push({ role: m.role, content: m.content });
         }
     }
+    /* O que VAI para o modelo é `pedido` (com as skills na frente); o que
+       fica guardado na memória e no histórico é `userPrompt`, o que a pessoa
+       escreveu. Guardar o texto inflado faria a conversa crescer com o mesmo
+       conhecimento repetido em cada turno. */
     /* ── O GATILHO DO DIRETOR ────────────────────────────────────────────
      *
      *   "A IA identifica que precisa criar vídeo, ativa o agente, esse agente
      *    faz a estrutura e manda pra IA, e depois ela só faz o vídeo."
      *
      * Deixar isso só escrito no catálogo não basta: com um pedido curto
-     * ("faz um vídeo do produto") o modelo pula direto para o studio_criar,
-     * porque criar é o que ele sabe fazer. Quem reconhece o pedido é uma
-     * regra (diretor.precisaDeProducao), e ela entra como ORDEM na conversa —
-     * não como conselho no meio de cinquenta ferramentas.
+     * ("faz um vídeo do produto") o modelo pula direto para montar cena,
+     * porque montar cena é o que ele sabe fazer — e o roteiro, escrito no
+     * meio do JSON, vira legenda de slide. Quem reconhece o pedido é uma
+     * regra (diretor.precisaDeProducao), e ela entra como ORDEM na conversa,
+     * não como conselho perdido no meio de quarenta e sete ferramentas.
      *
      * Num subagente não entra: ele já está fazendo uma parte de um plano, e
      * um diretor dentro do diretor é uma volta a mais para o mesmo lugar. */
     if (!subagent && profundidade === 0) {
-        const producao = require('./diretor.js').precisaDeProducao(userPrompt);
+        const producao = require('./diretor.js').precisaDeProducao(pedido);
         if (producao.producao) {
             messages.push({ role: 'system', content:
                 'ESTE PEDIDO É DE PRODUÇÃO AUDIOVISUAL. Antes de criar qualquer peça, chame '
                 + `planejar_producao com o pedido do usuário (formato "${producao.formato}"). `
-                + 'Ele devolve a pauta — roteiro, narração falada, voz, câmera e a mídia a buscar — '
-                + 'e é ela que você produz, cena a cena. Não comece pelo studio_criar: o roteiro '
-                + 'escrito no meio do JSON da cena vira legenda de slide, que é o que se quer evitar.' });
+                + 'Ele devolve a pauta — arco, narração falada, voz, direção de arte e a mídia a buscar — '
+                + 'e é ela que você produz, cena a cena, compondo com as primitivas. Não comece pelo '
+                + 'estudio_plano: o roteiro escrito no meio do JSON da cena vira legenda de slide, '
+                + 'que é exatamente o que se quer evitar.' });
         }
     }
 
-    messages.push({ role: 'user', content: userPrompt });
+    messages.push({ role: 'user', content: pedido });
 
     let finalText = '';
 
@@ -664,10 +730,10 @@ async function runAct(userPrompt, opts) {
                 iteration--;
                 continue;
             }
-            // PAROU NO MEIO? Texto de intenção ("agora vou criar…") ou plano
-            // com item aberto não é entrega. Em vez de encerrar, a tarefa é
-            // devolvida: "isso foi uma promessa — faça". Três empurrões; se
-            // depois disso ele insistir em só falar, a resposta é dele.
+            /* PAROU NO MEIO? Texto de intenção ("agora vou criar…") ou plano
+               com item aberto não é entrega. Em vez de encerrar, a tarefa
+               volta: "isso foi uma promessa — faça". Três empurrões; se
+               depois disso ele insistir em só falar, a resposta é dele. */
             const pendentes = todosDaTarefa.filter((t) => t.status !== 'completed').length;
             if (finalText && empurroes < MAX_EMPURROES && !PARAR
                 && pareceParadaNoMeio(finalText, { todosPendentes: pendentes, rodouTool })) {
@@ -767,37 +833,34 @@ async function runAct(userPrompt, opts) {
                 continue;
             }
 
-            /* O PIPELINE DE QUATRO PAPÉIS mora aqui pelo mesmo motivo que o
-               `spawn_agent`: ele PRECISA rodar agentes, e quem sabe rodar
-               agente é este arquivo. Pôr isto no `tools.execute` obrigaria
-               aquele módulo a conhecer o loop do agente — e um segundo lugar
-               que sabe abrir conversa com o modelo é um segundo lugar para
-               esquecer de passar o token, a pasta ou o motor. */
-            if (tc.name === 'construir_app') {
+            /* O DIRETOR mora aqui pela mesma razão: ele É uma conversa
+               nova, e quem sabe abrir conversa é este arquivo. */
+            if (tc.name === 'planejar_producao') {
                 algoRodou = true;
                 fala.acao(tc.name, tc.arguments, profundidade);
-                const r = await rodarPipeline(tc.arguments || {}, {
+                const r = await rodarDiretor(tc.arguments || {}, {
                     server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
                 });
                 logResult(tc.name, r, profundidade);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
-                if (r && r.ok && catalogo.escreveArquivo(tc.name)) temPasta = true;
                 continue;
             }
 
-            /* O DIRETOR mora aqui pelo mesmo motivo do pipeline: ele roda
-               um AGENTE, e quem sabe rodar agente é este arquivo. É a peça
-               que o dono pediu — "a IA identifica que precisa criar vídeo,
-               ativa o agente, esse agente faz a estrutura e manda pra IA, e
-               depois ela só faz o vídeo". */
-            if (tc.name === 'planejar_producao') {
+            /* O PIPELINE DE QUATRO PAPÉIS mora aqui pelo mesmo motivo que o
+               `spawn_agent`: ele PRECISA rodar agentes, e quem sabe rodar
+               agente é este arquivo. Pôr isto no `tools.execute` obrigaria
+               aquele módulo a conhecer o loop do agente — e um segundo lugar
+               que sabe abrir conversa com o modelo é um segundo lugar para
+               esquecer de passar o token ou a pasta. */
+            if (tc.name === 'construir_app') {
                 algoRodou = true;
                 fala.acao(tc.name, tc.arguments, profundidade);
-                const r = await rodarDiretor(tc.arguments || {}, {
-                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
+                const r = await rodarPipeline(tc.arguments || {}, {
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, livro, autorizar, controle: portaoControle,
                 });
                 logResult(tc.name, r, profundidade);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
+                if (r && r.ok && catalogo.escreveArquivo(tc.name)) temPasta = true;
                 continue;
             }
 
@@ -834,12 +897,30 @@ async function runAct(userPrompt, opts) {
                 continue;
             }
 
+            /* O PORTÃO do controle do computador. Antes da ação, não depois:
+               depois é o ponteiro já tendo andado. Ler a tela não passa por
+               aqui — ver é o que ele precisa fazer para saber onde clicar. */
+            if (permissao.precisa(tc.name)) {
+                const porta = await permissao.pedir(portaoControle, tc.name, tc.arguments, autorizar);
+                if (!porta.ok) {
+                    fala.acao(tc.name, tc.arguments, profundidade);
+                    console.log(fala.resultado(profundidade) + c.warn('não autorizado'));
+                    registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: porta.error });
+                    messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: porta.error }) });
+                    continue;
+                }
+            }
+
             algoRodou = true;
             rodouTool = true;
             fala.acao(tc.name, tc.arguments, profundidade);
             const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual });
             logResult(tc.name, result, profundidade);
             if (tc.name === 'write_todos' && result && Array.isArray(result.todos)) todosDaTarefa = result.todos;
+            // Além de narrar, ANOTA: no fim do pedido sai o balanço do que
+            // nasceu, mudou, rodou e falhou. Narrar sozinho não basta — numa
+            // tarefa de trinta ações, a primeira já saiu da tela.
+            registro.anotar(livro, tc.name, tc.arguments, result);
 
             // Uma escrita bem-sucedida limpa a dívida — mas só a do MESMO
             // arquivo. Escrever algo sem relação (ou um run_shell qualquer)
@@ -950,6 +1031,7 @@ async function runAct(userPrompt, opts) {
     return {
         userMessage: { role: 'user', content: userPrompt },
         assistantMessage: { role: 'assistant', content: finalText },
+        registro: livro,
         // Esc Esc no meio de um plano de vários passos precisa parar o plano
         // INTEIRO, não só o passo — senão o próximo passo começa logo depois
         // de o usuário ter mandado parar.
@@ -978,8 +1060,16 @@ async function runSubagent(args, ctx) {
         profundidade: profundidade + 1,
         subagent: true,
         motor,
+        autorizar: ctx.autorizar,
+        controle: ctx.controle,   // o mesmo objeto: a resposta vale para todos
     });
 
+    /* O que o subagente fez entra no livro de quem o chamou. Sem isto, o
+       balanço no fim mentiria por omissão: o especialista escreveu cinco
+       arquivos e a tela diria "nenhum arquivo". A conversa dele continua
+       separada — o que se junta é o registro do que aconteceu no disco. */
+    if (ctx.livro && r.registro) registro.juntar(ctx.livro, r.registro);
+
     const resumo = r.assistantMessage.content || 'sem resultado';
     fala.agenteVoltou(resumo, profundidade);
     return resumo;
@@ -1000,6 +1090,62 @@ async function runSubagent(args, ctx) {
  * coisa: quem acabou de escrever o código é o pior revisor dele, porque lê o
  * que quis escrever em vez do que escreveu.
  */
+/**
+ * O DIRETOR: estrutura antes de alguém produzir.
+ *
+ * Por que uma conversa PRÓPRIA, e não mais um parágrafo no prompt de quem
+ * produz: o modelo que está montando as cenas já gastou a atenção dele em
+ * JSON — fonte, cor, duração, posição — e é ali que o roteiro morre. Vira
+ * legenda do que aparece na tela ("Vantagens", "Nossos serviços"), sem arco,
+ * sem narração escrita, sem decisão de voz. O diretor não vê JSON de cena
+ * nenhum: ele decide o que se conta, em que ordem, em quantos segundos, com
+ * que voz e com que direção de arte. Depois disso o produtor tem pouco a
+ * inventar — e inventar é onde ele erra.
+ */
+async function rodarDiretor(args, ctx) {
+    const { server, model, token, projectDir, projectName, profundidade, motor } = ctx;
+    if (profundidade > 0) {
+        return { ok: false, error: 'Recusado: o diretor não roda dentro de um subagente. '
+            + 'Produza com o plano que você já recebeu.' };
+    }
+    const diretor = require('./diretor.js');
+    const correr = async (prompt, rotulo) => {
+        if (PARAR) return '';
+        fala.agente('Diretor', rotulo, profundidade);
+        const r = await runAct(prompt, {
+            server, model, token, projectDir, projectName,
+            history: [], profundidade: profundidade + 1, subagent: true, motor,
+        });
+        return (r && r.assistantMessage && r.assistantMessage.content) || '';
+    };
+
+    const r = await diretor.planejar({
+        pedido: args.pedido || args.prompt || '',
+        segundos: Number(args.segundos) || 30,
+        formato: args.formato === 'apresentacao' ? 'apresentacao' : 'video',
+        contexto: args.contexto || '',
+        correr,
+        mostrar: (t) => fala.agente('Diretor', t, profundidade),
+    });
+    if (!r.ok) return r;
+
+    /* A PAUTA é o que volta para o produtor, não o JSON cru. O JSON cru
+       convida a copiar campo por campo para dentro do plano de cena — e aí o
+       "fundo": "verde descendo" viraria uma string num lugar que espera cor.
+       A pauta é prosa: o produtor LÊ e compõe com os primitivos que ele tem. */
+    return {
+        ok: true,
+        aprovado: r.aprovado,
+        defeitos: r.defeitos.length ? r.defeitos : undefined,
+        pauta: diretor.pauta(r.plano),
+        voz: r.plano.voz,
+        midia: r.plano.midia,
+        trilha: r.plano.trilha,
+        segundos: r.plano.segundos,
+        proporcao: r.plano.proporcao,
+    };
+}
+
 async function rodarPipeline(args, ctx) {
     const { server, model, token, projectDir, projectName, profundidade, motor } = ctx;
     if (profundidade > 0) {
@@ -1035,60 +1181,5 @@ async function rodarPipeline(args, ctx) {
     });
 }
 
-/* ══ O DIRETOR ═════════════════════════════════════════════════════════════
- *
- *   "Tenha uma IA específica pra roteiro que monta tudo — narração, qual voz,
- *    roteiro. Ela estrutura tudo antes de mandar pra IA."
- *
- * As regras, o prompt e a conferência do plano moram em `diretor.js`. Aqui é
- * a costura: uma conversa NOVA para o diretor (ele não vê a do usuário nem a
- * do produtor — é isso que faz o roteiro parar de virar legenda do slide) e a
- * pauta de volta, que é o que o produtor recebe no lugar do pedido cru.
- */
-async function rodarDiretor(args, ctx) {
-    const { server, model, token, projectDir, projectName, profundidade, motor } = ctx;
-    const diretor = require('./diretor.js');
-
-    const correr = async (prompt, rotulo) => {
-        if (PARAR) return '';
-        fala.agente('Diretor', rotulo, profundidade);
-        const r = await runAct(prompt, {
-            server, model, token, projectDir, projectName,
-            history: [], profundidade: profundidade + 1, subagent: true, motor,
-        });
-        return (r && r.assistantMessage && r.assistantMessage.content) || '';
-    };
-
-    const r = await diretor.planejar({
-        pedido: args.pedido || args.prompt || '',
-        segundos: Number(args.segundos) || 30,
-        formato: args.formato === 'apresentacao' ? 'apresentacao' : 'video',
-        contexto: args.contexto || '',
-        correr,
-        mostrar: (linha) => console.log(fala.resultado(profundidade) + c.muted(linha)),
-    });
-    if (!r.ok) return r;
-
-    return {
-        ok: true,
-        motor: r.plano.motor,
-        voz: r.plano.voz,
-        midia: r.plano.midia,
-        trilha: r.plano.trilha,
-        pauta: diretor.pauta(r.plano),
-        plano: r.plano,
-        ressalvas: r.defeitos,
-        aviso: 'A ESTRUTURA ESTÁ PRONTA. Agora só PRODUZA: busque a mídia listada com '
-            + 'midia_procurar + midia_baixar (use o "src" que volta em fundo.imagem e em src); '
-            + 'a TRILHA vem do buscar_audio (já baixa e credita) e a identidade de uma empresa, do marca_da_empresa. '
-            + `e monte com studio_criar (${r.plano.formato === 'apresentacao' ? 'prisma' : 'corte'}) `
-            + 'seguindo a pauta cena a cena. Não invente cena, não troque a ordem, não reescreva a narração. '
-            + (r.plano.motor.motor === 'remotion'
-                ? 'Depois de criar, gere o projeto Remotion com remotion_projeto: '
-                    + r.plano.motor.motivo + '.'
-                : 'O motor é o estúdio: ' + r.plano.motor.motivo + '.'),
-    };
-}
-
-module.exports = { runAct, interromper, compactar, motivoDaParada, ehTetoDeToken, ehTransitorio, esperaDoErro,
-    anotacaoDoQueJaFoi, encolherParaContinuar, pareceParadaNoMeio, MAX_ITERATIONS, MAX_EMPURROES };
+module.exports = { runAct, interromper, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
+    anotacaoDoQueJaFoi, encolherParaContinuar, MAX_ITERATIONS };

package/lib/api.js

@@ -220,6 +220,14 @@ function requestResumo(serverUrl, payload) {
     return request(serverUrl, '/api/resumir', body, token);
 }
 
+/* A transcrição do áudio, com o tempo de cada trecho — é dela que sai a
+   legenda sincronizada. Quem tem a chave do provedor é o servidor, não o
+   CLI: essa é a promessa do produto. */
+function requestTranscricao(serverUrl, payload) {
+    const { token, ...body } = payload;
+    return request(serverUrl, '/api/transcrever', body, token);
+}
+
 // Refino do pedido: manda o texto cru, recebe a ordem de serviço.
 function requestRefino(serverUrl, payload) {
     const { token, ...body } = payload;
@@ -232,20 +240,43 @@ function requestPlano(serverUrl, payload) {
     return request(serverUrl, '/api/plano', body, token);
 }
 
+/* Os conectores do servidor. Rota própria em vez de espremer do /health: o
+   /health carrega a corrente inteira dos três apelidos, e quem quer só saber
+   quem está de pé não precisa baixar isso. */
+function getConectores(serverUrl, token) {
+    return pedirGet(serverUrl, '/api/conectores', token);
+}
+
 function getHealth(serverUrl, token) {
+    return pedirGet(serverUrl, '/health', token);
+}
+
+function pedirGet(serverUrl, rota, token) {
     return new Promise((resolve, reject) => {
-        const url = new URL('/health', serverUrl);
+        const url = new URL(rota, serverUrl);
         const client = url.protocol === 'https:' ? https : http;
         const req = client.get(buildOptions(url, 'GET', {}, null, token), (res) => {
             let body = '';
             res.on('data', (chunk) => { body += chunk; });
             res.on('end', () => {
                 try { resolve(JSON.parse(body)); }
-                catch { reject(new Error(`Resposta inválida do health check (HTTP ${res.statusCode})`)); }
+                catch { reject(new Error(`Resposta inválida de ${rota} (HTTP ${res.statusCode})`)); }
             });
         });
-        req.on('error', reject);
+        /* Sem prazo, um servidor mudo pendura o comando para sempre — e
+           pendura calado, que é o pior jeito de travar.
+
+           Relógio de PAREDE, nunca `req.setTimeout`: aquele mede silêncio do
+           socket, e o silêncio de 40 segundos da máquina subindo no Render é
+           justamente o que não pode ser cortado. Aqui a conta é a resposta
+           inteira, que é o que de fato tem de acabar. */
+        const relogio = setTimeout(() => {
+            req.destroy(erroDeTempo('respondeu', PRAZO_RESPOSTA));
+        }, PRAZO_RESPOSTA);
+        if (relogio.unref) relogio.unref();
+        req.on('close', () => clearTimeout(relogio));
+        req.on('error', (e) => { clearTimeout(relogio); reject(e); });
     });
 }
 
-module.exports = { request, requestStream, requestAct, requestChat, requestResumo, requestRefino, requestPlano, getHealth };
+module.exports = { request, requestStream, requestAct, requestChat, requestResumo, requestRefino, requestPlano, requestTranscricao, getHealth, getConectores };