@orkastery/cli 0.5.6 → 0.6.0

package/dist/noctum-terminal.js

@@ -0,0 +1,459 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TERMINAL_LIGADO = exports.CONTRATO_DO_TERMINAL = void 0;
+exports.ancestraisPeloProc = ancestraisPeloProc;
+exports.fimDaTranscricao = fimDaTranscricao;
+exports.codigosMostradosPorUltimo = codigosMostradosPorUltimo;
+exports.origemDoDono = origemDoDono;
+exports.lerEntradaDoHook = lerEntradaDoHook;
+exports.responderPeloTerminal = responderPeloTerminal;
+/**
+ * RM-057 (resposta curta, D5 e D6 da ork-rm057respost): o ingresso do terminal do Claude Code.
+ *
+ * DESLIGADO (GO-FIX 2, R2 e R3 do CHECK, decisão D22): o núcleo não grava nada pelo terminal. Quando o dono digita uma
+ * resposta curta a uma pergunta que espera por ele, o hook leva o evento ao núcleo, e o núcleo só devolve o aviso de
+ * responder pelo Telegram (em reply à mensagem da pergunta, ou com o código) ou pela janela de confirmação do Claude Code
+ * (o diálogo nativo). Por quê: o Claude Code instalado (2.1.306) não manda a origem humana do evento (`source`), então
+ * nada do dono gravaria; e o agente da própria sessão do dono forja o evento e passa a cadeia de processos, com `exec` e
+ * sem a marca `AI_AGENT` (S15 do CHECK). Hoje o ingresso não serviria ao dono e serviria a quem forja.
+ *
+ * O que falta para religar, numa fatia própria: o Claude Code mandar o `source` do evento, e uma prova de que o evento
+ * veio do hook do harness e não de um processo do mesmo usuário (a cadeia e o guard são lombadas, não prova); a pergunta
+ * mostrada exigida como a linha que o núcleo monta para ela, ou só o código (R3). Até lá, o código abaixo fica atrás da
+ * chave `TERMINAL_LIGADO`, desligada; só os testes a ligam, por `AmbienteDoTerminal.ligado`, e o CLI e o hook nunca.
+ *
+ * Com a chave ligada, o dono decidiu que aprova onde estiver. No terminal do Claude Code, o hook `UserPromptSubmit` do
+ * plugin do `ork` leva ao núcleo o que ele digitou numa sessão interativa; quando o texto é uma resposta curta a uma
+ * pergunta do arco #Noctum, o núcleo confere a ORIGEM do prompt e da sessão, nunca o texto, e grava o ato com o recibo.
+ *
+ * A origem (D5; GO-FIX 1, achados 1 e 5), conferida nesta ordem, cada passo com o motivo tipado de quando falha:
+ *  - prompt digitado: o evento diz quem escreveu o prompt (`source`), e só `user`, o compositor interativo, vale. A tarefa
+ *    agendada, a volta do `/loop`, a mensagem de canal ou de outra sessão, o SDK e o evento de sondagem são recusados, e o
+ *    evento sem o campo também: sem como provar que o dono digitou, nada é gravado;
+ *  - presença: o Claude Code marca os filhos de uma sessão com `CLAUDE_CODE_SESSION_ATTENDED=1` só quando há alguém
+ *    nela; em segundo plano, em `daemon` e na execução por `-p` aninhada, vale `0`;
+ *  - id: o `CLAUDE_CODE_SESSION_ID` do ambiente é o `session_id` do evento;
+ *  - sem despacho: nem a identidade de despacho do `ork` (`ORK_DISPATCH_ID`, `ORK_DISPATCH_THREAD`) nem a pasta de job
+ *    de segundo plano (`CLAUDE_JOB_DIR`) no ambiente;
+ *  - ponto de entrada: não é o do SDK (`sdk-*`);
+ *  - registro: o id não é de sessão que o `ork` despachou ou adotou em thread nenhuma deste projeto;
+ *  - worktree: o `cwd` não está em worktree de thread;
+ *  - ancestralidade (Linux, pelo `/proc`): a sessão do Claude Code (`CLAUDE_PID`) é ancestral deste processo, e TODO
+ *    processo entre este e ela nasceu com o ambiente que o Claude Code dá ao hook dela: o mesmo id de sessão, o mesmo
+ *    `CLAUDE_PID`, a presença e nenhuma marca `AI_AGENT`, que o Claude Code põe no shell das ferramentas do agente e não
+ *    no hook. O ambiente de quando cada ancestral nasceu não se reescreve de baixo. O ambiente da sessão não é de segundo
+ *    plano (`CLAUDE_CODE_SESSION_KIND`) e nenhuma outra sessão do Claude Code está acima dela. Sem `/proc`, nada é gravado.
+ *
+ * O limite que sobra, dito como o do diálogo nativo (A21 e NP14): a fronteira é a conta do sistema. Um processo do mesmo
+ * usuário que abra uma sessão interativa nova do Claude Code fora da árvore de processos do agente (com `setsid` e um
+ * terminal virtual, por exemplo) e digite nela passa, porque o núcleo e os agentes dividem a conta; o agente pela
+ * ferramenta Bash da própria sessão também passa, se trocar o shell pelo núcleo com `exec`, tirar a marca `AI_AGENT` e
+ * forjar o evento com `source` igual a `user` (S15 do CHECK; o guard do plugin não vê o subcomando entre aspas). Separar
+ * de verdade é rodar os agentes em outra conta ou sandbox.
+ *
+ * A pergunta (D6; GO-FIX 1, achado 3): o código digitado ("K7QX a") vale sempre que a origem prova o dono. A palavra
+ * solta, a letra e o número com a letra só valem logo depois da pergunta mostrada: a última linha da última mensagem do
+ * assistente, que é a última coisa da transcrição, traz o código dela (saída de ferramenta não conta). Só a alternativa
+ * "a" age por esse caminho: "b", "c", "não" e o resto seguem ao modelo, sem efeito, e nunca são engolidos. A pergunta já
+ * respondida, a que já ouviu "b" ou "c" e a que mudou (a proposta trocada) não aceitam a palavra solta: a primeira e a
+ * segunda deixam o prompt seguir ao modelo, e a terceira volta dizendo a pergunta de agora. A resposta a um gate não é
+ * gravada aqui (D1): ela vai ao condutor como contexto, para ele abrir o diálogo nativo, só com a origem provada.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const estado_thread_1 = require("./estado-thread");
+const hitl_texto_livre_1 = require("./hitl-texto-livre");
+const manifest_1 = require("./manifest");
+const noctum_resposta_1 = require("./noctum-resposta");
+const pulse_resposta_1 = require("./pulse-resposta");
+const thread_1 = require("./thread");
+exports.CONTRATO_DO_TERMINAL = 'ork.noctum-terminal/v1';
+/**
+ * GO-FIX 2 (R2 e R3 do CHECK, D22): a chave do ingresso do terminal, DESLIGADA. Desligada, a resposta curta a uma pergunta
+ * que espera o dono volta como recusa (`noctum.terminal.desligado`) com o aviso de por onde responder, antes de conferir a
+ * origem, e nada é gravado. Só um teste (ou a fatia que religar, com o que falta dito no topo deste arquivo) a liga.
+ */
+exports.TERMINAL_LIGADO = false;
+const TETO_DO_PROMPT = 300;
+const TETO_DA_TRANSCRICAO = 512 * 1024;
+const ID_DE_SESSAO = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/;
+const KINDS_DE_FUNDO = ['bg', 'daemon', 'daemon-worker'];
+/** O código curto como palavra inteira, em maiúsculas: hash e identificador em minúsculas nunca casam. */
+const CODIGO_NA_LINHA = /(?<![A-Za-z0-9])(?=[A-HJKMNP-TV-Z][2-9A-HJKMNP-TV-Z]{0,2}[2-9])[A-HJKMNP-TV-Z][2-9A-HJKMNP-TV-Z]{3}(?![A-Za-z0-9])/g;
+const sha = (s) => (0, node_crypto_1.createHash)('sha256').update(s).digest('hex');
+const decisao = (d) => ({ contrato: exports.CONTRATO_DO_TERMINAL, ...d });
+/** A cadeia de processos pelo `/proc`, do atual até o topo (Linux). Fora do Linux, `null`. */
+function ancestraisPeloProc() {
+    if (!fs.existsSync('/proc/self/stat'))
+        return null;
+    const cadeia = [];
+    let pid = process.pid;
+    for (let i = 0; i < 64 && pid > 0; i++) {
+        let stat;
+        try {
+            stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+        }
+        catch {
+            break;
+        }
+        const ppid = Number(stat.slice(stat.lastIndexOf(')') + 2).split(' ')[1]);
+        let ambiente = null;
+        try {
+            ambiente = Object.fromEntries(fs.readFileSync(`/proc/${pid}/environ`).toString('utf8').split('\0').filter(Boolean)
+                .map(l => { const k = l.indexOf('='); return [l.slice(0, k), l.slice(k + 1)]; }));
+        }
+        catch {
+            ambiente = null;
+        }
+        cadeia.push({ pid, ppid, ambiente });
+        if (!Number.isInteger(ppid) || ppid <= 1)
+            break;
+        pid = ppid;
+    }
+    return cadeia;
+}
+/** O fim da transcrição da sessão: um `.jsonl` comum do próprio usuário, lido só nos últimos 512 KB. */
+function fimDaTranscricao(arquivo) {
+    try {
+        if (!path.isAbsolute(arquivo) || !arquivo.endsWith('.jsonl'))
+            return null;
+        const fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        try {
+            const st = fs.fstatSync(fd);
+            if (!st.isFile() || st.uid !== process.getuid?.())
+                return null;
+            const tamanho = Math.min(st.size, TETO_DA_TRANSCRICAO), buf = Buffer.alloc(tamanho);
+            fs.readSync(fd, buf, 0, tamanho, st.size - tamanho);
+            return buf.toString('utf8');
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * GO-FIX 1 (achado 3): os códigos que o dono viu por último. A última entrada da conversa principal na transcrição (sem a
+ * de subagente e sem os registros que não são mensagem) tem de ser uma mensagem do assistente com texto, e os códigos são
+ * os da última linha desse texto (cerca de código não conta como linha). Se a última entrada é o resultado de uma
+ * ferramenta, um prompt (do dono ou injetado) ou uma mensagem sem texto, nada foi mostrado por último: a lista vem vazia.
+ */
+function codigosMostradosPorUltimo(fim) {
+    if (fim === null)
+        return [];
+    const linhas = fim.split('\n');
+    for (let i = linhas.length - 1; i >= 0; i--) {
+        let e;
+        try {
+            e = JSON.parse(linhas[i]);
+        }
+        catch {
+            continue;
+        }
+        if (!e || typeof e !== 'object' || Array.isArray(e))
+            continue;
+        const entrada = e;
+        if ((entrada.type !== 'assistant' && entrada.type !== 'user') || entrada.isSidechain === true)
+            continue;
+        if (entrada.type === 'user')
+            return [];
+        const blocos = Array.isArray(entrada.message?.content) ? entrada.message.content : [];
+        const texto = blocos.filter((b) => !!b && typeof b === 'object' &&
+            b.type === 'text' && typeof b.text === 'string').map(b => b.text).join('\n');
+        const ultima = texto.split('\n').map(l => l.trim()).filter(l => l && !/^(```|~~~)/.test(l)).at(-1) ?? '';
+        return [...new Set(ultima.match(CODIGO_NA_LINHA) ?? [])];
+    }
+    return [];
+}
+/** As sessões que o `ork` despachou ou adotou em alguma thread deste projeto, e as worktrees das threads. */
+function registroDoOrk(raiz) {
+    const sessoes = new Set(), worktrees = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        try {
+            const t = (0, thread_1.lerThread)(raiz, id);
+            for (const s of t.sessoes ?? [])
+                if (typeof s.sessionId === 'string')
+                    sessoes.add(s.sessionId);
+            if (typeof t.worktree === 'string' && t.worktree)
+                worktrees.push(t.worktree);
+        }
+        catch { /* thread ilegível não tira nem põe ninguém no registro */ }
+    }
+    return { sessoes, worktrees };
+}
+const real = (p) => { try {
+    return fs.realpathSync(p);
+}
+catch {
+    return path.resolve(p);
+} };
+const dentro = (pai, filho) => {
+    const rel = path.relative(real(pai), real(filho));
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+};
+const MOTIVOS = Object.freeze({
+    'noctum.terminal.desligado': 'o ingresso do terminal está desligado até o Claude Code mandar a origem humana do evento',
+    'noctum.terminal.origem-do-prompt-desconhecida': 'o evento do Claude Code não diz que foi você quem digitou (sem o campo source, o terminal não grava)',
+    'noctum.terminal.prompt-injetado': 'o prompt não foi digitado por você (veio de tarefa agendada, /loop, canal, outra sessão ou programa)',
+    'noctum.terminal.sem-presenca': 'a sessão não tem alguém presente (segundo plano ou execução por programa)',
+    'noctum.terminal.sessao-divergente': 'o id da sessão do evento não é o do ambiente',
+    'noctum.terminal.sessao-despachada': 'a sessão foi despachada pelo ork ou roda como job de segundo plano',
+    'noctum.terminal.sessao-programatica': 'a sessão é do SDK, não do terminal',
+    'noctum.terminal.sessao-do-ork': 'a sessão foi despachada ou adotada pelo ork numa thread',
+    'noctum.terminal.worktree-de-thread': 'a sessão roda numa worktree de thread',
+    'noctum.terminal.sem-cadeia': 'a cadeia de processos não se lê nesta plataforma',
+    'noctum.terminal.ancestral-divergente': 'a sessão do Claude Code não é ancestral deste processo',
+    'noctum.terminal.ancestral-ilegivel': 'o ambiente de um processo da cadeia não se lê',
+    'noctum.terminal.cadeia-fora-do-hook': 'um processo entre este e a sessão não nasceu do hook dela',
+    'noctum.terminal.cadeia-do-agente': 'a chamada saiu de uma ferramenta do agente, não do hook',
+    'noctum.terminal.sessao-em-segundo-plano': 'a sessão do Claude Code roda em segundo plano',
+    'noctum.terminal.sessao-aninhada': 'a sessão está aninhada em outra sessão do Claude Code',
+});
+/**
+ * D5: a origem do prompt e da sessão, nesta ordem. Devolve as conferências que passaram, para o recibo, ou o primeiro
+ * motivo que falhou. Nada aqui lê o texto do dono.
+ */
+function origemDoDono(raiz, entrada, amb) {
+    const env = amb.env, conferencias = [];
+    const falha = (motivo) => ({ ok: false, motivo });
+    // GO-FIX 1 (achado 1): o prompt que a máquina injeta na sessão do dono não é o dono, e sem o campo não há como provar.
+    if (entrada.source === undefined)
+        return falha('noctum.terminal.origem-do-prompt-desconhecida');
+    if (entrada.source !== 'user')
+        return falha('noctum.terminal.prompt-injetado');
+    conferencias.push('prompt-digitado');
+    if (env.CLAUDE_CODE_SESSION_ATTENDED !== '1')
+        return falha('noctum.terminal.sem-presenca');
+    conferencias.push('presenca');
+    if (env.CLAUDE_CODE_SESSION_ID !== entrada.session_id)
+        return falha('noctum.terminal.sessao-divergente');
+    conferencias.push('id-da-sessao');
+    if (env.ORK_DISPATCH_ID || env.ORK_DISPATCH_THREAD || env.CLAUDE_JOB_DIR)
+        return falha('noctum.terminal.sessao-despachada');
+    conferencias.push('sem-despacho');
+    if (/^sdk/i.test(env.CLAUDE_CODE_ENTRYPOINT ?? ''))
+        return falha('noctum.terminal.sessao-programatica');
+    conferencias.push('ponto-de-entrada');
+    const registro = registroDoOrk(raiz);
+    if (registro.sessoes.has(entrada.session_id))
+        return falha('noctum.terminal.sessao-do-ork');
+    conferencias.push('fora-do-registro');
+    let dirDasWorktrees = '.claude/worktrees';
+    try {
+        dirDasWorktrees = (0, manifest_1.exigirManifesto)((0, estado_thread_1.raizDoEstado)(raiz)).manifesto.worktree.dir || dirDasWorktrees;
+    }
+    catch { /* o padrão do manifesto */ }
+    const raizes = [...registro.worktrees, path.join((0, estado_thread_1.raizDoEstado)(raiz), dirDasWorktrees)];
+    if (raizes.some(w => dentro(w, entrada.cwd)))
+        return falha('noctum.terminal.worktree-de-thread');
+    conferencias.push('fora-de-worktree');
+    // GO-FIX 1 (achado 5): `CLAUDE_PID` não vale de qualquer ancestral. Cada processo entre este e a sessão tem de ter nascido
+    // do hook dela, e o agente não reescreve o ambiente de um ancestral que já está de pé.
+    const cadeia = (amb.ancestrais ?? ancestraisPeloProc)();
+    if (cadeia === null)
+        return falha('noctum.terminal.sem-cadeia');
+    const claudePid = Number(env.CLAUDE_PID);
+    const i = Number.isInteger(claudePid) && claudePid > 1 ? cadeia.findIndex(a => a.pid === claudePid) : -1;
+    if (i < 1)
+        return falha('noctum.terminal.ancestral-divergente');
+    for (const a of cadeia.slice(0, i)) {
+        if (!a.ambiente)
+            return falha('noctum.terminal.ancestral-ilegivel');
+        if (a.ambiente.CLAUDE_CODE_SESSION_ID !== entrada.session_id || a.ambiente.CLAUDE_PID !== String(claudePid) ||
+            a.ambiente.CLAUDE_CODE_SESSION_ATTENDED !== '1')
+            return falha('noctum.terminal.cadeia-fora-do-hook');
+        if (Object.prototype.hasOwnProperty.call(a.ambiente, 'AI_AGENT'))
+            return falha('noctum.terminal.cadeia-do-agente');
+    }
+    const sessao = cadeia[i];
+    if (!sessao.ambiente)
+        return falha('noctum.terminal.ancestral-ilegivel');
+    if (KINDS_DE_FUNDO.includes(sessao.ambiente.CLAUDE_CODE_SESSION_KIND ?? ''))
+        return falha('noctum.terminal.sessao-em-segundo-plano');
+    if (cadeia.slice(i + 1).some(a => a.ambiente?.CLAUDECODE === '1'))
+        return falha('noctum.terminal.sessao-aninhada');
+    conferencias.push('ancestralidade');
+    const entrypoint = typeof env.CLAUDE_CODE_ENTRYPOINT === 'string' && env.CLAUDE_CODE_ENTRYPOINT ? env.CLAUDE_CODE_ENTRYPOINT.slice(0, 64) : null;
+    return { ok: true, atestado: { host: 'claude-code', sessao: entrada.session_id, entrypoint, conferencias } };
+}
+/** A entrada do hook, ou `null` quando ela não tem a forma do `UserPromptSubmit`. */
+function lerEntradaDoHook(v) {
+    if (!v || typeof v !== 'object')
+        return null;
+    const e = v;
+    if (e.hook_event_name !== 'UserPromptSubmit' || typeof e.session_id !== 'string' || !ID_DE_SESSAO.test(e.session_id) ||
+        typeof e.cwd !== 'string' || !path.isAbsolute(e.cwd) || typeof e.prompt !== 'string' ||
+        (e.transcript_path !== undefined && typeof e.transcript_path !== 'string') ||
+        (e.source !== undefined && (typeof e.source !== 'string' || !/^[a-z_]{1,40}$/.test(e.source))))
+        return null;
+    return { session_id: e.session_id, cwd: e.cwd, hook_event_name: e.hook_event_name, prompt: e.prompt,
+        ...(typeof e.transcript_path === 'string' ? { transcript_path: e.transcript_path } : {}),
+        ...(typeof e.source === 'string' ? { source: e.source } : {}) };
+}
+/** A decisão para o desfecho da resposta à pergunta do arco. */
+function decisaoDoDesfecho(p, d) {
+    if (d.tipo === 'registrada') {
+        return decisao({ acao: 'registrada', mensagem: d.mensagem, arco: p.arco, ato: d.ato, codigo: p.codigo, repetida: d.repetida });
+    }
+    if (d.tipo === 'sem-efeito' || d.tipo === 'detalhe')
+        return decisao({ acao: d.tipo, mensagem: d.mensagem });
+    return decisao({ acao: 'pergunta', mensagem: d.mensagem });
+}
+/** O contexto ao condutor quando o dono respondeu a um gate no terminal (D1): o que abrir, sem resposta nos argumentos. */
+function contextoDoGate(codigo, thread, pedidoId, texto) {
+    return `Orkastery: o dono digitou "${texto.slice(0, 40)}" e isso parece a resposta à pergunta ${codigo} (gate da thread ${thread}). ` +
+        'O terminal não grava resposta de gate: abra o diálogo nativo com ork_request_decision ' +
+        `(threadId ${thread}, pedidoId ${pedidoId}) para o dono escolher lá; nunca passe a resposta nos argumentos.`;
+}
+/** A palavra solta, a letra ou o número com a letra que diz "a": só ela age sem o código (GO-FIX 1, achado 3). */
+function dizA(trecho) {
+    return (trecho.tipo === 'letra' && trecho.letra === 'a') || (trecho.tipo === 'intencao' && trecho.intencao === 'afirmar');
+}
+/**
+ * GO-FIX 2 (D22): a resposta do terminal desligado. Nada é gravado nem encaminhado; com alguém presente, o dono vê por onde
+ * responder, e o prompt segue ao modelo.
+ */
+function desligado(texto, alvo, env) {
+    const codigo = alvo.tipo === 'arco' ? alvo.pergunta.codigo : alvo.tipo === 'gate' ? alvo.codigo : null;
+    return decisao({ acao: 'recusada', motivo: 'noctum.terminal.desligado', presenca: env.CLAUDE_CODE_SESSION_ATTENDED === '1',
+        mensagem: `O Orkastery não registrou "${texto.slice(0, 40)}"${codigo ? ` para a pergunta ${codigo}` : ''}: ` +
+            `${MOTIVOS['noctum.terminal.desligado']}. Responda pelo Telegram, em reply à mensagem da pergunta` +
+            `${codigo ? ` ou com ${codigo} e a letra` : ''}, ou pela janela de confirmação do Claude Code (o diálogo nativo).` });
+}
+/**
+ * GO-FIX 1 (achado 3): a palavra solta e o número com a letra só valem para a pergunta que o dono viu por último, e só
+ * para dizer "a". Respondida, já com "b" ou "c", ou sem estar na última linha mostrada: o prompt segue ao modelo.
+ */
+function alvoMostradoPorUltimo(raiz, entrada, amb, quando, trecho, numero) {
+    const fim = entrada.transcript_path ? (amb.transcricao ?? fimDaTranscricao)(entrada.transcript_path) : null;
+    const doArco = codigosMostradosPorUltimo(fim).flatMap(c => (0, noctum_resposta_1.perguntasPorCodigo)(raiz, c, quando));
+    if (!doArco.length)
+        return { tipo: 'nada', motivo: 'nenhuma-pergunta-mostrada-por-ultimo' };
+    if (doArco.length > 1) {
+        return { tipo: 'pergunta-de-volta', mensagem: `A última mensagem mostra ${doArco.length} perguntas do arco, e "${entrada.prompt.trim().slice(0, 40)}" ` +
+                `não diz qual; nada foi registrado. Responda pelo código: ${doArco.map(noctum_resposta_1.rotuloDaPergunta).join('; ')}.` };
+    }
+    const [p] = doArco;
+    if (numero !== null) {
+        let servida;
+        try {
+            servida = (0, pulse_resposta_1.lerLoteServido)(raiz, amb.estadoDir).perguntas.find(q => q.numero === numero);
+        }
+        catch {
+            servida = undefined;
+        }
+        if (servida?.arco?.codigo !== p.codigo)
+            return { tipo: 'nada', motivo: 'numero-de-outra-pergunta' };
+    }
+    if (!dizA(trecho))
+        return { tipo: 'nada', motivo: 'nao-diz-a' };
+    if (p.situacao === 'respondida')
+        return { tipo: 'nada', motivo: 'pergunta-ja-respondida' };
+    const semEfeito = (0, noctum_resposta_1.perguntasComRespostaSemEfeito)(raiz);
+    if (semEfeito === null || semEfeito.has(p.codigo))
+        return { tipo: 'nada', motivo: 'pergunta-ja-ouviu-b-ou-c' };
+    return { tipo: 'arco', pergunta: p, trecho };
+}
+/**
+ * O ingresso do terminal: lê o evento do hook, reconhece só a resposta curta, acha a pergunta (o código, ou a mostrada por
+ * último para a palavra solta e o número), confere a origem (D5) e responde pela via do terminal. Nunca adivinha.
+ * Desligado (D22), devolve o aviso logo depois de achar a pergunta, sem conferir a origem e sem gravar nem encaminhar.
+ */
+function responderPeloTerminal(raiz, bruto, amb) {
+    const quando = amb.quando ?? new Date().toISOString();
+    const entrada = lerEntradaDoHook(bruto);
+    if (!entrada)
+        return decisao({ acao: 'ignorar', motivo: 'entrada' });
+    const texto = entrada.prompt.trim();
+    // Uma linha só, conferida no prompt cru: a mensagem que a máquina embrulha (outra sessão, canal) vem em várias linhas, e
+    // nem a quebra no fim passa.
+    if (!texto || texto.length > TETO_DO_PROMPT || /[\r\n]/.test(entrada.prompt))
+        return decisao({ acao: 'ignorar', motivo: 'nao-e-resposta-curta' });
+    const lido = (0, pulse_resposta_1.interpretarRespostaDoPulse)(texto);
+    if (!['consentimento', 'lote', 'livre'].includes(lido.forma) || (lido.forma === 'lote' && lido.escolhas.length !== 1)) {
+        return decisao({ acao: 'ignorar', motivo: 'nao-e-resposta-curta' });
+    }
+    if (raiz === null)
+        return decisao({ acao: 'ignorar', motivo: 'sem-projeto' });
+    // O alvo: pelo código digitado, ou pela pergunta mostrada por último (a palavra solta e o número com a letra).
+    let alvo;
+    if (lido.forma === 'consentimento') {
+        const doArco = (0, noctum_resposta_1.perguntasPorCodigo)(raiz, lido.codigo, quando);
+        const gates = (0, pulse_resposta_1.pedidosComCodigo)(raiz, lido.codigo);
+        const resto = (0, pulse_resposta_1.restoDoCodigo)(texto, lido.codigo);
+        const trecho = (0, hitl_texto_livre_1.lerTrecho)(resto) ?? (resto === '?' ? (0, hitl_texto_livre_1.lerTrecho)('detalhes') : null);
+        alvo = doArco.length + gates.length > 1
+            ? { tipo: 'pergunta-de-volta', mensagem: `O código ${lido.codigo} está em mais de uma pergunta; nada foi registrado. Responda pelo número da pergunta.` }
+            : gates.length === 1 ? { tipo: 'gate', contexto: contextoDoGate(lido.codigo, gates[0].thread, gates[0].pedido.id, texto), codigo: lido.codigo }
+                : !doArco.length ? { tipo: 'nada', motivo: 'codigo-desconhecido' }
+                    : !trecho ? { tipo: 'pergunta-de-volta', mensagem: `Não entendi "${resto.slice(0, 40)}" para ${doArco[0].codigo}; nada foi registrado. Responda a, b ou c.` }
+                        : { tipo: 'arco', pergunta: doArco[0], trecho };
+    }
+    else if (lido.forma === 'lote') {
+        const { numero, letra } = lido.escolhas[0];
+        alvo = alvoMostradoPorUltimo(raiz, entrada, amb, quando, { tipo: 'letra', letra }, numero);
+    }
+    else {
+        alvo = lido.forma === 'livre' ? alvoMostradoPorUltimo(raiz, entrada, amb, quando, lido.trecho, null)
+            : { tipo: 'nada', motivo: 'nao-e-resposta-curta' };
+    }
+    if (alvo.tipo === 'nada')
+        return decisao({ acao: 'ignorar', motivo: alvo.motivo });
+    // GO-FIX 2 (D22): desligado, nada é gravado nem encaminhado, e o dono ouve por onde responder.
+    if (!(amb.ligado ?? exports.TERMINAL_LIGADO))
+        return desligado(texto, alvo, amb.env);
+    // D5: a origem do prompt e da sessão, antes de qualquer gravação ou encaminhamento. A palavra do dono não prova nada.
+    const origem = origemDoDono(raiz, entrada, amb);
+    if (!origem.ok) {
+        const presenca = amb.env.CLAUDE_CODE_SESSION_ATTENDED === '1';
+        const sobre = alvo.tipo === 'arco' ? ` para a pergunta ${alvo.pergunta.codigo}` : '';
+        return decisao({ acao: 'recusada', motivo: origem.motivo, presenca,
+            mensagem: `O Orkastery não registrou "${texto.slice(0, 40)}"${sobre}: ${MOTIVOS[origem.motivo] ?? origem.motivo}. ` +
+                'Responda pelo Telegram ou pelo diálogo do host.' });
+    }
+    if (alvo.tipo === 'pergunta-de-volta')
+        return decisao({ acao: 'pergunta', mensagem: alvo.mensagem });
+    if (alvo.tipo === 'gate')
+        return decisao({ acao: 'encaminhar', contexto: alvo.contexto });
+    const atestado = { ...origem.atestado, recebidoEm: quando };
+    const pergunta = alvo.pergunta;
+    const d = (0, noctum_resposta_1.responderPerguntaDoArco)(raiz, pergunta, alvo.trecho, { quando, canal: 'terminal',
+        provar: r => ({ via: 'terminal', atestado, pergunta: { ...r, respostaSha256: sha(entrada.prompt) } }) });
+    return decisaoDoDesfecho(pergunta, d);
+}