@autonsh/cli 0.16.5 → 0.17.2

package/dist/index.js

@@ -15,7 +15,11 @@ import { SingleBar, Presets } from "cli-progress";
 import pc from "picocolors";
 import { ok, fail, info, dim, bold, url, spinner, logo, tagLine, statusColor, table, box, isTTY, } from "./ui.js";
 import { cmdLogin as loginCmd, cmdLogout as logoutCmd, credentialEnv } from "./login.js";
-import { TEMPLATES, promptInit, promptConfirmUndeploy, promptGateApproval, } from "./prompts.js";
+import { cmdModel, modelLs, modelSet, modelTest } from "./model.js";
+import { cmdChat } from "./chat.js";
+import { resolveAgent } from "./picker.js";
+import { getDefaultModel, getActiveProvider } from "./config.js";
+import { TEMPLATES, promptInit, promptConfirmUndeploy, promptGateApproval, promptGateQuestion, parseGateLine, } from "./prompts.js";
 import { loadTaskManifest, MODES, SKILLS, EXIT, ExitError, } from "./task.js";
 import { runVerify } from "./verify.js";
 const SRC = dirname(fileURLToPath(import.meta.url));
@@ -45,8 +49,8 @@ function ensureRuntimeLink(dir) {
  * TTY: barra de progresso com fases do npm. Pipe: silencioso, 1 linha. */
 async function installRuntime(dir) {
     const run = (onLine) => new Promise((resolveP, reject) => {
-        const args = ["install", "@autonsh/runtime", "--no-audit", "--no-fund", "--loglevel=info"];
-        const child = spawn("npm", args, {
+        const realArgs = ["install", "@autonsh/runtime", "--no-audit", "--no-fund", "--loglevel=info"];
+        const child = spawn("npm", realArgs, {
             cwd: dir,
             stdio: ["ignore", "ignore", "pipe"],
             shell: process.platform === "win32",
@@ -157,10 +161,79 @@ async function cmdInit(name, template, opts = {}) {
     if (isTTY)
         console.log(logo());
     console.log(ok(`${plain} (template: ${template}) em ${dim(dir)}`));
-    console.log(info(`próximo: ${bold(`auton run "${plain}" <objetivo>`)}`));
+    console.log(info(`próximo: ${bold(`cd ${plain} && auton run "<objetivo>"`)}`));
 }
 const VERSION = JSON.parse(readFileSync(resolve(SRC, "../package.json"), "utf8")).version;
 const API = process.env.AUTON_API ?? "http://localhost:8080";
+let cpStarted = false;
+/** G3: auto-start control plane se não estiver rodando (single-command UX). */
+async function ensureCPRunning() {
+    if (cpStarted)
+        return;
+    try {
+        const res = await fetch(`${API}/v1/agents`, {
+            method: "GET",
+            headers: authHeaders(),
+            signal: AbortSignal.timeout(1000),
+        });
+        if (res.ok) {
+            cpStarted = true;
+            return;
+        }
+    }
+    catch {
+        // CP não responde — tenta iniciar
+    }
+    // Tenta achar binário do control-plane
+    const candidates = [
+        // monorepo dev
+        resolve(SRC, "../../control-plane/bin/control-plane"),
+        // npm install global (se publicado)
+        resolve(process.execPath, "../../lib/node_modules/@autonsh/server/bin/control-plane"),
+        // fallback PATH
+        "control-plane",
+    ];
+    let cpBin = null;
+    for (const c of candidates) {
+        try {
+            await import("node:fs/promises").then((fs) => fs.access(c, fs.constants.X_OK));
+            cpBin = c;
+            break;
+        }
+        catch {
+            // não existe ou não executável
+        }
+    }
+    if (!cpBin) {
+        console.log(dim("aviso: control-plane não encontrado — assumindo externo"));
+        return;
+    }
+    console.log(info(`iniciando control-plane (${cpBin})...`));
+    const child = spawn(cpBin, {
+        detached: true,
+        stdio: ["ignore", "ignore", "ignore"],
+    });
+    child.unref();
+    // Aguarda CP subir (max 5s)
+    for (let i = 0; i < 50; i++) {
+        await new Promise((r) => setTimeout(r, 100));
+        try {
+            const res = await fetch(`${API}/v1/agents`, {
+                headers: authHeaders(),
+                signal: AbortSignal.timeout(500),
+            });
+            if (res.ok) {
+                cpStarted = true;
+                console.log(ok("control-plane iniciado"));
+                return;
+            }
+        }
+        catch {
+            // ainda subindo
+        }
+    }
+    console.log(dim("aviso: control-plane pode não ter subido a tempo"));
+}
 function authHeaders(extra) {
     const h = { ...extra };
     const token = process.env.AUTON_TOKEN;
@@ -168,37 +241,74 @@ function authHeaders(extra) {
         h.Authorization = `Bearer ${token}`;
     return h;
 }
+/** Nomes dos agentes deployados (0.17.0 — `auton <nome>` abre sessão). */
+async function listAgentNames() {
+    try {
+        const res = await fetch(`${API}/v1/agents`, { headers: authHeaders() });
+        if (!res.ok)
+            return [];
+        return (await res.json()).map((a) => a.name);
+    }
+    catch {
+        return [];
+    }
+}
 const USAGE = `
 auton — Tasks that start themselves
 
 Usage:
-auton run [goal]                Roda a task do diretório atual com o objetivo
-                                   (usa task.yaml: goal default; gates de aprovação
-                                   perguntam em linha — TTY; verify: roda antes — use
-                                   --skip-verify pra pular)
-  auton verify [dir] [--json]     Roda gates mecânicos do verify: (task.yaml)
-  auton inspect [dir] [--json]    Inspeciona task + evidência (goal/mode/verify/traces)
-  auton continue [name] [goal]    Retoma a última task (sem redeploy)
-  auton init [nome] [template]    Scaffold de task (support|with-approval|cron-digester|webhook-echo)
-  auton ps                        Lista tasks/agentes + status
-  auton logs [name]               Stream de logs da task (SSE)
-  auton status [name]             Status da task
+  auton <comando> [argumentos]
+
+Modelos:
+  auton model                       Seletor interativo do modelo default
+                                     (local ollama + providers configurados)
+  auton model ls [--json]           Lista modelos locais + providers
+  auton model set <spec>            Define default (ex: ollama:qwen3)
+  auton model test                  Testa latência dos providers
+  auton login [provider] [--apikey X]
+                                    Conecta provider (gemini/groq/ollama)
+  auton logout [id]                 Remove provider configurado
+
+Agentes:
+  auton [nome]                      Sessão de trabalho (estilo opencode): dá
+                                     tasks, acompanha o agente ao vivo, gates
+                                     inline. Sem nome: cwd/picker.
+  auton chat [name]                 Alias da sessão de trabalho
+  auton agent [dir]                 Deploy do agente no diretório
+  auton ps                          Lista agentes + status
+  auton logs [name] [--tail N] [--follow] [--since X] [--turn N]
+                                    Stream de logs do agente (SSE)
+  auton status [name]               Status do agente
+  auton restart [name]              Reinicia o agente
   auton invoke [name] [--stream] [-- prompt]
-                                  Roda 1 turno (legado v0)
-  auton kv get|set|ls [name] [key] [value]
-                                  Inspeciona o storage KV
-  auton context [name]              Lista work context: decisions/findings/artifacts
+                                    Roda 1 turno (legado v0)
   auton approve|reject [name] [-- razão]
-                                  Decide o gate de aprovação (approval: true)
-  auton undeploy [name]           Remove a task
-  auton login                     TODO: auth com control plane (dpk_...)
+                                    Decide o gate de aprovação
+  auton answer [name] [-- texto]    Responde pergunta pendente (ctx.ask)
+  auton context [name]              Work context: decisions/findings/artifacts
+  auton undeploy [name]             Remove o agente (--all remove tudo)
+
+Tasks:
+  auton run [goal] [--model X] [--skip-verify] [--async]
+                                      Roda a task do diretório atual (--async = fire-and-forget)
+  auton wait <task-id>                Aguarda task async terminar (poll logs)
+  auton result <task-id>              Busca resultado final de task async
+  auton verify [dir] [--json]         Roda gates mecânicos do verify
+  auton inspect [dir] [--json]        Inspeciona task + evidência
+  auton continue [name] [goal]        Retoma a última task (sem redeploy)
+  auton init [nome] [template]        Scaffold de task (support|with-approval|...)
+
+Infra:
+  auton kv get|set|ls [name] [key] [value]
+                                    Inspeciona o storage KV
+  auton env set|get|ls [name] [key] [value]
+                                    Env vars por agente
 
 Options:
   --help, -h                 Mostra ajuda
-  --version, -v              Mostra versão
+  --version, -v              Mostra versão + modelo default
   AUTON_API=http://...       Base do control plane (default localhost:8080)
-
-Nota: commandos legado v0 (deploy agent . / deploy invoke) continuam funcionando.
+  --no-auto-cp               Desliga auto-start do control plane
 
 Exit codes (0.14):
   0 ok · 1 erro genérico · 2 uso inválido · 3 verificação falhou
@@ -414,24 +524,190 @@ async function cmdRun(dir, goalArg, skipVerify, model) {
     const manifest = await loadTaskManifest(dir);
     if (!skipVerify)
         await verifyPreFlight(dir, manifest);
-    const goal = goalArg ?? manifest.goal;
+    let goal = goalArg ?? manifest.goal;
     if (!goal) {
-        throw new Error(`task ${manifest.name} sem objetivo — passe "${bold('auton run "<objetivo>"')}" ou defina 'goal' no task.yaml`);
+        if (isTTY) {
+            // 0.17: run sem goal pergunta (estilo `ollama run` sem modelo)
+            const { text, isCancel } = await import("@clack/prompts");
+            const answered = (await text({
+                message: `qual o objetivo da task ${manifest.name}?`,
+                validate: (v) => (!v || v.trim() === "" ? "objetivo não pode ser vazio" : undefined),
+            }));
+            if (isCancel(answered)) {
+                console.log(dim("cancelado"));
+                return;
+            }
+            goal = answered.trim();
+        }
+        else {
+            throw new Error(`task ${manifest.name} sem objetivo — passe "${bold('auton run "<objetivo>"')}" ou defina 'goal' no task.yaml`);
+        }
     }
-    // 0.16.13: modelo efetivo = --model > task.yaml > env; valida no provider antes do turno
-    await precheckModel(model ?? manifest.models ?? process.env.AUTON_MODEL ?? "");
+    // 0.17: modelo efetivo = --model > task.yaml > env > config default (auton model)
+    const defaultModel = getDefaultModel();
+    await precheckModel(model ?? manifest.models ?? process.env.AUTON_MODEL ?? defaultModel);
     // 0.15.1: credencial do `auton login` injetada no deploy (key/base);
     // --model (0.14.3) sobrescreve models: do task.yaml
     await cmdDeploy(dir, { ...credentialEnv(), ...(model ? { AUTON_MODEL: model } : {}) });
     const lines = await runWithGates(manifest.name, goal);
     await printTaskDone(manifest.name, goal, lines);
 }
+/** G2: auton run --async — dispara task e retorna task-id imediatamente. */
+async function cmdRunAsync(dir, goalArg, skipVerify, model) {
+    const manifest = await loadTaskManifest(dir);
+    if (!skipVerify)
+        await verifyPreFlight(dir, manifest);
+    let goal = goalArg ?? manifest.goal;
+    if (!goal) {
+        throw new Error(`task ${manifest.name} sem objetivo — passe "auton run \"<objetivo>\" --async" ou defina 'goal' no task.yaml`);
+    }
+    const defaultModel = getDefaultModel();
+    await precheckModel(model ?? manifest.models ?? process.env.AUTON_MODEL ?? defaultModel);
+    await cmdDeploy(dir, { ...credentialEnv(), ...(model ? { AUTON_MODEL: model } : {}) });
+    // Gera task-id único: agent-name + timestamp + random
+    const taskId = `${manifest.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    // Dispara invoke sem aguardar (fire-and-forget)
+    const body = { prompt: goal };
+    const res = await fetch(`${API}/v1/agents/${manifest.name}/invoke`, {
+        method: "POST",
+        headers: authHeaders({ "Content-Type": "application/json" }),
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        throw new Error(`control plane ${res.status}: ${await res.text()}`);
+    }
+    // Salva mapping task-id -> agent name para wait/result
+    const taskMapKey = `task-map:${taskId}`;
+    await fetch(`${API}/v1/agents/${manifest.name}/kv/${taskMapKey}`, {
+        method: "PUT",
+        headers: authHeaders({ "Content-Type": "application/json" }),
+        body: JSON.stringify({ agent: manifest.name, goal, startedAt: new Date().toISOString() }),
+    });
+    console.log(ok(`task iniciada (async): ${bold(taskId)}`));
+    console.log(info(`  agente: ${manifest.name}`));
+    console.log(info(`  objetivo: ${goal}`));
+    console.log(info(`  acompanhe: ${bold(`auton wait ${taskId}`)} | resultado: ${bold(`auton result ${taskId}`)}`));
+}
+/** G2: auton wait <task-id> — aguarda task terminar (poll logs até TASK:DONE/ERR). */
+async function cmdWait(taskId) {
+    if (!taskId)
+        throw new ExitError(EXIT.USAGE, "uso: auton wait <task-id>");
+    // Busca agent name do task-id via KV de qualquer agente (precisa listar agentes)
+    const agentsRes = await fetch(`${API}/v1/agents`, { headers: authHeaders() });
+    if (!agentsRes.ok)
+        throw new Error(`control plane ${agentsRes.status}: ${await agentsRes.text()}`);
+    const agents = (await agentsRes.json());
+    let agentName;
+    let taskInfo;
+    for (const a of agents) {
+        const taskMapKey = `task-map:${taskId}`;
+        const res = await fetch(`${API}/v1/agents/${a.name}/kv/${taskMapKey}`, { headers: authHeaders() });
+        if (res.ok) {
+            taskInfo = (await res.json());
+            agentName = taskInfo.agent;
+            break;
+        }
+    }
+    if (!agentName || !taskInfo) {
+        throw new Error(`task-id ${taskId} não encontrado`);
+    }
+    console.log(info(`aguardando task ${bold(taskId)} (agente: ${agentName})...`));
+    const deadline = Date.now() + 30 * 60 * 1000; // 30 min max
+    let lastLineCount = 0;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 2000));
+        const res = await fetch(`${API}/v1/agents/${agentName}/logs?tail=50`, {
+            headers: authHeaders({ Accept: "application/json" }),
+        });
+        if (!res.ok)
+            continue;
+        const entries = (await res.json());
+        const lines = entries.map((e) => e.line);
+        // Verifica se terminou
+        const doneLine = lines.find((l) => l.startsWith("[TASK:DONE]"));
+        const errLine = lines.find((l) => l.startsWith("[TASK:ERR]"));
+        if (doneLine || errLine) {
+            console.log(ok(`task ${bold(taskId)} concluída`));
+            if (doneLine) {
+                const ev = JSON.parse(doneLine.slice("[TASK:DONE]".length).trim());
+                if (ev.result)
+                    console.log(dim(`resultado: ${ev.result}`));
+            }
+            else {
+                console.log(fail(`task falhou: ${errLine.slice("[TASK:ERR]".length).trim()}`));
+                process.exitCode = EXIT.ERR;
+            }
+            return;
+        }
+        // Progress: mostra novas linhas se houver
+        if (lines.length > lastLineCount) {
+            for (let i = lastLineCount; i < lines.length; i++) {
+                const line = lines[i];
+                if (line)
+                    console.log(tagLine(line));
+            }
+            lastLineCount = lines.length;
+        }
+    }
+    console.log(info(`timeout aguardando task — veja ${bold(`auton logs ${agentName}`)} ou ${bold(`auton result ${taskId}`)}`));
+    process.exitCode = EXIT.TIMEOUT;
+}
+/** G2: auton result <task-id> — busca resultado final da task (sem aguardar). */
+async function cmdResult(taskId) {
+    if (!taskId)
+        throw new ExitError(EXIT.USAGE, "uso: auton result <task-id>");
+    const agentsRes = await fetch(`${API}/v1/agents`, { headers: authHeaders() });
+    if (!agentsRes.ok)
+        throw new Error(`control plane ${agentsRes.status}: ${await agentsRes.text()}`);
+    const agents = (await agentsRes.json());
+    let agentName;
+    for (const a of agents) {
+        const taskMapKey = `task-map:${taskId}`;
+        const res = await fetch(`${API}/v1/agents/${a.name}/kv/${taskMapKey}`, { headers: authHeaders() });
+        if (res.ok) {
+            const info = (await res.json());
+            agentName = info.agent;
+            break;
+        }
+    }
+    if (!agentName) {
+        throw new Error(`task-id ${taskId} não encontrado`);
+    }
+    // Busca última evidência TASK:DONE nos logs
+    const res = await fetch(`${API}/v1/agents/${agentName}/logs?tail=100`, {
+        headers: authHeaders({ Accept: "application/json" }),
+    });
+    if (!res.ok)
+        throw new Error(`control plane ${res.status}: ${await res.text()}`);
+    const entries = (await res.json());
+    const lines = entries.map((e) => e.line);
+    const doneLine = [...lines].reverse().find((l) => l.startsWith("[TASK:DONE]"));
+    const errLine = [...lines].reverse().find((l) => l.startsWith("[TASK:ERR]"));
+    if (doneLine) {
+        const ev = JSON.parse(doneLine.slice("[TASK:DONE]".length).trim());
+        console.log(ok(`task ${bold(taskId)} concluída`));
+        console.log(`resultado: ${ev.result ?? "?"}`);
+        if (ev.evidence)
+            console.log(dim(`evidência: ${JSON.stringify(ev.evidence)}`));
+        return;
+    }
+    if (errLine) {
+        console.log(fail(`task ${bold(taskId)} falhou`));
+        console.log(`erro: ${errLine.slice("[TASK:ERR]".length).trim()}`);
+        process.exitCode = EXIT.ERR;
+        return;
+    }
+    console.log(info(`task ${bold(taskId)} ainda em andamento — use ${bold(`auton wait ${taskId}`)} para aguardar`));
+}
 /** 0.16.13 — valida modelo no provider antes do turno (ollama /api/tags; openai-compat /models).
  * Falha dura só quando o provider respondeu e o modelo não existe; endpoint fora → aviso. */
 async function precheckModel(model) {
     if (!model)
         return;
-    const [provider, name] = model.split(":", 2);
+    // 0.17.1 — separa provider do nome SEM cortar a tag (ollama:deepseek-coder:1.3b)
+    const sep = model.indexOf(":");
+    const provider = sep === -1 ? model : model.slice(0, sep);
+    const name = sep === -1 ? undefined : model.slice(sep + 1);
     if (!name)
         return;
     if (provider === "ollama") {
@@ -462,30 +738,37 @@ async function precheckModel(model) {
         return;
     }
 }
-/** Roda o turno resolvendo gates pendentes em linha (TTY pergunta; pipe reporta). */
+/** Roda o turno resolvendo gates pendentes em linha (TTY pergunta; pipe reporta).
+ * 0.17.0: além de aprovação, resolve perguntas de clarificação (ctx.ask). */
 async function runWithGates(name, goal) {
     let lines = await cmdInvoke(name, goal, false);
     for (let i = 0; i < 10; i++) {
-        const gate = lines.find((l) => l.startsWith("[APPROVAL:REQ]"));
+        const gate = lines.find((l) => l.startsWith("[APPROVAL:REQ]") || l.startsWith("[QUESTION:REQ]"));
         if (!gate)
             return lines;
+        const g = parseGateLine(gate);
+        if (!g)
+            return lines;
+        if (g.kind === "question") {
+            if (!isTTY) {
+                console.log(info("pergunta pendente — rode `auton answer <nome> -- \"resposta\"`"));
+                return lines;
+            }
+            const answer = await promptGateQuestion(String(g.payload?.question ?? "pergunta"));
+            if (answer === undefined)
+                return lines;
+            lines = await answerPost(name, answer);
+            continue;
+        }
         if (!isTTY) {
             console.log(info("aprovação pendente — rode `auton approve` ou `auton reject`"));
             return lines;
         }
-        let payload;
-        try {
-            payload = gate.slice("[APPROVAL:REQ]".length).trim();
-            JSON.parse(payload);
-        }
-        catch {
-            payload = "{}";
-        }
-        const reason = JSON.parse(payload).reason ?? "ação";
+        const reason = g.payload?.reason ?? "ação";
         const approved = await promptGateApproval(reason);
         lines = await cmdInvokeApproval(name, approved, undefined);
     }
-    throw new Error(`loop de aprovação não convergiu (10 gates)`);
+    throw new Error(`loop de gates não convergiu (10)`);
 }
 /** POST de controle: resolve o gate pendente no worker (sem novo trigger). */
 async function cmdInvokeApproval(name, approved, reason) {
@@ -506,6 +789,62 @@ async function cmdInvokeApproval(name, approved, reason) {
         console.log(line);
     return out.lines;
 }
+/** 0.17.0 — POST de controle de pergunta: resolve ctx.ask no worker (sem trigger novo). */
+async function answerPost(name, answer) {
+    const res = await fetch(`${API}/v1/agents/${name}/invoke`, {
+        method: "POST",
+        headers: authHeaders({ "Content-Type": "application/json" }),
+        body: JSON.stringify({ question: { answer } }),
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        if (res.status === 409 && body.includes("sem pergunta pendente")) {
+            throw new Error(`task ${name} sem pergunta pendente`);
+        }
+        throw new Error(`control plane ${res.status}: ${body}`);
+    }
+    const out = (await res.json());
+    return out.lines;
+}
+/** auton answer [name] [-- texto] — responde pergunta de clarificação pendente. */
+async function cmdAnswer(name, answer) {
+    const agent = await resolveAgent("answer", name);
+    if (answer === undefined) {
+        if (!isTTY) {
+            throw new ExitError(EXIT.USAGE, `uso: auton answer <nome> -- "resposta" (pipe)`);
+        }
+        // mostra a pergunta pendente (logs recentes) e pede a resposta
+        let question = "pergunta pendente — responda:";
+        const logs = await fetch(`${API}/v1/agents/${agent}/logs?tail=30`, {
+            headers: authHeaders({ Accept: "application/json" }),
+        });
+        if (logs.ok) {
+            const entries = (await logs.json());
+            const qline = [...entries].reverse().find((e) => e.line.startsWith("[QUESTION:REQ]"));
+            if (qline) {
+                const g = parseGateLine(qline.line);
+                if (g)
+                    question = String(g.payload?.question ?? question);
+            }
+        }
+        answer = await promptGateQuestion(question);
+        if (answer === undefined) {
+            console.log(dim("cancelado — agente segue pausado"));
+            return;
+        }
+    }
+    const lines = await answerPost(agent, answer);
+    console.log(ok(`resposta entregue — task ${bold(agent)} segue.`));
+    const done = lines.find((l) => l.startsWith("[TASK:DONE]"));
+    if (done) {
+        const ev = JSON.parse(done.slice("[TASK:DONE]".length).trim());
+        if (ev.result)
+            console.log(dim(`resultado: ${ev.result}`));
+    }
+    else if (lines.some((l) => l.startsWith("[QUESTION:REQ]"))) {
+        console.log(info("nova pergunta pendente — `auton answer` de novo."));
+    }
+}
 /** auton continue — retoma a última task sem re-passar o objetivo.
  * O harness guarda o último input no KV ("ultima-task"); aqui só busca e
  * invoca de novo (worker dormindo → cold start; KV persiste). */
@@ -531,15 +870,7 @@ async function cmdContinue(dir, nameArg, goalArg) {
  * 0.12: vira POST de CONTROLE (resolve gate pendente no worker vivo);
  * gate de legado (template com approval:) também é resolvido assim. */
 async function cmdApproval(name, approved, reason) {
-    let agent = name;
-    if (!agent) {
-        try {
-            agent = (await loadTaskManifest(process.cwd())).name;
-        }
-        catch {
-            throw new Error(`${approved ? "approve" : "reject"}: nenhum nome passado e cwd não é um agente — rode \`auton ${approved ? "approve" : "reject"} <nome>\``);
-        }
-    }
+    const agent = await resolveAgent(approved ? "approve" : "reject", name);
     const lines = await cmdInvokeApproval(agent, approved, reason);
     const done = lines.find((l) => l.startsWith("[TASK:DONE]"));
     if (done) {
@@ -562,7 +893,7 @@ async function cmdApproval(name, approved, reason) {
 /** 0.16.14: snapshot JSON c/ timestamp + filtro por turno (--turn N = últimos N turnos);
  * --follow mantém SSE ao vivo (sem ts, como antes). */
 async function cmdLogs(name, tail, since, follow = false, turn) {
-    const agent = name ?? (await loadTaskManifest(process.cwd())).name;
+    const agent = name ?? (await resolveAgent("logs", undefined));
     const params = new URLSearchParams();
     if (tail !== undefined)
         params.set("tail", String(tail));
@@ -597,6 +928,7 @@ async function cmdLogs(name, tail, since, follow = false, turn) {
     }
     if (!res.body)
         throw new Error("resposta sem body");
+    console.log(dim(`— seguindo ${agent} — Ctrl+C sai —`));
     const reader = res.body.getReader();
     const decoder = new TextDecoder();
     let buf = "";
@@ -619,7 +951,7 @@ async function cmdLogs(name, tail, since, follow = false, turn) {
     }
 }
 async function cmdStatus(name) {
-    const agent = name ?? (await loadTaskManifest(process.cwd())).name;
+    const agent = await resolveAgent("status", name);
     const res = await fetch(`${API}/v1/agents/${agent}`, {
         headers: authHeaders(),
     });
@@ -630,7 +962,7 @@ async function cmdStatus(name) {
 }
 async function cmdRestart(name) {
     // 0.1.1 — reinicia o agente (SIGTERM + respawn, state preservado)
-    const agent = name ?? (await loadTaskManifest(process.cwd())).name;
+    const agent = await resolveAgent("restart", name);
     const res = await fetch(`${API}/v1/agents/${agent}/restart`, {
         method: "POST",
         headers: authHeaders(),
@@ -661,7 +993,7 @@ async function cmdUndeploy(name) {
             console.log(dim("(nada pra remover)"));
         return;
     }
-    const agent = name ?? (await loadTaskManifest(process.cwd())).name;
+    const agent = await resolveAgent("undeploy", name);
     if (isTTY && !(await promptConfirmUndeploy(agent)))
         return;
     const res = await fetch(`${API}/v1/agents/${agent}`, {
@@ -819,7 +1151,7 @@ async function cmdInvoke(name, prompt, stream) {
 /** autonomous context [name] — imprime a memória do trabalho da task:
  * decisions/findings/artifacts gravadas via ctx.work (KV "work:*"). */
 async function cmdContext(name) {
-    const agent = name ?? (await loadTaskManifest(process.cwd())).name;
+    const agent = await resolveAgent("context", name);
     const res = await fetch(`${API}/v1/agents/${agent}/kv`, { headers: authHeaders() });
     if (!res.ok)
         throw new Error(`control plane ${res.status}: ${await res.text()}`);
@@ -916,8 +1248,9 @@ async function cmdPs(json) {
         a.cron ? "sim" : "-",
         String(a.logs),
         String(a.kv),
+        a.model ? String(a.model) : "-",
     ]);
-    console.log(table(["AGENTE", "STATUS", "CRON", "LOGS", "KV"], rows));
+    console.log(table(["AGENTE", "STATUS", "CRON", "LOGS", "KV", "MODEL"], rows));
 }
 async function cmdKv(op, name, key, value) {
     const agent = name ?? (await loadTaskManifest(process.cwd())).name;
@@ -958,40 +1291,101 @@ async function cmdKv(op, name, key, value) {
         throw new Error(`control plane ${res.status}: ${await res.text()}`);
     console.log(ok(`${key} = ${bold(value)}`));
 }
-async function cmdLogin(args) {
+async function cmdLogin(realArgs) {
     // 0.15.1 — auton login [provider] [--apikey X] / auton logout
-    const keyIdx = args.indexOf("--apikey");
-    const apiKey = keyIdx !== -1 ? args[keyIdx + 1] : undefined;
-    const provider = args
-        .filter((a, i) => a !== "--apikey" && args[i - 1] !== "--apikey" && !a.startsWith("-"))
+    const keyIdx = realArgs.indexOf("--apikey");
+    const apiKey = keyIdx !== -1 ? realArgs[keyIdx + 1] : undefined;
+    const provider = realArgs
+        .filter((a, i) => a !== "--apikey" && realArgs[i - 1] !== "--apikey" && !a.startsWith("-"))
         .find(() => true);
     await loginCmd(provider, apiKey);
 }
-async function cmdLogout() {
-    await logoutCmd();
+async function cmdLogout(providerId) {
+    await logoutCmd(providerId);
 }
 async function main() {
-    const args = process.argv.slice(2);
-    if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    let realArgs = process.argv.slice(2);
+    // G3: auto-start CP para comandos que precisam dele (--no-auto-cp desliga)
+    const noAutoCP = realArgs.includes("--no-auto-cp");
+    const noCP = new Set(["login", "logout", "model", "--help", "-h", "--version", "-v", "init"]);
+    const cmd = realArgs[0];
+    if (!noAutoCP && cmd && !noCP.has(cmd)) {
+        await ensureCPRunning();
+    }
+    // Remove --no-auto-cp dos realArgs antes do switch
+    realArgs = realArgs.filter((a) => a !== "--no-auto-cp");
+    if (realArgs.length === 0) {
+        // 0.17.0 — `auton` bare: abre sessão de trabalho (estilo opencode):
+        // cwd é agente → sessão nele; senão picker. Pipe: mosta ajuda.
+        if (isTTY) {
+            await cmdChat(undefined);
+            return;
+        }
+        console.log(USAGE);
+        return;
+    }
+    if (realArgs[0] === "--help" || realArgs[0] === "-h") {
         console.log(USAGE);
         return;
     }
-    if (args[0] === "--version" || args[0] === "-v") {
+    if (realArgs[0] === "--version" || realArgs[0] === "-v") {
         if (isTTY)
             console.log(logo());
         console.log(bold(`auton v${VERSION}`));
+        const d = getDefaultModel();
+        const active = getActiveProvider();
+        if (d)
+            console.log(dim(`  modelo default: ${d}`));
+        if (active)
+            console.log(dim(`  provider: ${active.id} (${active.quando.slice(0, 10)})`));
         return;
     }
-    switch (args[0]) {
+    // 0.17.0 — `auton <nome-de-agente-deployado>` abre sessão (comandos têm prioridade).
+    const KNOWN = new Set([
+        "login", "logout", "model", "agent", "logs", "status", "restart", "run",
+        "verify", "inspect", "continue", "invoke", "undeploy", "approve", "reject",
+        "ps", "context", "env", "init", "kv", "chat", "answer", "wait", "result",
+    ]);
+    if (!KNOWN.has(realArgs[0]) && isTTY) {
+        const deployed = await listAgentNames();
+        if (deployed.includes(realArgs[0])) {
+            await cmdChat(realArgs[0]);
+            return;
+        }
+    }
+    switch (realArgs[0]) {
         case "login":
-            await cmdLogin(args.slice(1));
+            await cmdLogin(realArgs.slice(1));
             break;
         case "logout":
-            await cmdLogout();
+            await cmdLogout(realArgs[1]);
+            break;
+        case "model": {
+            // auton model [ls|set <spec>|test] — sem sub: seletor TTY
+            const sub = realArgs[1];
+            const json = realArgs.includes("--json");
+            if (sub === "ls") {
+                await modelLs(json);
+            }
+            else if (sub === "set") {
+                if (!realArgs[2])
+                    throw new ExitError(EXIT.USAGE, "uso: auton model set <provider:modelo>");
+                await modelSet(realArgs[2]);
+            }
+            else if (sub === "test") {
+                await modelTest();
+            }
+            else if (sub === undefined || sub === "select") {
+                await cmdModel();
+            }
+            else {
+                throw new ExitError(EXIT.USAGE, `uso: auton model [ls|set <spec>|test] — subcomando desconhecido: ${sub}`);
+            }
             break;
+        }
         case "agent":
-            if (args[1]) {
-                const dir = resolve(args[1]);
+            if (realArgs[1]) {
+                const dir = resolve(realArgs[1]);
                 ensureRuntimeLink(dir);
                 await cmdDeploy(dir);
             }
@@ -1001,8 +1395,8 @@ async function main() {
             }
             break;
         case "logs":
-            // args[1..]: [name] [--tail N] [--since RFC3339] [--follow] [--turn N]
-            const rest = args.slice(1);
+            // realArgs[1..]: [name] [--tail N] [--since RFC3339] [--follow] [--turn N]
+            const rest = realArgs.slice(1);
             const tailIdx = rest.indexOf("--tail");
             const sinceIdx = rest.indexOf("--since");
             let name;
@@ -1034,34 +1428,90 @@ async function main() {
             await cmdLogs(name, tail, since, follow, turn);
             break;
         case "status":
-            await cmdStatus(args[1]);
+            await cmdStatus(realArgs[1]);
             break;
         case "restart":
-            await cmdRestart(args[1]);
+            await cmdRestart(realArgs[1]);
             break;
         case "run": {
-            // auton run "<goal>" [--skip-verify] [--model X] (ou auton run → goal do task.yaml)
-            const skipVerify = args.includes("--skip-verify");
-            const modelIdx = args.indexOf("--model");
-            const model = modelIdx !== -1 ? args[modelIdx + 1] : undefined;
-            const goal = args
-                .slice(1)
-                .filter((a, i) => a !== "--skip-verify" && a !== "--model" && args[i - 1] !== "--model")
-                .join(" ")
-                .trim() || undefined;
-            ensureRuntimeLink(process.cwd());
-            await cmdRun(process.cwd(), goal, skipVerify, model);
+            // auton run "<goal>" [--skip-verify] [--model X] [--async] [--dir DIR] [-d DIR] (ou auton run <agent-name> "goal")
+            const skipVerify = realArgs.includes("--skip-verify");
+            const isAsync = realArgs.includes("--async");
+            const modelIdx = realArgs.indexOf("--model");
+            const model = modelIdx !== -1 ? realArgs[modelIdx + 1] : undefined;
+            // --dir / -d
+            const dirIdx = realArgs.indexOf("--dir");
+            const dirShortIdx = realArgs.indexOf("-d");
+            const explicitDir = (dirIdx !== -1 ? realArgs[dirIdx + 1] : undefined) ??
+                (dirShortIdx !== -1 ? realArgs[dirShortIdx + 1] : undefined);
+            // resolve dir: --dir > agent name via CP > cwd
+            let targetDir = explicitDir ? resolve(explicitDir) : process.cwd();
+            let usedAgentName = false;
+            let agentNameSliceIdx = -1; // index in realArgs.slice(1) of the agent name
+            if (!explicitDir) {
+                // Find first positional arg (not a flag) after "run"
+                let firstPosArg;
+                let firstPosArgIdx = -1;
+                for (let i = 1; i < realArgs.length; i++) {
+                    const arg = realArgs[i];
+                    if (arg && !arg.startsWith("-")) {
+                        firstPosArg = arg;
+                        firstPosArgIdx = i;
+                        break;
+                    }
+                }
+                if (firstPosArg) {
+                    const knownCmds = new Set([
+                        "login", "logout", "model", "agent", "logs", "status", "restart", "run",
+                        "verify", "inspect", "continue", "invoke", "undeploy", "approve", "reject",
+                        "ps", "context", "env", "init", "kv", "chat", "answer", "wait", "result",
+                    ]);
+                    if (!knownCmds.has(firstPosArg)) {
+                        try {
+                            const agent = await resolveAgent("run", firstPosArg);
+                            const statusRes = await fetch(`${API}/v1/agents/${agent}`, { headers: authHeaders() });
+                            if (statusRes.ok) {
+                                const status = (await statusRes.json());
+                                if (status.dir) {
+                                    targetDir = resolve(status.dir);
+                                    usedAgentName = true;
+                                    agentNameSliceIdx = firstPosArgIdx - 1; // index in realArgs.slice(1)
+                                }
+                            }
+                        }
+                        catch { /* ignora, usa cwd */ }
+                    }
+                }
+            }
+            // build goal: exclude flags + agent name if used for resolution
+            const goal = realArgs.slice(1).filter((a, i) => {
+                const origIdx = i + 1; // index in realArgs
+                if (a === "--skip-verify" || a === "--model" || realArgs[origIdx - 1] === "--model" ||
+                    a === "--async" || a === "--dir" || a === "-d" ||
+                    realArgs[origIdx - 1] === "--dir" || realArgs[origIdx - 1] === "-d")
+                    return false;
+                if (usedAgentName && i === agentNameSliceIdx)
+                    return false; // exclude agent name from goal
+                return true;
+            }).join(" ").trim() || undefined;
+            ensureRuntimeLink(targetDir);
+            if (isAsync) {
+                await cmdRunAsync(targetDir, goal, skipVerify, model);
+            }
+            else {
+                await cmdRun(targetDir, goal, skipVerify, model);
+            }
             break;
         }
         case "verify": {
-            const rest = args.slice(1);
+            const rest = realArgs.slice(1);
             const json = rest.includes("--json");
             const dirArg = rest.find((a) => !a.startsWith("-"));
             await cmdVerify(resolve(dirArg ?? process.cwd()), json);
             break;
         }
         case "inspect": {
-            const rest = args.slice(1);
+            const rest = realArgs.slice(1);
             const json = rest.includes("--json");
             const dirArg = rest.find((a) => !a.startsWith("-"));
             await cmdInspect(resolve(dirArg ?? process.cwd()), json);
@@ -1069,51 +1519,74 @@ async function main() {
         }
         case "continue": {
             // auton continue [name] [goal...]
-            const goal = args.slice(2).filter((a) => !a.startsWith("-")).join(" ").trim() || undefined;
-            const nameArg = args[1] && !args[1].startsWith("-") ? args[1] : undefined;
+            const goal = realArgs.slice(2).filter((a) => !a.startsWith("-")).join(" ").trim() || undefined;
+            const nameArg = realArgs[1] && !realArgs[1].startsWith("-") ? realArgs[1] : undefined;
             ensureRuntimeLink(process.cwd());
             await cmdContinue(process.cwd(), nameArg, goal);
             break;
         }
         case "invoke": {
             // deploy invoke [name] [-- prompt] [--stream]
-            const rest = args.slice(2);
+            const rest = realArgs.slice(2);
             const stream = rest.includes("--stream");
             const promptIdx = rest.indexOf("--");
             const prompt = promptIdx !== -1 ? rest.slice(promptIdx + 1).join(" ") : undefined;
-            await cmdInvoke(args[1], prompt, stream);
+            await cmdInvoke(realArgs[1], prompt, stream);
             break;
         }
         case "undeploy":
-            await cmdUndeploy(args[1]);
+            await cmdUndeploy(realArgs[1]);
+            break;
+        case "wait":
+            // auton wait <task-id> [--timeout Ms]
+            if (!realArgs[1])
+                throw new ExitError(EXIT.USAGE, "uso: auton wait <task-id>");
+            await cmdWait(realArgs[1]);
+            break;
+        case "result":
+            // auton result <task-id>
+            if (!realArgs[1])
+                throw new ExitError(EXIT.USAGE, "uso: auton result <task-id>");
+            await cmdResult(realArgs[1]);
             break;
         case "approve":
         case "reject": {
-            const approved = args[0] === "approve";
+            const approved = realArgs[0] === "approve";
             // auton approve [name] [-- razão]: -- na posição [1] = sem name
-            const rest = args.slice(1);
+            const rest = realArgs.slice(1);
             const dash = rest.indexOf("--");
             const name = dash === -1 ? rest[0] : dash === 0 ? undefined : rest[0];
             const reason = dash !== -1 ? rest.slice(dash + 1).join(" ") : undefined;
             await cmdApproval(name, approved, reason);
             break;
         }
+        case "chat":
+            await cmdChat(realArgs[1]);
+            break;
+        case "answer": {
+            const rest = realArgs.slice(1);
+            const dash = rest.indexOf("--");
+            const name = dash === -1 ? rest[0] : dash === 0 ? undefined : rest[0];
+            const answer = dash !== -1 ? rest.slice(dash + 1).join(" ") : undefined;
+            await cmdAnswer(name, answer);
+            break;
+        }
         case "ps":
-            await cmdPs(args[1] === "--json");
+            await cmdPs(realArgs[1] === "--json");
             break;
         case "context":
-            await cmdContext(args[1]);
+            await cmdContext(realArgs[1]);
             break;
         case "env": {
-            const sub = args[1];
+            const sub = realArgs[1];
             if (sub === "set") {
-                await cmdEnvSet(args[2], args[3], args[4]);
+                await cmdEnvSet(realArgs[2], realArgs[3], realArgs[4]);
             }
             else if (sub === "get") {
-                await cmdEnvGet(args[2], args[3]);
+                await cmdEnvGet(realArgs[2], realArgs[3]);
             }
             else if (sub === "ls") {
-                await cmdEnvLs(args[2]);
+                await cmdEnvLs(realArgs[2]);
             }
             else {
                 console.log(USAGE);
@@ -1122,8 +1595,8 @@ async function main() {
         }
         case "init": {
             // deploy init [nome] [template] [--mode=X] [--skills=a,b] — sem argumentos (TTY): pergunta interativo
-            const initFlags = args.filter((a) => a.startsWith("--"));
-            const initPos = args.filter((a) => !a.startsWith("--"));
+            const initFlags = realArgs.filter((a) => a.startsWith("--"));
+            const initPos = realArgs.filter((a) => !a.startsWith("--"));
             const initOpts = {
                 mode: initFlags.find((f) => f.startsWith("--mode="))?.slice(7),
                 skills: initFlags
@@ -1147,10 +1620,10 @@ async function main() {
         }
         case "kv":
             // deploy kv get|set|ls <nome> [chave] [valor]
-            await cmdKv(args[1], args[2], args[3], args[4]);
+            await cmdKv(realArgs[1], realArgs[2], realArgs[3], realArgs[4]);
             break;
         default: {
-            console.error(fail(`comando desconhecido: ${args[0]}`));
+            console.error(fail(`comando desconhecido: ${realArgs[0]}`));
             console.error(USAGE);
             process.exit(EXIT.USAGE);
         }