aether-code 0.36.8 → 0.37.0

package/bin/aether-code.js

@@ -27,8 +27,9 @@ import {
 } from "../src/mcp-registry.js";
 import readline from "node:readline";
 import { c, errorLine, divider, setTerminalTitle } from "../src/render.js";
+import { getVersion } from "../src/version.js";
 
-const VERSION = "0.32.0";
+const VERSION = getVersion();
 
 /**
  * Try to start MCP servers from ~/.aether/mcp.json. Returns a started
@@ -315,13 +316,10 @@ async function handleBalance() {
     const me = await fetchBalance();
     console.log(c.bold(c.magenta("Aether")));
     console.log(c.gray("─".repeat(50)));
-    console.log(`Plan      ${c.cyan(me.plan)}${me.role !== "USER" ? c.gray(` · ${me.role}`) : ""}`);
+    console.log(`Plan      ${c.cyan(me.plan)}`);
     console.log(`Balance   ${c.bold(me.balance.toLocaleString())} credits`);
     console.log(`  plan    ${me.planCredits.toLocaleString()}`);
     console.log(`  topup   ${me.topupCredits.toLocaleString()}`);
-    if (me.rate) {
-      console.log(`Rate      ${me.rate.used}/${me.rate.limit} this hour${me.rate.resetIn ? ` · resets in ${me.rate.resetIn}s` : ""}`);
-    }
     if (me.isSuspended) console.log(c.red("\n⚠ Account is suspended."));
   } catch (err) {
     if (err instanceof AetherError && err.code === "NO_API_KEY") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aether-code",
-  "version": "0.36.8",
+  "version": "0.37.0",
   "description": "Uncensored AI coding agent for your terminal — Claude Code alternative with MCP support. Reads code, writes files, runs commands. Drives IDA Pro, Roblox Studio, Wireshark, Blender, and any MCP server. No refusal layer.",
   "homepage": "https://trynoguard.com",
   "repository": {
@@ -23,7 +23,7 @@
     "node": ">=18"
   },
   "scripts": {
-    "lint": "node --check bin/aether-code.js src/agent.js src/api.js src/config.js src/render.js src/tools.js src/diff.js src/repl.js src/mcp.js src/mcp-cli.js src/mcp-registry.js src/skills.js src/update-check.js src/ink-input.js",
+    "lint": "node --check bin/aether-code.js src/agent.js src/api.js src/config.js src/render.js src/tools.js src/diff.js src/repl.js src/mcp.js src/mcp-cli.js src/mcp-registry.js src/skills.js src/update-check.js src/ink-input.js src/version.js src/sessions.js src/project-context.js",
     "test": "node --test \"test/**/*.test.js\"",
     "prepublishOnly": "npm run lint && npm test"
   },

package/src/agent.js

@@ -8,27 +8,31 @@ import { agentTurnStream, AetherError } from "./api.js";
 import { TOOL_DEFINITIONS, executeTool } from "./tools.js";
 import { unnamespaceToolName } from "./mcp.js";
 import { loadAllSkills, selectSkills, renderSkillsBlock } from "./skills.js";
+import { scanProject } from "./project-context.js";
 import { c, divider, turn, toolLabel, toolSummary, makeTokenStripper, errorLine, startSpinner } from "./render.js";
 
 const DEFAULT_MAX_TURNS = 25;
 
