daemora 1.0.4 → 1.0.6

package/src/channels/index.js

@@ -1,7 +1,4 @@
-// HTTP channel is intentionally commented out - it has no authentication.
-// Anyone on the network could send arbitrary tasks to the agent.
-// Uncomment only if you've added your own auth middleware.
-// import { HttpChannel } from "./HttpChannel.js";
+import { HttpChannel } from "./HttpChannel.js";
 
 // ─── Core channels ─────────────────────────────────────────────────────────────
 import { TelegramChannel } from "./TelegramChannel.js";
@@ -42,10 +39,10 @@ class ChannelRegistry {
    * Initialize and start all enabled channels.
    */
   async startAll() {
-    // ─── HTTP channel disabled (no authentication) ────────────────────────────
-    // const http = new HttpChannel(config.channels.http);
-    // this.channels.set("http", http);
-    // await http.start();
+    // ─── HTTP channel (Securely handled by Express routes in index.js) ────────
+    const http = new HttpChannel(config.channels.http);
+    this.channels.set("http", http);
+    await http.start();
     // ─────────────────────────────────────────────────────────────────────────
 
     // ── Core channels ─────────────────────────────────────────────────────────
@@ -351,11 +348,11 @@ class ChannelRegistry {
     eventBus.on("task:reply:needed", async ({ task }) => {
       const channel = this.channels.get(task.channel);
       if (!channel?.running) {
-        console.log(`[ChannelRegistry] Cannot send recovered reply — channel "${task.channel}" not running`);
+        console.log(`[ChannelRegistry] Cannot send recovered reply \u2014 channel "${task.channel}" not running`);
         return;
       }
       try {
-        const reply = task.result || "(Task completed — no output)";
+        const reply = task.result || "(Task completed \u2014 no output)";
         await channel.sendReply(task.channelMeta, reply);
         console.log(`[ChannelRegistry] Recovered reply sent via ${task.channel} for task ${task.id}`);
       } catch (e) {

package/src/cli.js

@@ -15,9 +15,10 @@ import chalk from "chalk";
 import { config } from "./config/default.js";
 import daemonManager from "./daemon/DaemonManager.js";
 import secretVault from "./safety/SecretVault.js";
-import { readFileSync, writeFileSync, existsSync } from "fs";
-import { join } from "path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
 import { execSync } from "child_process";
+import { randomBytes } from "crypto";
 
 // ── Color palette — matches Daemora UI exactly ──────────────────────────────
 const P = {
@@ -118,6 +119,10 @@ async function main() {
       await handleDoctor();
       break;
 
+    case "cleanup":
+      await handleCleanup(subcommand, rest);
+      break;
+
     case "channels":
       await handleChannels(subcommand);
       break;
@@ -130,6 +135,14 @@ async function main() {
       await handleTools(subcommand);
       break;
 
+    case "config":
+      handleConfig(subcommand, rest);
+      break;
+
+    case "auth":
+      handleAuth(subcommand);
+      break;
+
     case "setup":
       const { runSetupWizard } = await import("./setup/wizard.js");
       await runSetupWizard();
@@ -421,7 +434,7 @@ async function handleMCP(action, args) {
           }));
           if (needsEnv) {
             serverConfig.env = {};
-            p.log.info(`  Tip: use \${MY_VAR} to reference existing env vars instead of pasting secrets`);
+            pi.log.info(`  Tip: use \${MY_VAR} to reference existing env vars instead of pasting secrets`);
             let more = true;
             while (more) {
               const key = pGuard(await pi.text({
@@ -645,6 +658,132 @@ async function handleMCP(action, args) {
   }
 }
 
+// ── Config (env var management from CLI) ──────────────────────────────────────
+
+function handleConfig(action, args) {
+  const header = `\n  ${t.h("Daemora Config")}  ${t.muted("Environment variable management")}\n`;
+
+  switch (action) {
+    case "set": {
+      const [key, ...valueParts] = args;
+      const value = valueParts.join(" ");
+      if (!key || !value) {
+        console.error(`\n  ${S.cross}  Usage: daemora config set ${t.dim("<KEY> <value>")}\n`);
+        console.log(`  ${t.muted("Example:")}  daemora config set OPENAI_API_KEY sk-...\n`);
+        process.exit(1);
+      }
+      writeEnvKey(key, value);
+      process.env[key] = value;
+      console.log(`${header}  ${S.check}  ${t.success(key)} = ${t.muted(value.length <= 8 ? value : value.slice(0, 4) + "****")}\n`);
+      break;
+    }
+    case "get": {
+      const [key] = args;
+      if (!key) {
+        console.error(`\n  ${S.cross}  Usage: daemora config get ${t.dim("<KEY>")}\n`);
+        process.exit(1);
+      }
+      const env = readEnvFile();
+      const val = env[key];
+      if (val !== undefined) {
+        const masked = val.length <= 4 ? "****" : val.slice(0, 4) + "*".repeat(Math.min(val.length - 4, 20));
+        console.log(`${header}  ${key} = ${t.muted(masked)}\n`);
+      } else {
+        console.log(`${header}  ${S.cross}  ${key} is not set\n`);
+      }
+      break;
+    }
+    case "delete":
+    case "unset": {
+      const [key] = args;
+      if (!key) {
+        console.error(`\n  ${S.cross}  Usage: daemora config unset ${t.dim("<KEY>")}\n`);
+        process.exit(1);
+      }
+      deleteEnvKey(key);
+      delete process.env[key];
+      console.log(`${header}  ${S.check}  ${key} removed\n`);
+      break;
+    }
+    case "list":
+    default: {
+      const env = readEnvFile();
+      const keys = Object.keys(env);
+      console.log(header);
+      if (keys.length === 0) {
+        console.log(`  ${t.muted("No env vars configured. Run:")}  daemora config set <KEY> <value>\n`);
+      } else {
+        // Also read .env.example for available keys
+        const examplePath = join(config.rootDir, ".env.example");
+        const availableKeys = new Set();
+        if (existsSync(examplePath)) {
+          for (const line of readFileSync(examplePath, "utf-8").split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#")) continue;
+            const eqIdx = trimmed.indexOf("=");
+            if (eqIdx > 0) availableKeys.add(trimmed.slice(0, eqIdx));
+          }
+        }
+
+        // Show configured keys
+        console.log(`  ${t.muted("Configured")}  (${keys.length} keys)\n`);
+        for (const key of keys) {
+          const val = env[key];
+          const masked = !val ? t.dim("(empty)") : val.length <= 4 ? "****" : val.slice(0, 4) + "*".repeat(Math.min(val.length - 4, 16));
+          console.log(`  ${S.check}  ${t.success(key.padEnd(30))} ${t.muted(masked)}`);
+        }
+
+        // Show unconfigured keys from .env.example
+        const unconfigured = [...availableKeys].filter(k => !env[k]);
+        if (unconfigured.length > 0) {
+          console.log(`\n  ${t.muted("Available (not set)")}  (${unconfigured.length} keys)\n`);
+          for (const key of unconfigured.slice(0, 20)) {
+            console.log(`  ${S.cross}  ${t.dim(key)}`);
+          }
+          if (unconfigured.length > 20) {
+            console.log(`  ${t.dim(`... and ${unconfigured.length - 20} more`)}`);
+          }
+        }
+        console.log("");
+      }
+      break;
+    }
+  }
+}
+
+// ── Auth (API token management) ───────────────────────────────────────────────
+
+function handleAuth(action) {
+  const tokenPath = join(config.dataDir, "auth-token");
+  const header = `\n  ${t.h("Daemora Auth")}  ${t.muted("API token management")}\n`;
+
+  switch (action) {
+    case "token": {
+      if (!existsSync(tokenPath)) {
+        console.log(`${header}  ${S.cross}  No token yet. Start the server first or run: daemora auth reset\n`);
+      } else {
+        const token = readFileSync(tokenPath, "utf-8").trim();
+        console.log(`${header}  ${t.muted("API Token:")}\n\n  ${token}\n`);
+        console.log(`  ${t.muted("Usage:")}  curl -H "Authorization: Bearer ${token.slice(0, 8)}..." http://localhost:${config.port}/api/health\n`);
+      }
+      break;
+    }
+    case "reset": {
+      const token = randomBytes(32).toString("hex");
+      mkdirSync(dirname(tokenPath), { recursive: true });
+      writeFileSync(tokenPath, token, { mode: 0o600 });
+      console.log(`${header}  ${S.check}  ${t.success("New token generated")}\n\n  ${token}\n`);
+      console.log(`  ${t.muted("Restart the server for the new token to take effect.")}\n`);
+      break;
+    }
+    default: {
+      console.log(`${header}  ${t.cmd("daemora auth token")}    Show current API token`);
+      console.log(`  ${t.cmd("daemora auth reset")}    Generate a new token\n`);
+      break;
+    }
+  }
+}
+
 // ── Sandbox (filesystem scoping) helpers ──────────────────────────────────────
 
 function readEnvFile() {
@@ -1281,6 +1420,71 @@ async function handleDoctor() {
   }
 }
 
+// ─── Cleanup ──────────────────────────────────────────────────────────────────
+
+async function handleCleanup(subcommand, rest) {
+  const { runCleanup, getStorageStats } = await import("./services/cleanup.js");
+  const { readFileSync: rfs, writeFileSync: wfs, existsSync: exs } = await import("fs");
+  const { join: pjoin } = await import("path");
+
+  if (subcommand === "stats") {
+    const stats = getStorageStats();
+    console.log(`\n  ${t.h("Storage Stats")}\n`);
+    console.log(`  Tasks:    ${t.bold(stats.tasks.files)} files  (${stats.tasks.sizeKB} KB)`);
+    console.log(`  Audit:    ${t.bold(stats.audit.files)} files  (${stats.audit.sizeKB} KB)`);
+    console.log(`  Costs:    ${t.bold(stats.costs.files)} files  (${stats.costs.sizeKB} KB)`);
+    console.log(`  Sessions: ${t.bold(stats.sessions.files)} files  (${stats.sessions.sizeKB} KB)`);
+    console.log(`\n  Retention: ${stats.retentionDays === "never" ? t.dim("never delete") : t.bold(stats.retentionDays + " days")}`);
+    console.log(`  ${t.dim("Set with: daemora cleanup set <days>  (0 = never)")}\n`);
+    return;
+  }
+
+  if (subcommand === "set") {
+    const days = parseInt(rest[0], 10);
+    if (isNaN(days) || days < 0) {
+      console.log(`\n  ${S.cross}  Usage: daemora cleanup set <days>  (0 = never delete)\n`);
+      return;
+    }
+
+    // Update .env file
+    const envPath = pjoin(config.rootDir, ".env");
+    if (exs(envPath)) {
+      let env = rfs(envPath, "utf-8");
+      if (env.includes("CLEANUP_AFTER_DAYS=")) {
+        env = env.replace(/CLEANUP_AFTER_DAYS=\d*/, `CLEANUP_AFTER_DAYS=${days}`);
+      } else {
+        env = env.trimEnd() + `\n\n# === Cleanup ===\nCLEANUP_AFTER_DAYS=${days}\n`;
+      }
+      wfs(envPath, env);
+    } else {
+      wfs(envPath, `CLEANUP_AFTER_DAYS=${days}\n`);
+    }
+
+    if (days === 0) {
+      console.log(`\n  ${t.success("✔")}  Auto-cleanup ${t.bold("disabled")}. Data will be kept forever.\n`);
+    } else {
+      console.log(`\n  ${t.success("✔")}  Auto-cleanup set to ${t.bold(days + " days")}. Old data deleted on each startup.\n`);
+    }
+    return;
+  }
+
+  // Default: run cleanup now
+  const days = config.cleanupAfterDays || 30;
+  console.log(`\n  ${t.h("Cleanup")}  ${t.muted(`Deleting data older than ${days} days`)}\n`);
+
+  const result = runCleanup(days);
+
+  if (result.total === 0) {
+    console.log(`  ${t.success("✔")}  Nothing to clean up.\n`);
+  } else {
+    if (result.tasks > 0)    console.log(`  ${t.success("✔")}  Tasks:    ${result.tasks} deleted`);
+    if (result.audit > 0)    console.log(`  ${t.success("✔")}  Audit:    ${result.audit} deleted`);
+    if (result.costs > 0)    console.log(`  ${t.success("✔")}  Costs:    ${result.costs} deleted`);
+    if (result.sessions > 0) console.log(`  ${t.success("✔")}  Sessions: ${result.sessions} deleted`);
+    console.log(`\n  Total: ${t.bold(result.total)} file(s) deleted.\n`);
+  }
+}
+
 // ─── Channels ─────────────────────────────────────────────────────────────────
 
 const CHANNEL_DEFS = [
@@ -1675,60 +1879,66 @@ async function handleModels() {
     {
       name: "OpenAI", prefix: "openai", envKey: "OPENAI_API_KEY",
       models: [
-        // GPT-5 family
-        { id: "gpt-5.3-codex",              desc: "Latest coding model (2025)",                  isNew: true },
-        { id: "gpt-5.2-pro",                desc: "GPT-5.2 Pro — highest capability",            isNew: true },
-        { id: "gpt-5.2",                    desc: "GPT-5.2 flagship (Dec 2025)",                 isNew: true },
-        { id: "gpt-5.1-codex-max",          desc: "GPT-5.1 Codex Max — coding (Nov 2025)",      isNew: true },
-        { id: "gpt-5.1",                    desc: "GPT-5.1 (Nov 2025)",                         isNew: true },
-        { id: "gpt-5-pro",                  desc: "GPT-5 Pro — most powerful" },
-        { id: "gpt-5",                      desc: "GPT-5 flagship (Aug 2025)" },
-        { id: "gpt-5-mini",                 desc: "GPT-5 Mini — fast & cheap" },
-        { id: "gpt-5-nano",                 desc: "GPT-5 Nano — cheapest GPT-5" },
+        // GPT-5.4
+        { id: "gpt-5.4",                    desc: "GPT-5.4 flagship",                            price: "$2.50/$15",   isNew: true },
+        { id: "gpt-5.4-pro",                desc: "GPT-5.4 Pro — highest capability",            price: "$30/$180",    isNew: true },
+        // GPT-5.2
+        { id: "gpt-5.2",                    desc: "GPT-5.2 flagship (Dec 2025)",                 price: "$1.75/$14",   isNew: true },
+        { id: "gpt-5.2-pro",                desc: "GPT-5.2 Pro — extended reasoning",            price: "$21/$168",    isNew: true },
+        // GPT-5.1 / 5
+        { id: "gpt-5.1",                    desc: "GPT-5.1 (Nov 2025)",                          price: "$1.25/$10",   isNew: true },
+        { id: "gpt-5",                      desc: "GPT-5 flagship (Aug 2025)",                   price: "$1.25/$10" },
+        { id: "gpt-5-pro",                  desc: "GPT-5 Pro — most powerful",                   price: "$15/$120" },
+        { id: "gpt-5-mini",                 desc: "GPT-5 Mini — fast & cheap",                   price: "$0.25/$2" },
+        { id: "gpt-5-nano",                 desc: "GPT-5 Nano — cheapest GPT-5",                 price: "$0.05/$0.40" },
+        // Codex
+        { id: "gpt-5.3-codex",              desc: "Latest coding model (2025)",                  price: "$1.75/$14",   isNew: true },
+        { id: "gpt-5.1-codex",              desc: "GPT-5.1 Codex — coding",                     price: "$1.25/$10",   isNew: true },
+        { id: "gpt-5-codex",                desc: "GPT-5 Codex — coding",                       price: "$1.25/$10" },
         // o-series reasoning
-        { id: "o3-pro",                     desc: "Best reasoning — most thorough" },
-        { id: "o3-deep-research",           desc: "Deep research with web browsing" },
-        { id: "o4-mini-deep-research",      desc: "Fast deep research" },
-        { id: "o3",                         desc: "Advanced reasoning (Apr 2025)" },
-        { id: "o4-mini",                    desc: "Fast reasoning (Apr 2025)" },
-        { id: "o1-pro",                     desc: "o1 Pro — powerful reasoning (Mar 2025)" },
-        { id: "o1",                         desc: "o1 reasoning model" },
-        { id: "o3-mini",                    desc: "Lightweight reasoning" },
+        { id: "o3-pro",                     desc: "Best reasoning — most thorough",              price: "$20/$80" },
+        { id: "o3",                         desc: "Advanced reasoning (Apr 2025)",               price: "$2/$8" },
+        { id: "o4-mini",                    desc: "Fast reasoning (Apr 2025)",                   price: "$1.10/$4.40" },
+        { id: "o1-pro",                     desc: "o1 Pro — powerful reasoning",                 price: "$150/$600" },
+        { id: "o1",                         desc: "o1 reasoning model",                          price: "$15/$60" },
+        { id: "o3-mini",                    desc: "Lightweight reasoning",                       price: "$1.10/$4.40" },
         // GPT-4.1 (1M context)
-        { id: "gpt-4.1",                    desc: "1M context, best instruction following" },
-        { id: "gpt-4.1-mini",               desc: "1M context, fast & affordable (default)" },
-        { id: "gpt-4.1-nano",               desc: "1M context, fastest & cheapest" },
+        { id: "gpt-4.1",                    desc: "1M context, best instruction following",      price: "$2/$8" },
+        { id: "gpt-4.1-mini",               desc: "1M context, fast & affordable (default)",     price: "$0.40/$1.60" },
+        { id: "gpt-4.1-nano",               desc: "1M context, fastest & cheapest",              price: "$0.10/$0.40" },
         // GPT-4o & specialized
-        { id: "gpt-4o",                     desc: "Vision + text (128K ctx)" },
-        { id: "gpt-4o-mini",                desc: "GPT-4o Mini (128K ctx)" },
-        { id: "computer-use-preview",       desc: "Computer use / GUI automation" },
-        { id: "gpt-4o-search-preview",      desc: "Built-in live web search" },
-        { id: "gpt-image-1",                desc: "Image generation (native API)" },
+        { id: "gpt-4o",                     desc: "Vision + text (128K ctx)",                    price: "$2.50/$10" },
+        { id: "gpt-4o-mini",                desc: "GPT-4o Mini (128K ctx)",                      price: "$0.15/$0.60" },
+        { id: "computer-use-preview",       desc: "Computer use / GUI automation",               price: "$3/$12" },
       ],
     },
     {
       name: "Anthropic", prefix: "anthropic", envKey: "ANTHROPIC_API_KEY",
       models: [
-        { id: "claude-opus-4-6",            desc: "Most intelligent — complex reasoning + extended thinking", isNew: true },
-        { id: "claude-sonnet-4-6",          desc: "Best speed/intelligence — daily coding & agents",         isNew: true },
-        { id: "claude-haiku-4-5",           desc: "Fastest — high-volume, cost-sensitive tasks" },
-        { id: "claude-opus-4-5-20251101",   desc: "Opus 4.5 — complex multi-step tasks (Nov 2025)" },
-        { id: "claude-sonnet-4-5-20250929", desc: "Sonnet 4.5 — coding & agentic tasks (200K ctx)" },
-        { id: "claude-opus-4-1-20250805",   desc: "Opus 4.1 — long-duration complex tasks" },
-        { id: "claude-3-5-sonnet-latest",   desc: "3.5 Sonnet — previous gen, widely used" },
-        { id: "claude-3-5-haiku-latest",    desc: "3.5 Haiku — fast previous gen" },
+        { id: "claude-opus-4-6",            desc: "Most intelligent — complex reasoning",        price: "$5/$25",      isNew: true },
+        { id: "claude-opus-4-5",            desc: "Opus 4.5 — complex multi-step tasks",         price: "$5/$25",      isNew: true },
+        { id: "claude-opus-4-1",            desc: "Opus 4.1 — long-duration complex tasks",      price: "$15/$75" },
+        { id: "claude-opus-4",              desc: "Opus 4 — extended thinking",                  price: "$15/$75" },
+        { id: "claude-sonnet-4-6",          desc: "Best speed/intelligence — coding & agents",   price: "$3/$15",      isNew: true },
+        { id: "claude-sonnet-4-5",          desc: "Sonnet 4.5 — coding & agentic tasks",         price: "$3/$15" },
+        { id: "claude-sonnet-4",            desc: "Sonnet 4 — balanced performance",             price: "$3/$15" },
+        { id: "claude-haiku-4-5",           desc: "Fastest — high-volume, cost-sensitive",       price: "$1/$5" },
+        { id: "claude-haiku-3-5",           desc: "3.5 Haiku — fast previous gen",               price: "$0.80/$4" },
+        { id: "claude-haiku-3",             desc: "Haiku 3 — cheapest Claude",                   price: "$0.25/$1.25" },
       ],
     },
     {
       name: "Google", prefix: "google", envKey: "GOOGLE_AI_API_KEY",
       models: [
-        { id: "gemini-3.1-pro-preview",             desc: "Latest — complex tasks, advanced reasoning",    isNew: true },
-        { id: "gemini-3.1-flash-lite-preview",      desc: "Latest — cost-efficient & fast",               isNew: true },
-        { id: "gemini-2.5-pro",                     desc: "GA — complex reasoning & coding (1M ctx)" },
-        { id: "gemini-2.5-flash",                   desc: "Fast & cost-effective for high-volume tasks" },
-        { id: "gemini-2.5-flash-lite",              desc: "Speed-optimised for high-throughput" },
-        { id: "gemini-live-2.5-flash-native-audio", desc: "Real-time bidirectional audio/video agents" },
-        { id: "gemini-2.0-flash",                   desc: "Previous gen flash" },
+        { id: "gemini-3.1-pro-preview",          desc: "Latest — complex tasks, reasoning",      price: "$2/$12",      isNew: true },
+        { id: "gemini-3.1-flash-lite-preview",    desc: "Latest — cost-efficient & fast",         price: "$0.25/$1.50", isNew: true },
+        { id: "gemini-3-pro-preview",             desc: "Gemini 3 Pro — advanced reasoning",      price: "$2/$12",      isNew: true },
+        { id: "gemini-3-flash-preview",           desc: "Gemini 3 Flash — fast & cheap",          price: "$0.50/$3",    isNew: true },
+        { id: "gemini-2.5-pro",                   desc: "GA — complex reasoning & coding (1M)",   price: "$1.25/$10" },
+        { id: "gemini-2.5-flash",                 desc: "Fast & cost-effective for high-volume",  price: "$0.30/$2.50" },
+        { id: "gemini-2.5-flash-lite",            desc: "Speed-optimised for high-throughput",    price: "$0.10/$0.40" },
+        { id: "gemini-2.0-flash",                 desc: "Previous gen flash",                     price: "$0.15/$0.60" },
+        { id: "gemini-2.0-flash-lite",            desc: "Cheapest Gemini",                        price: "$0.075/$0.30" },
       ],
     },
     {
@@ -1758,14 +1968,14 @@ async function handleModels() {
     {
       name: "Ollama (local)", prefix: "ollama", configured: true,
       models: [
-        { id: "llama4-maverick", desc: "Llama 4 Maverick — 17B MoE, 1M ctx, multimodal", isNew: true },
-        { id: "llama4-scout",    desc: "Llama 4 Scout — 17B MoE, 10M ctx",               isNew: true },
-        { id: "llama3.3",        desc: "Llama 3.3 70B — best open model (Dec 2024)" },
-        { id: "qwen2.5",         desc: "Qwen 2.5 72B — strong coder" },
-        { id: "deepseek-r1",     desc: "DeepSeek-R1 local — reasoning" },
-        { id: "mistral",         desc: "Mistral 7B — fast small model" },
-        { id: "phi4",            desc: "Phi-4 14B — Microsoft small model" },
-        { id: "codellama",       desc: "CodeLlama — code specialised" },
+        { id: "llama4-maverick", desc: "Llama 4 Maverick — 17B MoE, 1M ctx, multimodal", price: "free", isNew: true },
+        { id: "llama4-scout",    desc: "Llama 4 Scout — 17B MoE, 10M ctx",               price: "free", isNew: true },
+        { id: "llama3.3",        desc: "Llama 3.3 70B — best open model (Dec 2024)",      price: "free" },
+        { id: "qwen2.5",         desc: "Qwen 2.5 72B — strong coder",                    price: "free" },
+        { id: "deepseek-r1",     desc: "DeepSeek-R1 local — reasoning",                  price: "free" },
+        { id: "mistral",         desc: "Mistral 7B — fast small model",                   price: "free" },
+        { id: "phi4",            desc: "Phi-4 14B — Microsoft small model",               price: "free" },
+        { id: "codellama",       desc: "CodeLlama — code specialised",                    price: "free" },
       ],
     },
   ];
@@ -1792,7 +2002,8 @@ async function handleModels() {
     for (const m of prov.models) {
       const fullId  = `${prov.prefix}:${m.id}`;
       const newBadge = m.isNew ? chalk.hex(P.amber)(" [NEW]") : "";
-      console.log(`  ${S.dot}  ${chalk.hex(P.teal)(fullId.padEnd(50))}${newBadge}`);
+      const priceTag = m.price ? chalk.hex(P.muted)(` ${m.price} /MTok`) : "";
+      console.log(`  ${S.dot}  ${chalk.hex(P.teal)(fullId.padEnd(44))}${priceTag}${newBadge}`);
       console.log(`       ${chalk.hex(P.dim)(m.desc)}`);
     }
   }
@@ -1984,6 +2195,15 @@ ${line}
   ${t.cmd("start")}                            Start the agent server
   ${t.cmd("setup")}                            Interactive setup wizard
 
+  ${t.cmd("auth token")}                        Show API auth token
+  ${t.cmd("auth reset")}                        Generate a new auth token
+
+  ${t.cmd("config list")}                      List all configured env vars
+  ${t.cmd("config set")} ${t.dim("<KEY> <value>")}          Set an env var (e.g. OPENAI_API_KEY)
+  ${t.cmd("config get")} ${t.dim("<KEY>")}                  Show an env var (masked)
+  ${t.cmd("config unset")} ${t.dim("<KEY>")}                Remove an env var
+  ${t.dim("  Keys: DEFAULT_MODEL, SUB_AGENT_MODEL, CODE_MODEL, RESEARCH_MODEL ...")}
+
   ${t.cmd("daemon install")}                   Install as OS service (auto-start)
   ${t.cmd("daemon uninstall")}                 Remove OS service
   ${t.cmd("daemon start")}                     Start the background daemon
@@ -2036,6 +2256,9 @@ ${line}
   ${t.cmd("tools")} ${t.dim("[filter]")}                    List all 50 built-in tools (filter by name/category)
 
   ${t.cmd("doctor")}                           Security audit - check for misconfigurations
+  ${t.cmd("cleanup")}                          Delete old tasks, logs, and sessions
+  ${t.cmd("cleanup set")} ${t.dim("<days>")}             Set auto-cleanup retention (0 = never)
+  ${t.cmd("cleanup stats")}                    Show storage usage per directory
 
   ${t.cmd("help")}                             Show this help
 
@@ -2053,8 +2276,11 @@ ${line}
   ${t.dim("$")} daemora mcp list
   ${t.dim("$")} daemora mcp add github npx -y @modelcontextprotocol/server-github
   ${t.dim("$")} daemora mcp env github GITHUB_PERSONAL_ACCESS_TOKEN ghp_...
-  ${t.dim("$")} daemora mcp add notion http://localhost:3100/mcp
-  ${t.dim("$")} daemora mcp add myserver http://localhost:3100/sse --sse
+  ${t.dim("$")} daemora mcp env notion NOTION_TOKEN ntn_...
+  ${t.dim("$")} daemora mcp env stripe STRIPE_SECRET_KEY sk_live_...
+  ${t.dim("$")} daemora mcp enable notion
+  ${t.dim("$")} daemora mcp add myserver https://api.example.com/mcp
+  ${t.dim("$")} daemora mcp add mysse https://api.example.com/sse --sse
   ${t.dim("$")} daemora mcp remove github
   ${t.dim("$")} daemora mcp add                   (interactive - prompts for everything)
   ${t.dim("$")} daemora mcp reload github         (reconnects live if agent running)

package/src/config/agentProfiles.js

@@ -114,6 +114,7 @@ export const defaultSubAgentTools = [
   "searchMemory", "pruneMemory", "listMemoryCategories",
   // Project tracking
   "projectTracker",
+  "taskManager",
   // MCP (via specialist agent - no direct mcp__ tools)
   "manageMCP",
   "useMCP",

package/src/config/default.js

@@ -28,12 +28,23 @@ export const config = {
   memoryPath: join(ROOT_DIR, "MEMORY.md"),
 
   // Default model (provider:model format)
-  defaultModel: process.env.DEFAULT_MODEL || "openai:gpt-4.1-mini",
+  defaultModel: process.env.DEFAULT_MODEL || "openai:gpt-5.1-mini",
+
+  // Sub-agent model — used for all sub-agents when no profile-specific model is set.
+  // Falls between profile routing (CODE_MODEL etc.) and DEFAULT_MODEL in priority.
+  subAgentModel: process.env.SUB_AGENT_MODEL || null,
 
   // Agent loop
   maxLoops: 40,
   maxSubAgentDepth: 3,
 
+  // Thinking level: "auto" | "off" | "minimal" | "low" | "medium" | "high" | "xhigh"
+  thinkingLevel: process.env.THINKING_LEVEL || "auto",
+
+  // Message queue mode: "steer" (inject into live loop) | "collect" (batch into follow-up) | "followup" (queue as separate)
+  queueMode: process.env.QUEUE_MODE || "steer",
+  debounceMs: parseInt(process.env.DEBOUNCE_MS || "1500", 10),
+
   // Safety
   permissionTier: process.env.PERMISSION_TIER || "standard",
 
@@ -41,6 +52,9 @@ export const config = {
   maxCostPerTask: parseFloat(process.env.MAX_COST_PER_TASK || "0.50"),
   maxDailyCost: parseFloat(process.env.MAX_DAILY_COST || "10.00"),
 
+  // Cleanup
+  cleanupAfterDays: parseInt(process.env.CLEANUP_AFTER_DAYS || "30", 10), // 0 = never
+
   // Daemon
   daemonMode: process.env.DAEMON_MODE === "true",
   heartbeatIntervalMinutes: parseInt(process.env.HEARTBEAT_INTERVAL_MINUTES || "30", 10),