@autonsh/cli 0.17.1 → 0.18.0

package/dist/index.js

@@ -19,7 +19,9 @@ 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 { promptInit, promptConfirmUndeploy, promptGateApproval, promptGateQuestion, parseGateLine, listTemplatesForDisplay, } from "./prompts.js";
+import { getTemplateRegistry } from "./template-registry.js";
+import { renderTemplate } from "./template-engine.js";
 import { loadTaskManifest, MODES, SKILLS, EXIT, ExitError, } from "./task.js";
 import { runVerify } from "./verify.js";
 const SRC = dirname(fileURLToPath(import.meta.url));
@@ -49,8 +51,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",
@@ -109,62 +111,185 @@ async function installRuntime(dir) {
         bar.stop();
     }
 }
-async function cmdInit(name, template, opts = {}) {
+async function cmdInit(name, templateId, opts = {}) {
+    const registry = await getTemplateRegistry();
+    const template = await registry.get(templateId);
+    if (!template) {
+        throw new ExitError(EXIT.USAGE, `template não encontrado: ${templateId}. Rode 'auton template list' para ver disponíveis.`);
+    }
     const plain = name === "." ? basename(process.cwd()) : name;
     const dir = resolve(name === "." ? process.cwd() : join(process.cwd(), name));
     if (existsSync(dir) && readdirSync(dir).length > 0) {
         throw new ExitError(EXIT.USAGE, `diretório não vazio: ${dir}`);
     }
+    // Prepara contexto de renderização
+    const context = {
+        name: plain,
+        ...opts.variables,
+    };
+    if (opts.dryRun) {
+        console.log(info(`[dry-run] Scaffold seria criado em: ${dir}`));
+        console.log(info(`[dry-run] Template: ${template.name} (${template.id})`));
+        console.log(info(`[dry-run] Variáveis: ${JSON.stringify(context, null, 2)}`));
+        return;
+    }
     mkdirSync(dir, { recursive: true });
-    cpSync(join(TEMPLATES_SRC, template), dir, { recursive: true });
-    // seta o nome real no manifest (task.yaml desde 0.9.1)
+    // Renderiza template via engine (Handlebars)
+    const result = await renderTemplate(template, context, dir);
+    // Substitui name no task.yaml (backward compat: templates built-in têm name hardcoded)
     const yamlPath = join(dir, "task.yaml");
-    const yaml = (await readFile(yamlPath, "utf8")).replace(/^name: .*$/m, `name: ${plain}`);
-    await writeFile(yamlPath, yaml);
-    // mode (pivô 0.11): permissões do worker; docs do modo viram agent.md do projeto.
+    if (existsSync(yamlPath)) {
+        let yaml = await readFile(yamlPath, "utf8");
+        yaml = yaml.replace(/^name: .*$/m, `name: ${plain}`);
+        await writeFile(yamlPath, yaml);
+    }
+    // Garante package.json (pode vir do template ou ser gerado)
+    const pkgPath = join(dir, "package.json");
+    if (!existsSync(pkgPath)) {
+        const pkgName = plain.toLowerCase().replace(/[^a-z0-9._-]/g, "-");
+        await writeFile(pkgPath, JSON.stringify({
+            name: pkgName || "agent",
+            version: "0.0.0",
+            private: true,
+            type: "module",
+            dependencies: { "@autonsh/runtime": "^0.11.0" },
+        }, null, 2) + "\n");
+    }
+    // Genesis custom (se fornecido via --genesis ou prompt)
+    if (opts.genesis) {
+        const yamlPath = join(dir, "task.yaml");
+        let yaml = await readFile(yamlPath, "utf8");
+        // Substitui ou adiciona bloco genesis
+        if (yaml.includes("genesis:")) {
+            yaml = yaml.replace(/^genesis:[\s\S]*?(?=\n\S|\n*$)/m, `genesis: |\n  ${opts.genesis.replace(/\n/g, "\n  ")}\n`);
+        }
+        else {
+            yaml += `\ngenesis: |\n  ${opts.genesis.replace(/\n/g, "\n  ")}\n`;
+        }
+        await writeFile(yamlPath, yaml);
+    }
+    // Mode + skills do template (podem ser sobrescritos por opts)
     const mode = opts.mode && MODES.includes(opts.mode)
         ? opts.mode
-        : "build";
+        : template.defaultMode;
+    const skills = (opts.skills ?? template.skills).filter((s) => SKILLS.includes(s));
+    // Atualiza task.yaml com mode/skills apenas se override explícito
+    if (opts.mode || opts.skills) {
+        const yamlPath2 = join(dir, "task.yaml");
+        let yaml = await readFile(yamlPath2, "utf8");
+        yaml = yaml
+            .split("\n")
+            .filter((line) => !/^(mode|skills):/m.test(line) && !/^\s*-\s/.test(line))
+            .join("\n")
+            .trimEnd()
+            .concat("\n", `mode: ${mode}`, skills.length > 0
+            ? `\nskills:\n${skills.map((s) => `  - ${s}`).join("\n")}`
+            : "")
+            .concat("\n");
+        await writeFile(yamlPath2, yaml);
+    }
+    // Copia agent.md do modo se não existir
     const modeDoc = join(TEMPLATES_SRC, "modes", mode, "agent.md");
-    if (existsSync(modeDoc)) {
+    if (existsSync(modeDoc) && !existsSync(join(dir, "agent.md"))) {
         cpSync(modeDoc, join(dir, "agent.md"));
     }
-    const skills = (opts.skills ?? []).filter((s) => SKILLS.includes(s));
+    // Skills built-in
     for (const s of skills) {
-        cpSync(join(TEMPLATES_SRC, "skills", s, "SKILL.md"), join(dir, "skills", s, "SKILL.md"), {
-            recursive: true,
-        });
+        try {
+            cpSync(join(TEMPLATES_SRC, "skills", s, "SKILL.md"), join(dir, "skills", s, "SKILL.md"), {
+                recursive: true,
+            });
+        }
+        catch {
+            // skill não existe — ignora
+        }
     }
-    await writeFile(yamlPath, yaml
-        .split("\n")
-        .filter((line) => !/^(mode|skills):/m.test(line))
-        .join("\n")
-        .trimEnd()
-        .concat("\n", `mode: ${mode}`, skills.length > 0
-        ? `\nskills:\n${skills.map((s) => `  - ${s}`).join("\n")}`
-        : "")
-        .concat("\n"));
-    // package.json do projeto (0.0.7): remove o passo manual de criar pacote.
-    // `npm install` abaixo salva/adiciona a dep se preciso; aqui o pacote já existe.
-    const pkgName = plain.toLowerCase().replace(/[^a-z0-9._-]/g, "-");
-    await writeFile(join(dir, "package.json"), JSON.stringify({
-        name: pkgName || "agent",
-        version: "0.0.0",
-        private: true,
-        type: "module",
-        dependencies: { "@autonsh/runtime": "^0.11.0" },
-    }, null, 2) + "\n");
     ensureRuntimeLink(dir);
     if (!HAS_LOCAL_RUNTIME) {
         await installRuntime(dir);
     }
     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(ok(`${plain} (template: ${template.name}) em ${dim(dir)}`));
+    console.log(info(`próximo: ${bold(`cd ${plain} && auton run "<objetivo>"`)}`));
+    // Deploy opcional
+    if (opts.deploy) {
+        console.log(info(`deployando ${bold(plain)}...`));
+        await cmdDeploy(dir);
+        console.log(ok(`${plain} deployado`));
+    }
 }
 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;
@@ -192,51 +317,59 @@ Usage:
 
 Modelos:
   auton model                       Seletor interativo do modelo default
-                                     (local ollama + providers configurados)
+                                      (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)
+                                      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.
+                                      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)
+                                      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)
+                                      Roda 1 turno (legado v0)
   auton approve|reject [name] [-- razão]