-// Environment block prepended to the first user message so the model can
-// resolve named locations to real absolute paths.
-function envContext(cwd) {
+export const MOD_RE =
+  /\b(refactor|fix|add|adds?|change|update|implement|creat|writ|remov|delet|rename|extract|move|replace|build|generate|insert|append|convert|migrat|wire|hook|edit|modif|patch|integrat)/i;
+
+export function envContext(cwd) {
   const home = os.homedir();
   const desktop = path.join(home, "Desktop");
   const documents = path.join(home, "Documents");
   const win = process.platform === "win32";
-  // OS-specific shell guidance: gemma tends to emit Unix commands (mkdir -p,
-  // touch, &&-chains) which FAIL in Windows cmd.exe ("The syntax of the command
-  // is incorrect"). Steer it to the file tools (which are cross-platform and
-  // auto-create parent dirs) and OS-appropriate shell usage.
   const shellNote = win
     ? `shell: Windows cmd.exe. To create files OR directories, use the write_file tool — ` +
       `it creates any missing parent folders automatically. Do NOT use shell "mkdir -p", ` +
       `"touch", "ls", "rm", "cp", "mv", or "&&"-chained Unix commands; they FAIL in cmd.exe. ` +
       `Run programs/tests with their interpreter (python, node, java, etc.).`
     : `shell: POSIX sh. Standard Unix commands are available. write_file still auto-creates parent dirs.`;
+
+  let projectBlock = "";
+  try {
+    projectBlock = scanProject(cwd);
+  } catch { /* non-fatal */ }
+
   return (
     `[environment]\n` +
     `os: ${process.platform}\n` +
@@ -40,7 +44,8 @@ function envContext(cwd) {
     `When the user names a location ("my desktop", "home", "documents"), write to ` +
     `the matching ABSOLUTE path above (e.g. desktop -> ${desktop}). Otherwise ` +
     `work under the cwd. Use absolute paths when a specific location is named.\n` +
-    `[/environment]\n\n`
+    `[/environment]\n\n` +
+    (projectBlock ? projectBlock + "\n" : "")
   );
 }
 
@@ -102,8 +107,6 @@ export async function runAgent({
   // Completeness guard: gemma sometimes reads files then narrates the fix as
   // text, or refactors one file but forgets the others. If a MODIFICATION task
   // finishes having read files it never edited, we nudge it once to finish.
-  const MOD_RE =
-    /\b(refactor|fix|add|adds?|change|update|implement|creat|writ|remov|delet|rename|extract|move|replace|build|generate|insert|append|convert|migrat|wire|hook|edit|modif|patch|integrat)/i;
   const looksLikeModification = MOD_RE.test(initialPrompt);
   let appliedNothingNudges = 0;
 
@@ -309,7 +312,7 @@ export async function runAgent({
  * worse than no skills at all. Prepending into the user message keeps
  * both layers active.
  */
-function buildTurnMessages(messages, allSkills, referencedPaths) {
+export function buildTurnMessages(messages, allSkills, referencedPaths) {
   if (allSkills.length === 0) return messages;
   // Find the latest user message — that's where the current task lives.
   let lastUserIdx = -1;

package/src/api.js

@@ -1,22 +1,9 @@
 // API client.
 
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { getConfig } from "./config.js";
+import { getVersion } from "./version.js";
 
-// Resolve our own version once for the User-Agent header — read from
-// package.json so it can't drift (the file previously sent three different
-// hardcoded versions across three calls).
-function readVersion() {
-  try {
-    const pkgPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-    return JSON.parse(fs.readFileSync(pkgPath, "utf8")).version || "0";
-  } catch {
-    return "0";
-  }
-}
-const USER_AGENT = `aether-code/${readVersion()}`;
+const USER_AGENT = `aether-code/${getVersion()}`;
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
@@ -93,7 +80,7 @@ export async function fetchBalance(apiKeyOverride) {
     const msg = data?.error || `${res.status} ${res.statusText}`;
     throw new AetherError(msg, code, res.status, data);
   }
-  return data; // { plan, role, planCredits, topupCredits, balance, isSuspended, rate }
+  return data; // { plan, planCredits, topupCredits, balance, isSuspended }
 }
 
 export class AetherError extends Error {

package/src/mcp.js

@@ -31,6 +31,7 @@ import os from "node:os";
 import path from "node:path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { getVersion } from "./version.js";
 
 const DEFAULT_CONFIG_PATH = path.join(os.homedir(), ".aether", "mcp.json");
 const NAMESPACE_SEP = "__";
@@ -163,7 +164,7 @@ export class MCPManager {
       env: { ...process.env, ...(cfg.env ?? {}) },
     });
     const client = new Client(
-      { name: "aether-code", version: "0.9.0" },
+      { name: "aether-code", version: getVersion() },
       { capabilities: {} },
     );
     // Bound the init handshake so a hung server doesn't stall startup.

package/src/project-context.js

@@ -0,0 +1,279 @@
+// Project context scanner. Reads the cwd on startup to give the model
+// immediate understanding of what project it's working in — tech stack,
+// file structure, available scripts, dependencies, and any project-specific
+// instructions. This is the single biggest quality-of-life improvement for
+// a weaker model: instead of guessing, it KNOWS.
+
+import fs from "node:fs";
+import path from "node:path";
+
+const SKIP_DIRS = new Set([
+  "node_modules", ".git", ".next", "dist", "build", "__pycache__",
+  ".venv", "venv", "env", ".env", ".idea", ".vscode", "coverage",
+  ".cache", ".turbo", "target", "out", ".output", ".nuxt", ".svelte-kit",
+  "vendor", "bower_components", ".parcel-cache", ".webpack",
+]);
+
+const FRAMEWORK_SIGNATURES = {
+  "next.config.js": "Next.js",
+  "next.config.mjs": "Next.js",
+  "next.config.ts": "Next.js",
+  "nuxt.config.ts": "Nuxt",
+  "svelte.config.js": "SvelteKit",
+  "astro.config.mjs": "Astro",
+  "remix.config.js": "Remix",
+  "angular.json": "Angular",
+  "vue.config.js": "Vue CLI",
+  "vite.config.ts": "Vite",
+  "vite.config.js": "Vite",
+  "webpack.config.js": "Webpack",
+  "tsconfig.json": "TypeScript",
+  "Cargo.toml": "Rust (Cargo)",
+  "go.mod": "Go",
+  "pyproject.toml": "Python",
+  "setup.py": "Python (setuptools)",
+  "requirements.txt": "Python",
+  "Gemfile": "Ruby (Bundler)",
+  "pom.xml": "Java (Maven)",
+  "build.gradle": "Java/Kotlin (Gradle)",
+  "CMakeLists.txt": "C/C++ (CMake)",
+  "Makefile": "Make",
+  "Dockerfile": "Docker",
+  "docker-compose.yml": "Docker Compose",
+  "docker-compose.yaml": "Docker Compose",
+  ".env": "dotenv config",
+  "prisma/schema.prisma": "Prisma ORM",
+  "drizzle.config.ts": "Drizzle ORM",
+};
+
+const DEP_FRAMEWORKS = {
+  next: "Next.js",
+  react: "React",
+  vue: "Vue",
+  svelte: "Svelte",
+  angular: "Angular",
+  express: "Express",
+  fastify: "Fastify",
+  koa: "Koa",
+  hono: "Hono",
+  "socket.io": "Socket.IO",
+  prisma: "Prisma",
+  drizzle: "Drizzle",
+  mongoose: "Mongoose",
+  sequelize: "Sequelize",
+  tailwindcss: "Tailwind CSS",
+  "styled-components": "styled-components",
+  electron: "Electron",
+  jest: "Jest",
+  vitest: "Vitest",
+  mocha: "Mocha",
+  playwright: "Playwright",
+  cypress: "Cypress",
+};
+
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function readTextSafe(filePath, maxBytes = 2000) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile() || stat.size > 500_000) return null;
+    const buf = Buffer.alloc(Math.min(stat.size, maxBytes));
+    const fd = fs.openSync(filePath, "r");
+    const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
+    fs.closeSync(fd);
+    return buf.toString("utf8", 0, bytesRead);
+  } catch {
+    return null;
+  }
+}
+
+function listTopLevel(cwd) {
+  let entries;
+  try {
+    entries = fs.readdirSync(cwd, { withFileTypes: true });
+  } catch {
+    return { dirs: [], files: [] };
+  }
+  const dirs = [];
+  const files = [];
+  for (const e of entries) {
+    if (e.name.startsWith(".") && e.name !== ".env" && e.name !== ".gitignore") continue;
+    if (SKIP_DIRS.has(e.name)) continue;
+    if (e.isDirectory()) {
+      dirs.push(e.name + "/");
+    } else if (e.isFile()) {
+      files.push(e.name);
+    }
+  }
+  dirs.sort();
+  files.sort();
+  return { dirs, files };
+}
+
+function listSecondLevel(cwd, dirName) {
+  const full = path.join(cwd, dirName);
+  let entries;
+  try {
+    entries = fs.readdirSync(full, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const items = [];
+  for (const e of entries) {
+    if (e.name.startsWith(".")) continue;
+    if (SKIP_DIRS.has(e.name)) continue;
+    items.push(e.isDirectory() ? e.name + "/" : e.name);
+  }
+  items.sort();
+  return items.slice(0, 30);
+}
+
+function detectFrameworks(cwd, topFiles) {
+  const found = new Set();
+  for (const file of topFiles) {
+    if (FRAMEWORK_SIGNATURES[file]) found.add(FRAMEWORK_SIGNATURES[file]);
+  }
+  if (fs.existsSync(path.join(cwd, "prisma", "schema.prisma"))) {
+    found.add("Prisma ORM");
+  }
+  return [...found];
+}
+
+function extractPackageInfo(cwd) {
+  const pkg = readJsonSafe(path.join(cwd, "package.json"));
+  if (!pkg) return null;
+  const info = { name: pkg.name, version: pkg.version };
+  if (pkg.scripts && Object.keys(pkg.scripts).length > 0) {
+    info.scripts = Object.keys(pkg.scripts);
+  }
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const detectedLibs = [];
+  for (const [dep, label] of Object.entries(DEP_FRAMEWORKS)) {
+    if (allDeps[dep]) detectedLibs.push(label);
+  }
+  if (detectedLibs.length > 0) info.frameworks = detectedLibs;
+  const depCount = Object.keys(pkg.dependencies || {}).length;
+  const devCount = Object.keys(pkg.devDependencies || {}).length;
+  if (depCount || devCount) {
+    info.depCounts = `${depCount} deps, ${devCount} devDeps`;
+  }
+  return info;
+}
+
+function extractCargoInfo(cwd) {
+  const raw = readTextSafe(path.join(cwd, "Cargo.toml"), 1500);
+  if (!raw) return null;
+  const name = raw.match(/^name\s*=\s*"(.+?)"/m)?.[1];
+  const version = raw.match(/^version\s*=\s*"(.+?)"/m)?.[1];
+  return { name, version, type: "Rust" };
+}
+
+function extractGoInfo(cwd) {
+  const raw = readTextSafe(path.join(cwd, "go.mod"), 500);
+  if (!raw) return null;
+  const mod = raw.match(/^module\s+(\S+)/m)?.[1];
+  const goVer = raw.match(/^go\s+(\S+)/m)?.[1];
+  return { module: mod, goVersion: goVer, type: "Go" };
+}
+
+function extractPythonInfo(cwd) {
+  const pyproject = readTextSafe(path.join(cwd, "pyproject.toml"), 1500);
+  if (pyproject) {
+    const name = pyproject.match(/^name\s*=\s*"(.+?)"/m)?.[1];
+    return { name, type: "Python" };
+  }
+  if (fs.existsSync(path.join(cwd, "requirements.txt"))) {
+    return { type: "Python (requirements.txt)" };
+  }
+  return null;
+}
+
+export function scanProject(cwd) {
+  const { dirs, files } = listTopLevel(cwd);
+  if (dirs.length === 0 && files.length === 0) {
+    return "[project]\nEmpty directory — no files detected.\n[/project]\n";
+  }
+
+  const lines = ["[project]"];
+
+  const frameworks = detectFrameworks(cwd, files);
+  if (frameworks.length > 0) {
+    lines.push(`stack: ${frameworks.join(", ")}`);
+  }
+
+  const pkg = extractPackageInfo(cwd);
+  const cargo = extractCargoInfo(cwd);
+  const goInfo = extractGoInfo(cwd);
+  const pyInfo = extractPythonInfo(cwd);
+
+  if (pkg) {
+    if (pkg.name) lines.push(`package: ${pkg.name}${pkg.version ? `@${pkg.version}` : ""}`);
+    if (pkg.frameworks) lines.push(`libraries: ${pkg.frameworks.join(", ")}`);
+    if (pkg.depCounts) lines.push(`dependencies: ${pkg.depCounts}`);
+    if (pkg.scripts) lines.push(`scripts: ${pkg.scripts.join(", ")}`);
+  }
+  if (cargo) {
+    lines.push(`crate: ${cargo.name || "unknown"}${cargo.version ? `@${cargo.version}` : ""}`);
+  }
+  if (goInfo) {
+    lines.push(`module: ${goInfo.module || "unknown"}${goInfo.goVersion ? ` (go ${goInfo.goVersion})` : ""}`);
+  }
+  if (pyInfo) {
+    lines.push(`python project: ${pyInfo.name || pyInfo.type}`);
+  }
+
+  lines.push("");
+  lines.push("structure:");
+  for (const d of dirs) {
+    lines.push(`  ${d}`);
+    const children = listSecondLevel(cwd, d.replace(/\/$/, ""));
+    for (const child of children.slice(0, 15)) {
+      lines.push(`    ${child}`);
+    }
+    if (children.length > 15) {
+      lines.push(`    ... (${children.length - 15} more)`);
+    }
+  }
+  for (const f of files) {
+    lines.push(`  ${f}`);
+  }
+
+  const contextFile = path.join(cwd, ".aether", "context.md");
+  const context = readTextSafe(contextFile, 3000);
+  if (context) {
+    lines.push("");
+    lines.push("project-instructions:");
+    lines.push(context.trim());
+  }
+
+  const readme = readTextSafe(path.join(cwd, "README.md"), 1500);
+  if (readme) {
+    lines.push("");
+    lines.push("readme-excerpt:");
+    lines.push(readme.trim());
+  }
+
+  lines.push("[/project]");
+  return lines.join("\n") + "\n";
+}
+
+export function scanProjectQuick(cwd) {
+  const { dirs, files } = listTopLevel(cwd);
+  const total = dirs.length + files.length;
+  if (total === 0) return "empty directory";
+  const frameworks = detectFrameworks(cwd, files);
+  const pkg = extractPackageInfo(cwd);
+  const parts = [];
+  if (pkg?.name) parts.push(pkg.name);
+  if (frameworks.length > 0) parts.push(frameworks.join(", "));
+  else if (pkg?.frameworks?.length) parts.push(pkg.frameworks[0]);
+  parts.push(`${total} items`);
+  if (pkg?.scripts) parts.push(`${pkg.scripts.length} scripts`);
+  return parts.join(" · ");
+}

package/src/repl.js

@@ -15,8 +15,14 @@ import { runSetup } from "./setup.js";
 import { c, errorLine, boxLines, sideBySide } from "./render.js";
 import { checkForUpdate } from "./update-check.js";
 import { promptBox, EXIT_SIGNAL } from "./box-input.js";
+import { getVersion } from "./version.js";
+import {
+  generateSessionId, saveSession, loadSession, listSessions,
+  findRecentSession, deleteSession, extractSummary, formatAge,
+} from "./sessions.js";
+import { scanProjectQuick } from "./project-context.js";
 
-const VERSION = "0.32.0";
+const VERSION = getVersion();
 const MODEL_NAME = "Aether Core";
 
 // /model aliases → { id, name }. id=null = server default (gemma / Aether Core).
@@ -38,9 +44,12 @@ const SHORTCUTS = `
   ${c.cyan("/yes")}       Toggle auto-approve mode (skip y/N prompts)
   ${c.cyan("/turns")} ${c.gray("<n>")}     Set max turns per prompt (default 25)
   ${c.cyan("/model")} ${c.gray("[core|ultra]")}  Show or switch model (ultra=Opus — premium)
+  ${c.cyan("/sessions")}  List saved sessions for this directory
+  ${c.cyan("/resume")} ${c.gray("[id]")}   Resume a saved session (default: most recent)
+  ${c.cyan("/new")}       Start a fresh session (save current first)
 
 ${c.gray("Anything else is sent to the agent as your next message.")}
-${c.gray("Conversation history is kept across messages until you /clear.")}
+${c.gray("Sessions auto-save — close the terminal and come back later.")}
 `;
 
 export async function runRepl({ cwd: initialCwd, autoYes: initialAutoYes, unsafePaths: initialUnsafePaths, maxTurns: initialMaxTurns, model: initialModel = null, mcpManager = null }) {
@@ -52,19 +61,17 @@ export async function runRepl({ cwd: initialCwd, autoYes: initialAutoYes, unsafe
     maxTurns: initialMaxTurns ?? 25,
     model: initialModel ?? null,
     modelName: initialAlias?.name ?? MODEL_NAME,
-    messages: [], // accumulates across turns
+    messages: [],
     balance: null,
     sessionCredits: 0,
     sessionIn: 0,
     sessionOut: 0,
+    sessionId: generateSessionId(initialCwd),
+    turnCount: 0,
   };
 
-  // Kick off the npm update check concurrently with the balance fetch so it
-  // adds no startup latency; the nudge (if any) prints just under the banner.
   const updatePromise = checkForUpdate().catch(() => null);
 
-  // Free balance check up front. If no key configured, walk through first-time
-  // setup flow (open browser → paste key → verify → save).
   let needsSetup = false;
   try {
     const me = await fetchBalance();
@@ -74,7 +81,6 @@ export async function runRepl({ cwd: initialCwd, autoYes: initialAutoYes, unsafe
     if (err instanceof AetherError && (err.code === "NO_API_KEY" || err.status === 401)) {
       needsSetup = true;
     } else {
-      // Transient network or other — surface but don't block
       console.log(c.gray(`(could not fetch balance: ${err.message})`));
     }
   }
@@ -85,42 +91,73 @@ export async function runRepl({ cwd: initialCwd, autoYes: initialAutoYes, unsafe
       console.log(c.gray("Aborting — no valid API key."));
       process.exit(1);
     }
-    // Re-fetch balance now that the key is saved
     try {
       const me = await fetchBalance();
       state.balance = me.balance;
       state.plan = me.plan;
-    } catch { /* tolerate — banner just won't show balance */ }
+    } catch { /* tolerate */ }
   }
 
-  printBanner(state);
+  // Check for a resumable session before printing the banner
+  let resumed = false;
+  try {
+    const recent = findRecentSession(state.cwd);
+    if (recent && recent.messageCount >= 2) {
+      const full = loadSession(recent.id);
+      if (full && full.messages?.length >= 2) {
+        console.log(
+          c.gray(`\n  Found session from ${formatAge(recent.updatedAt)} — `) +
+          c.cyan(extractSummary(full.messages) || "(no summary)"),
+        );
+        console.log(c.gray("  Resuming automatically. Use /new to start fresh.\n"));
+        state.sessionId = full.id;
+        state.messages = full.messages;
+        state.sessionCredits = full.credits ?? 0;
+        state.sessionIn = full.tokensIn ?? 0;
+        state.sessionOut = full.tokensOut ?? 0;
+        state.turnCount = full.turnCount ?? 0;
+        if (full.model !== undefined) state.model = full.model;
+        if (full.modelName) state.modelName = full.modelName;
+        resumed = true;
+      }
+    }
+  } catch { /* non-fatal */ }
+
+  // Project quick-scan for banner
+  let projectLine = "";
+  try {
+    projectLine = scanProjectQuick(state.cwd);
+  } catch { /* non-fatal */ }
+
+  printBanner(state, projectLine, resumed);
   const updateNudge = await updatePromise;
   if (updateNudge) console.log(updateNudge + "\n");
 
-  // Input: a bordered raw-mode box (box-input.js) — cmd.exe-safe and identical
-  // everywhere. (Ink's live redraw ghosts in the legacy Windows console, so we
-  // don't use it.) Each prompt is independent; the tool y/N prompts and the
-  // ask_user menu run BETWEEN prompts in raw mode too, so nothing overlaps.
   const inputHistory = [];
 
   while (true) {
     const raw = await promptBox({ history: inputHistory });
-    if (raw === EXIT_SIGNAL) { console.log(c.gray("bye.")); return; }
+    if (raw === EXIT_SIGNAL) {
+      autoSave(state);
+      console.log(c.gray("bye."));
+      return;
+    }
     const line = (raw ?? "").trim();
     if (!line) continue;
 
-    // promptBox already echoes "› <line>" on submit, so no echo needed here.
     inputHistory.push(line);
 
-    // Slash command?
     if (line.startsWith("/") || line === "?") {
       const handled = await handleSlash(line, state);
-      if (handled === "exit") return;
+      if (handled === "exit") {
+        autoSave(state);
+        return;
+      }
       printStatusLine(state);
       continue;
     }
 
-    // Otherwise — send as a message to the agent
+    state.turnCount++;
     const result = await runAgent({
       initialPrompt: line,
       priorMessages: state.messages.length > 0 ? state.messages : undefined,
@@ -140,13 +177,31 @@ export async function runRepl({ cwd: initialCwd, autoYes: initialAutoYes, unsafe
 
     if (!result.ok && result.error) {
       console.log("\n" + errorLine(result.error.message || String(result.error)));
-      // Don't kill the session on a single error — surface it and continue.
     }
 
+    autoSave(state);
     printStatusLine(state);
   }
 }
 
+function autoSave(state) {
+  if (state.messages.length < 2) return;
+  try {
+    saveSession({
+      id: state.sessionId,
+      cwd: state.cwd,
+      model: state.model,
+      modelName: state.modelName,
+      messages: state.messages,
+      credits: state.sessionCredits,
+      tokensIn: state.sessionIn,
+      tokensOut: state.sessionOut,
+      turnCount: state.turnCount,
+      summary: extractSummary(state.messages),
+    });
+  } catch { /* non-fatal — don't kill the session over a save failure */ }
+}
+
 /* ───────── slash commands ───────── */
 
 async function handleSlash(line, state) {
@@ -231,6 +286,75 @@ async function handleSlash(line, state) {
       }
       break;
     }
+    case "sessions": {
+      const sessions = listSessions(state.cwd);
+      if (sessions.length === 0) {
+        console.log(c.gray("No saved sessions for this directory."));
+      } else {
+        console.log(c.bold("Saved sessions") + c.gray(` (${state.cwd})`));
+        for (const s of sessions.slice(0, 10)) {
+          const active = s.id === state.sessionId ? c.cyan(" ← current") : "";
+          const summary = s.summary || "(no summary)";
+          const truncated = summary.length > 60 ? summary.slice(0, 57) + "..." : summary;
+          console.log(
+            `  ${c.gray(formatAge(s.updatedAt).padEnd(8))} ` +
+            `${c.gray(s.id.slice(0, 16))}  ` +
+            `${truncated}` +
+            `${c.gray(` · ${s.turnCount} turns`)}` +
+            active,
+          );
+        }
+        if (sessions.length > 10) {
+          console.log(c.gray(`  ... and ${sessions.length - 10} more`));
+        }
+        console.log(c.gray("\nUse /resume <id-prefix> to load one."));
+      }
+      break;
+    }
+    case "resume": {
+      const target = (arg || "").trim();
+      let session = null;
+      if (target) {
+        const sessions = listSessions(state.cwd);
+        const match = sessions.find((s) => s.id.startsWith(target));
+        if (match) session = loadSession(match.id);
+        if (!session) {
+          console.log(errorLine(`No session matching "${target}" found.`));
+          break;
+        }
+      } else {
+        const recent = findRecentSession(state.cwd);
+        if (recent) session = loadSession(recent.id);
+        if (!session) {
+          console.log(errorLine("No recent session to resume. Use /sessions to list."));
+          break;
+        }
+      }
+      autoSave(state);
+      state.sessionId = session.id;
+      state.messages = session.messages ?? [];
+      state.sessionCredits = session.credits ?? 0;
+      state.sessionIn = session.tokensIn ?? 0;
+      state.sessionOut = session.tokensOut ?? 0;
+      state.turnCount = session.turnCount ?? 0;
+      if (session.model !== undefined) state.model = session.model;
+      if (session.modelName) state.modelName = session.modelName;
+      const summary = extractSummary(session.messages) || "(no summary)";
+      console.log(c.gray(`Resumed: `) + c.cyan(summary));
+      console.log(c.gray(`  ${state.messages.length} messages · ${state.turnCount} turns · ${formatAge(session.updatedAt)}`));
+      break;
+    }
+    case "new": {
+      autoSave(state);
+      state.sessionId = generateSessionId(state.cwd);
+      state.messages = [];
+      state.sessionCredits = 0;
+      state.sessionIn = 0;
+      state.sessionOut = 0;
+      state.turnCount = 0;
+      console.log(c.gray("New session started. Previous session saved."));
+      break;
+    }
     default:
       console.log(errorLine(`Unknown command: /${cmd}. Type ${c.cyan("/help")} for shortcuts.`));
   }
@@ -245,23 +369,27 @@ const shortenPath = (p, max) => (p.length <= max ? p : "..." + p.slice(p.length
 // Short, hand-curated highlights shown in the "What's new" box. Update with
 // notable releases — keep it to ~3 lines so it balances the banner height.
 const WHATS_NEW = [
-  "Files now save to your Desktop",
+  "Session persistence — close & resume",
+  "Project auto-understanding on startup",
   "Live thinking spinner + loop guard",
-  "Asks you when a task is unclear",
 ];
 
-function printBanner(state) {
+function printBanner(state, projectLine = "", resumed = false) {
   const mode = state.autoYes ? (state.unsafePaths ? "skip-permissions" : "auto-yes") : "review mode";
   const credits = state.balance != null ? `${state.balance.toLocaleString()} credits` : "";
-  const left = boxLines(
-    [
-      c.bold(c.magenta("aether")) + c.gray("  ·  ") + c.bold(state.modelName) + c.gray("   v" + VERSION),
-      c.gray("uncensored AI coding agent"),
-      c.gray((credits ? credits + " · " : "") + mode),
-      c.gray(shortenPath(state.cwd, 52)),
-    ],
-    { color: c.magenta, padX: 2 },
-  );
+  const leftLines = [
+    c.bold(c.magenta("aether")) + c.gray("  ·  ") + c.bold(state.modelName) + c.gray("   v" + VERSION),
+    c.gray("uncensored AI coding agent"),
+    c.gray((credits ? credits + " · " : "") + mode),
+    c.gray(shortenPath(state.cwd, 52)),
+  ];
+  if (projectLine) {
+    leftLines.push(c.gray("project: " + (projectLine.length > 48 ? projectLine.slice(0, 45) + "..." : projectLine)));
+  }
+  if (resumed) {
+    leftLines.push(c.cyan("↻ resumed session") + c.gray(` · ${state.turnCount} turns · ${state.messages.length} msgs`));
+  }
+  const left = boxLines(leftLines, { color: c.magenta, padX: 2 });
   const right = boxLines(
     [c.bold(c.cyan("What's new")), ...WHATS_NEW.map((s) => c.gray("• " + s))],
     { color: c.cyan, padX: 2 },
@@ -269,8 +397,6 @@ function printBanner(state) {
 
   console.log("");
   const cols = process.stdout.columns || 80;
-  // Only place the two boxes side by side when there's room; otherwise the
-  // banner alone (narrow terminals would wrap and tear the second box).
   if (cols >= visLen(left[0]) + visLen(right[0]) + 4) {
     console.log(sideBySide(left, right, 3));
   } else {

package/src/sessions.js

@@ -0,0 +1,167 @@
+// Session persistence. Saves conversation state to ~/.aether/sessions/ so
+// users can close the terminal, come back tomorrow, and resume exactly
+// where they left off. Auto-saves after every agent turn.
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+
+const SESSIONS_DIR = path.join(os.homedir(), ".aether", "sessions");
+const MAX_SESSIONS = 50;
+const STALE_DAYS = 14;
+
+function ensureDir() {
+  fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+}
+
+function cwdHash(cwd) {
+  return crypto.createHash("sha256").update(cwd.toLowerCase()).digest("hex").slice(0, 12);
+}
+
+function sessionPath(id) {
+  return path.join(SESSIONS_DIR, `${id}.json`);
+}
+
+export function generateSessionId(cwd) {
+  const hash = cwdHash(cwd);
+  const ts = Date.now().toString(36);
+  return `${hash}-${ts}`;
+}
+
+export function saveSession(session) {
+  ensureDir();
+  const data = {
+    id: session.id,
+    cwd: session.cwd,
+    model: session.model ?? null,
+    modelName: session.modelName ?? "Aether Core",
+    messages: session.messages ?? [],
+    credits: session.credits ?? 0,
+    tokensIn: session.tokensIn ?? 0,
+    tokensOut: session.tokensOut ?? 0,
+    createdAt: session.createdAt ?? new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    summary: session.summary ?? "",
+    turnCount: session.turnCount ?? 0,
+  };
+  const filePath = sessionPath(data.id);
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
+  try { fs.chmodSync(filePath, 0o600); } catch { /* windows */ }
+  pruneOldSessions();
+  return data;
+}
+
+export function loadSession(id) {
+  const filePath = sessionPath(id);
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export function deleteSession(id) {
+  try {
+    fs.unlinkSync(sessionPath(id));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function listSessions(filterCwd) {
+  ensureDir();
+  let files;
+  try {
+    files = fs.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const sessions = [];
+  for (const f of files) {
+    try {
+      const raw = fs.readFileSync(path.join(SESSIONS_DIR, f), "utf8");
+      const data = JSON.parse(raw);
+      if (filterCwd && data.cwd?.toLowerCase() !== filterCwd.toLowerCase()) continue;
+      sessions.push({
+        id: data.id,
+        cwd: data.cwd,
+        model: data.model,
+        modelName: data.modelName,
+        summary: data.summary,
+        turnCount: data.turnCount ?? 0,
+        messageCount: data.messages?.length ?? 0,
+        credits: data.credits ?? 0,
+        createdAt: data.createdAt,
+        updatedAt: data.updatedAt,
+      });
+    } catch {
+      continue;
+    }
+  }
+  sessions.sort((a, b) => (b.updatedAt || "").localeCompare(a.updatedAt || ""));
+  return sessions;
+}
+
+export function findRecentSession(cwd, maxAgeMs = 24 * 60 * 60 * 1000) {
+  const sessions = listSessions(cwd);
+  if (sessions.length === 0) return null;
+  const newest = sessions[0];
+  if (!newest.updatedAt) return null;
+  const age = Date.now() - new Date(newest.updatedAt).getTime();
+  if (age > maxAgeMs) return null;
+  if (newest.messageCount < 2) return null;
+  return newest;
+}
+
+function pruneOldSessions() {
+  let files;
+  try {
+    files = fs.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+  } catch {
+    return;
+  }
+  if (files.length <= MAX_SESSIONS) return;
+  const entries = [];
+  for (const f of files) {
+    try {
+      const stat = fs.statSync(path.join(SESSIONS_DIR, f));
+      entries.push({ file: f, mtime: stat.mtimeMs });
+    } catch {
+      continue;
+    }
+  }
+  entries.sort((a, b) => b.mtime - a.mtime);
+  const cutoff = Date.now() - STALE_DAYS * 24 * 60 * 60 * 1000;
+  for (const e of entries.slice(MAX_SESSIONS)) {
+    if (e.mtime < cutoff) {
+      try { fs.unlinkSync(path.join(SESSIONS_DIR, e.file)); } catch { /* ignore */ }
+    }
+  }
+}
+
+export function extractSummary(messages) {
+  if (!messages || messages.length === 0) return "";
+  const firstUser = messages.find((m) => m.role === "user");
+  if (!firstUser || typeof firstUser.content !== "string") return "";
+  const text = firstUser.content
+    .replace(/\[environment\][\s\S]*?\[\/environment\]\s*/g, "")
+    .replace(/\[project\][\s\S]*?\[\/project\]\s*/g, "")
+    .replace(/=== LOADED SKILLS[\s\S]*?---\s*/g, "")
+    .trim();
+  return text.length > 120 ? text.slice(0, 117) + "..." : text;
+}
+
+export function formatAge(isoDate) {
+  if (!isoDate) return "unknown";
+  const ms = Date.now() - new Date(isoDate).getTime();
+  const mins = Math.floor(ms / 60_000);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}

package/src/tools.js

@@ -16,6 +16,7 @@ import { c } from "./render.js";
 import { promptChoice } from "./menu.js";
 import { unifiedDiff, summarizeWrite } from "./diff.js";
 import { getConfig } from "./config.js";
+import { getVersion } from "./version.js";
 
 /* ─────────────────────── Tool definitions (sent to model) ─────────────────────── */
 
@@ -646,26 +647,39 @@ async function webSearch(args, opts) {
     return { ok: false, output: "Web search requires AETHER_API_KEY. Set it and try again." };
   }
   const max = Number.isInteger(args.max_results) ? Math.min(10, Math.max(1, args.max_results)) : 5;
+  const maxRetries = 2;
+  const baseDelay = 500;
   let res;
-  try {
-    res = await fetch(`${baseUrl}/api/v1/web-search`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`,
-        "User-Agent": "aether-code/web-search",
-      },
-      body: JSON.stringify({ query: args.query, max_results: max }),
-    });
-  } catch (e) {
-    return { ok: false, output: `web_search network error: ${e.message}` };
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      res = await fetch(`${baseUrl}/api/v1/web-search`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+          "User-Agent": `aether-code/${getVersion()}`,
+        },
+        body: JSON.stringify({ query: args.query, max_results: max }),
+      });
+      if (res.status >= 500 && attempt < maxRetries) {
+        res.body?.cancel().catch(() => {});
+        await new Promise((r) => setTimeout(r, baseDelay * 2 ** attempt));
+        continue;
+      }
+      break;
+    } catch (e) {
+      if (attempt < maxRetries) {
+        await new Promise((r) => setTimeout(r, baseDelay * 2 ** attempt));
+        continue;
+      }
+      return { ok: false, output: `web_search network error: ${e.message}` };
+    }
   }
   let data = null;
   try { data = await res.json(); } catch { /* non-JSON */ }
   if (!res.ok) {
     return { ok: false, output: data?.error || `web_search HTTP ${res.status}` };
   }
-  // Hand the model just the array — that's all it needs to decide which URL to fetch.
   return { ok: true, output: JSON.stringify(data.results ?? [], null, 2) };
 }
 
@@ -709,7 +723,7 @@ async function webFetch(args, opts) {
       headers: {
         // Looking like a normal browser dodges many anti-bot pages.
         "User-Agent":
-          "Mozilla/5.0 (compatible; aether-code/0.7) Gecko/20100101 Firefox/130.0",
+          `Mozilla/5.0 (compatible; aether-code/${getVersion()}) Gecko/20100101 Firefox/130.0`,
         Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
         "Accept-Language": "en-US,en;q=0.9",
       },
@@ -782,11 +796,28 @@ export function htmlToText(html) {
   return s.trim();
 }
 
+const CATASTROPHIC_CMD_RE = new RegExp(
+  [
+    String.raw`rm\s+-(r|f|rf|fr)\w*\s+[/~](?!\S*node_modules)(?!\S*dist)(?!\S*\.next)(?!\S*build)`,
+    String.raw`del\s+/[sfq]+\s+[cC]:\\`,
+    String.raw`format\s+[a-zA-Z]:`,
+    String.raw`mkfs\.`,
+    String.raw`dd\s+.*of=/dev/[sh]d`,
+    String.raw`:\(\)\s*\{\s*:\|:`,
+    String.raw`>\s*/dev/[sh]d`,
+    String.raw`rd\s+/[sq]+\s+[cC]:\\`,
+  ].join("|"),
+);
+
 async function runShell(args, opts) {
   if (typeof args.command !== "string") return { ok: false, output: "command is required" };
   const cwd = args.cwd ? resolveSafe(args.cwd, opts) : opts.cwd;
   console.log(c.yellow("$ ") + c.bold(args.command) + (args.cwd ? c.dim(`  (cwd: ${args.cwd})`) : ""));
-  const approved = await confirm(c.yellow("Run this command?"), opts.autoYes);
+  const forceReview = CATASTROPHIC_CMD_RE.test(args.command);
+  if (forceReview) {
+    console.log(c.red(c.bold("  ⚠ DESTRUCTIVE COMMAND DETECTED")) + c.gray(" — requires manual confirmation"));
+  }
+  const approved = await confirm(c.yellow("Run this command?"), forceReview ? false : opts.autoYes);
   if (!approved) return { ok: false, output: "User declined the command." };
 
   return new Promise((resolve) => {

package/src/version.js

@@ -0,0 +1,15 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+let cached;
+export function getVersion() {
+  if (cached) return cached;
+  try {
+    const pkgPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    cached = JSON.parse(fs.readFileSync(pkgPath, "utf8")).version || "0";
+  } catch {
+    cached = "0";
+  }
+  return cached;
+}