-                                    Decide o gate de aprovação
+                                      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]
-                                    Roda a task do diretório atual
-  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|...)
+  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] [--mode=X] [--skills=a,b] [--deploy] [--dry-run] [--genesis] [--var key=value]
+                                      Scaffold de task (templates built-in + custom)
+
+Templates:
+  auton template list [--json]        Lista templates (built-in + custom)
+  auton template create <id>          Cria template custom (futuro)
 
 Infra:
   auton kv get|set|ls [name] [key] [value]
-                                    Inspeciona o storage KV
+                                      Inspeciona o storage KV
   auton env set|get|ls [name] [key] [value]
-                                    Env vars por agente
+                                      Env vars por agente
 
 Options:
   --help, -h                 Mostra ajuda
   --version, -v              Mostra versão + modelo default
   AUTON_API=http://...       Base do control plane (default localhost:8080)
+  --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
@@ -480,6 +613,153 @@ async function cmdRun(dir, goalArg, skipVerify, 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) {
@@ -1072,35 +1352,108 @@ 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(providerId) {
     await logoutCmd(providerId);
 }
+/** Project mode: `auton` bare — se não há agente, cria + deploya + entra no chat. */
+async function cmdProject() {
+    // 1. Tenta achar agente no cwd (task.yaml)
+    let agentName;
+    try {
+        const { loadTaskManifest } = await import("./task.js");
+        const manifest = await loadTaskManifest(process.cwd());
+        if (manifest?.name)
+            agentName = manifest.name;
+    }
+    catch {
+        // sem task.yaml
+    }
+    // 2. Se não há no cwd, tenta deployed agents
+    if (!agentName) {
+        const deployed = await listAgentNames();
+        if (deployed.length === 1) {
+            agentName = deployed[0];
+        }
+        else if (deployed.length > 1) {
+            // Múltiplos deployados — usa picker (cmdChat já faz isso)
+            await cmdChat(undefined);
+            return;
+        }
+    }
+    // 3. Tem agente (cwd ou único deployado) → entra no chat
+    if (agentName) {
+        console.log(info(`entrando no agente ${bold(agentName)}...`));
+        await cmdChat(agentName);
+        return;
+    }
+    // 4. Nenhum agente — oferece init interativo
+    console.log(box("auton — nenhum agente encontrado", [
+        "Este diretório não tem task.yaml e não há agentes deployados.",
+        "Quer criar um novo agente aqui?",
+    ]));
+    const { confirm } = await import("@clack/prompts");
+    const create = await confirm({
+        message: "criar novo agente neste diretório?",
+        active: "sim",
+        inactive: "não",
+    });
+    if (!create) {
+        console.log(dim("até logo."));
+        return;
+    }
+    // Init interativo
+    const { promptInit } = await import("./prompts.js");
+    const p = await promptInit();
+    // Deploy automático
+    console.log(info(`criando e deployando ${bold(p.name)}...`));
+    await cmdInit(p.name, p.templateId, {
+        mode: p.mode,
+        skills: p.skills,
+        genesis: p.genesis,
+        deploy: true,
+        dryRun: false,
+        variables: p.variables,
+    });
+    // Entra no chat
+    console.log(info(`entrando no agente ${bold(p.name)}...`));
+    await cmdChat(p.name);
+}
 async function main() {
-    const args = process.argv.slice(2);
-    if (args.length === 0) {
+    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.
+        // NOVO: project mode — se não há agente, oferece init + deploy + chat
         if (isTTY) {
-            await cmdChat(undefined);
+            await cmdProject();
             return;
         }
         console.log(USAGE);
         return;
     }
-    if (args[0] === "--help" || args[0] === "-h") {
+    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}`));
@@ -1116,33 +1469,34 @@ async function main() {
     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",
+        "ps", "context", "env", "init", "kv", "chat", "answer", "wait", "result",
+        "template",
     ]);
-    if (!KNOWN.has(args[0]) && isTTY) {
+    if (!KNOWN.has(realArgs[0]) && isTTY) {
         const deployed = await listAgentNames();
-        if (deployed.includes(args[0])) {
-            await cmdChat(args[0]);
+        if (deployed.includes(realArgs[0])) {
+            await cmdChat(realArgs[0]);
             return;
         }
     }
-    switch (args[0]) {
+    switch (realArgs[0]) {
         case "login":
-            await cmdLogin(args.slice(1));
+            await cmdLogin(realArgs.slice(1));
             break;
         case "logout":
-            await cmdLogout(args[1]);
+            await cmdLogout(realArgs[1]);
             break;
         case "model": {
             // auton model [ls|set <spec>|test] — sem sub: seletor TTY
-            const sub = args[1];
-            const json = args.includes("--json");
+            const sub = realArgs[1];
+            const json = realArgs.includes("--json");
             if (sub === "ls") {
                 await modelLs(json);
             }
             else if (sub === "set") {
-                if (!args[2])
+                if (!realArgs[2])
                     throw new ExitError(EXIT.USAGE, "uso: auton model set <provider:modelo>");
-                await modelSet(args[2]);
+                await modelSet(realArgs[2]);
             }
             else if (sub === "test") {
                 await modelTest();
@@ -1156,8 +1510,8 @@ async function main() {
             break;
         }
         case "agent":
-            if (args[1]) {
-                const dir = resolve(args[1]);
+            if (realArgs[1]) {
+                const dir = resolve(realArgs[1]);
                 ensureRuntimeLink(dir);
                 await cmdDeploy(dir);
             }
@@ -1167,8 +1521,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;
@@ -1200,34 +1554,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);
@@ -1235,29 +1645,41 @@ 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;
@@ -1265,10 +1687,10 @@ async function main() {
             break;
         }
         case "chat":
-            await cmdChat(args[1]);
+            await cmdChat(realArgs[1]);
             break;
         case "answer": {
-            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 answer = dash !== -1 ? rest.slice(dash + 1).join(" ") : undefined;
@@ -1276,21 +1698,21 @@ async function main() {
             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);
@@ -1298,36 +1720,97 @@ async function main() {
             break;
         }
         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 initOpts = {
-                mode: initFlags.find((f) => f.startsWith("--mode="))?.slice(7),
-                skills: initFlags
-                    .find((f) => f.startsWith("--skills="))
-                    ?.slice(9)
-                    .split(",")
-                    .filter(Boolean),
-            };
+            // auton init [nome] [template] [--mode=X] [--skills=a,b] [--deploy] [--dry-run] [--genesis] [--var key=value]
+            const initFlags = realArgs.filter((a) => a.startsWith("--"));
+            const initPos = realArgs.filter((a) => !a.startsWith("--"));
+            // Parse flags
+            const deploy = initFlags.includes("--deploy");
+            const dryRun = initFlags.includes("--dry-run");
+            const mode = initFlags.find((f) => f.startsWith("--mode="))?.slice(7);
+            const skills = initFlags
+                .find((f) => f.startsWith("--skills="))
+                ?.slice(9)
+                .split(",")
+                .filter(Boolean);
+            const genesis = initFlags.find((f) => f.startsWith("--genesis="))?.slice(10);
+            // Parse --var key=value
+            const variables = {};
+            for (const f of initFlags) {
+                if (f.startsWith("--var=")) {
+                    const rest = f.slice(6); // remove "--var="
+                    const eqIdx = rest.indexOf("=");
+                    if (eqIdx > 0) {
+                        const key = rest.slice(0, eqIdx);
+                        const val = rest.slice(eqIdx + 1);
+                        variables[key] = val === "true" ? true : val === "false" ? false : val;
+                    }
+                }
+            }
             if (isTTY && !initPos[1] && !initPos[2]) {
                 const p = await promptInit();
-                await cmdInit(p.name, p.template, initOpts);
+                await cmdInit(p.name, p.templateId, {
+                    mode: p.mode ?? mode,
+                    skills: p.skills ?? skills,
+                    genesis: p.genesis ?? genesis,
+                    deploy,
+                    dryRun,
+                    variables,
+                });
             }
             else {
-                const tpl = (initPos[2] ?? "support");
-                if (!TEMPLATES.includes(tpl)) {
-                    throw new ExitError(EXIT.USAGE, `template desconhecido: ${tpl} (disponíveis: ${TEMPLATES.join(", ")})`);
+                const name = initPos[1] ?? ".";
+                const templateId = initPos[2];
+                if (!templateId) {
+                    throw new ExitError(EXIT.USAGE, "uso: auton init <nome> <template-id> [--deploy] [--dry-run] ...");
+                }
+                // Valida template existe
+                const registry = await getTemplateRegistry();
+                const tpl = await registry.get(templateId);
+                if (!tpl) {
+                    const list = await listTemplatesForDisplay();
+                    throw new ExitError(EXIT.USAGE, `template desconhecido: ${templateId}\nDisponíveis: ${list.map(t => `${t.id} (${t.category})`).join(", ")}`);
+                }
+                await cmdInit(name, templateId, {
+                    mode,
+                    skills,
+                    genesis,
+                    deploy,
+                    dryRun,
+                    variables,
+                });
+            }
+            break;
+        }
+        case "template": {
+            const sub = realArgs[1];
+            if (sub === "list" || sub === "ls" || !sub) {
+                const list = await listTemplatesForDisplay();
+                if (realArgs.includes("--json")) {
+                    console.log(JSON.stringify(list, null, 2));
+                }
+                else {
+                    console.log(bold("Templates disponíveis:"));
+                    for (const t of list) {
+                        const srcTag = t.source === "custom" ? pc.cyan("(custom)") : pc.dim("(builtin)");
+                        console.log(`  ${bold(t.id)} ${srcTag} — ${t.name} [${t.category}]`);
+                        console.log(`    ${dim(t.description)}`);
+                    }
                 }
-                await cmdInit(initPos[1] ?? ".", tpl, initOpts);
+            }
+            else if (sub === "create") {
+                console.log(info("Use 'auton init' com template custom — criação de template virá em versão futura"));
+            }
+            else {
+                console.log(USAGE);
             }
             break;
         }
         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);
         }