jawere 1.5.1 → 1.6.1

package/README.md

@@ -4,12 +4,10 @@ Terminal-based AI coding assistant powered by DeepSeek. Runs as an interactive R
 
 ## Features
 
-- **Autonomous Agent Loop** — Tool-calling loop (up to 500 turns) with seven filesystem tools
+- **Autonomous Agent Loop** — Tool-calling loop (up to 500 turns) with filesystem tools
 - **Codebase Scanner** — Pre-scans the project on startup, generating `.codebase/tree.yaml` and `.codebase/meta.json` so the LLM has structural context before the first prompt
-- **Interactive REPL** — Multiline input (Shift+Enter), session resumption, and persistent conversation history backed by Convex
+- **Interactive REPL** — Multiline input (Shift+Enter), session resumption, and persistent conversation history
 - **Encrypted API Key** — AES-256-GCM encrypted key storage at `~/.jawere/key.enc`
-- **Session Persistence** — Full message history, tool calls, and token usage stored in Convex
-- **Dual Environment** — Dev/prod modes with separate Convex deployments
 
 ## Quick Start
 
@@ -33,8 +31,6 @@ npm start
 | Command | Description |
 |---------|-------------|
 | `/help` | Show available commands |
-| `/sessions` | List recent Convex sessions |
-| `/load <id>` | Resume a previous session |
 | `/key` | Show API key status |
 | `/setup` | Re-enter and save API key |
 | `/clear` | Clear screen and start fresh |
@@ -42,7 +38,7 @@ npm start
 
 ## Tools
 
-The LLM has access to seven filesystem tools:
+The LLM has access to filesystem and web tools:
 
 - `bash` — Execute shell commands with configurable timeout (max 300s). Output truncated at 2000 lines / 50KB.
 - `read` — Read file contents with line offset/limit for large files.
@@ -51,6 +47,10 @@ The LLM has access to seven filesystem tools:
 - `ls` — List directory contents with sizes.
 - `find` — Find files by fuzzy name or glob pattern. Skips hidden dirs and node_modules.
 - `grep` — Search file contents with regex. Supports file glob filtering.
+- `stat` — Get file or directory metadata.
+- `diff` — Show git diff of working changes.
+- `web_search` — Search the web for up-to-date information.
+- `docs` — Search library/package documentation.
 
 ## Configuration
 
@@ -59,8 +59,6 @@ The LLM has access to seven filesystem tools:
 | `DEEPSEEK_API_KEY` | — | DeepSeek API key |
 | `DEEPSEEK_MODEL` | `deepseek-v4-pro` | Model name |
 | `WORK_DIR` | `process.cwd()` | Working directory |
-| `CONVEX_URL` | auto | Convex deployment URL |
-| `NODE_ENV` | auto-detected | `development` or `production` |
 
 ## Project Structure
 
@@ -71,12 +69,11 @@ The LLM has access to seven filesystem tools:
 │   ├── agent.ts               # Agent loop: LLM calls + tool execution
 │   ├── config.ts              # Configuration (env, key, mode)
 │   ├── tools.ts               # Tool definitions & implementations
-│   ├── convex-client.ts       # HTTP client for Convex backend
 │   ├── crypto.ts              # Encrypted API key storage (AES-256-GCM)
 │   ├── scanner.ts             # Codebase pre-scanner (.codebase/)
 │   ├── spinner.ts             # Terminal spinner animations
+│   ├── prompt.ts              # Interactive prompt (multiline)
 │   └── system-prompt.ts       # System prompt template
-├── convex/                    # Convex backend (schema, mutations, queries)
 ├── scripts/build.js           # esbuild bundler
 ├── dist/                      # Compiled output
 ├── package.json
@@ -90,11 +87,6 @@ The LLM has access to seven filesystem tools:
 | `npm start` | Run in dev mode |
 | `npm run start:prod` | Run in prod mode |
 | `npm run build` | Bundle with esbuild |
-| `npm run dev` | Run `convex dev` for backend |
-| `npm run deploy:dev` | Deploy Convex backend (dev) |
-| `npm run deploy:prod` | Deploy Convex backend (prod) |
-| `npm run seed:dev` | Seed dev database |
-| `npm run seed:prod` | Seed prod database |
 
 ## License
 

package/dist/index.js

@@ -2801,12 +2801,12 @@ var require_lib2 = __commonJS({
       const dest = new URL$1(destination).protocol;
       return orig === dest;
     };
-    function fetch3(url, opts) {
-      if (!fetch3.Promise) {
+    function fetch2(url, opts) {
+      if (!fetch2.Promise) {
         throw new Error("native promise missing, set fetch.Promise to your favorite alternative");
       }
-      Body.Promise = fetch3.Promise;
-      return new fetch3.Promise(function(resolve4, reject) {
+      Body.Promise = fetch2.Promise;
+      return new fetch2.Promise(function(resolve4, reject) {
         const request = new Request3(url, opts);
         const options = getNodeRequestOptions(request);
         const send = (options.protocol === "https:" ? https : http).request;
@@ -2877,7 +2877,7 @@ var require_lib2 = __commonJS({
         req.on("response", function(res) {
           clearTimeout(reqTimeout);
           const headers = createHeadersLenient(res.headers);
-          if (fetch3.isRedirect(res.statusCode)) {
+          if (fetch2.isRedirect(res.statusCode)) {
             const location = headers.get("Location");
             let locationURL = null;
             try {
@@ -2939,7 +2939,7 @@ var require_lib2 = __commonJS({
                   requestOpts.body = void 0;
                   requestOpts.headers.delete("content-length");
                 }
-                resolve4(fetch3(new Request3(locationURL, requestOpts)));
+                resolve4(fetch2(new Request3(locationURL, requestOpts)));
                 finalize();
                 return;
             }
@@ -3031,11 +3031,11 @@ var require_lib2 = __commonJS({
         stream.end();
       }
     }
-    fetch3.isRedirect = function(code) {
+    fetch2.isRedirect = function(code) {
       return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
     };
-    fetch3.Promise = global.Promise;
-    module.exports = exports = fetch3;
+    fetch2.Promise = global.Promise;
+    module.exports = exports = fetch2;
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.default = exports;
     exports.Headers = Headers3;
@@ -6817,7 +6817,7 @@ var VERSION = "4.104.0";
 // node_modules/openai/_shims/registry.mjs
 var auto = false;
 var kind = void 0;
-var fetch2 = void 0;
+var fetch = void 0;
 var Request = void 0;
 var Response = void 0;
 var Headers = void 0;
@@ -6838,7 +6838,7 @@ function setShims(shims, options = { auto: false }) {
   }
   auto = options.auto;
   kind = shims.kind;
-  fetch2 = shims.fetch;
+  fetch = shims.fetch;
   Request = shims.Request;
   Response = shims.Response;
   Headers = shims.Headers;
@@ -7950,7 +7950,7 @@ var APIClient = class {
     this.maxRetries = validatePositiveInteger("maxRetries", maxRetries);
     this.timeout = validatePositiveInteger("timeout", timeout);
     this.httpAgent = httpAgent;
-    this.fetch = overriddenFetch ?? fetch2;
+    this.fetch = overriddenFetch ?? fetch;
   }
   authHeaders(opts) {
     return {};
@@ -13101,6 +13101,14 @@ You have access to a set of tools that let you interact with the filesystem:
          Skips hidden dirs and node_modules, .git, dist, etc.
   grep   Search file contents with regex. Returns file paths with line numbers.
          Skips binary files and files over 500KB.
+  web_search  Search the web for general information using DuckDuckGo (free).
+         Returns abstracts, answers, definitions, related topics, web links.
+         Use for general knowledge, news, current events \u2014 NOT for code docs.
+  docs   Search library/framework/API documentation specifically. Uses site-scoped
+         DuckDuckGo queries targeting official doc sites (MDN, nodejs.org, docs.rs,
+         react.dev, python.org, etc.). Optional library param narrows the search.
+         Use this for API references, method signatures, config options, examples.
+         Prefer this over web_search for any programming documentation lookup.
 
 \u2500\u2500 Parallel Tool Execution \u2500\u2500
 
@@ -13116,6 +13124,9 @@ independent of each other. This is faster and saves tokens \u2014 use it wheneve
   GOOD \u2014 read a file AND list a directory at the same time:
     \u2022 Call read(config.ts) + ls(src/) together
 
+  GOOD \u2014 search docs/web while also reading files:
+    \u2022 Call docs(query, library) + web_search(query) + read(file) all at once
+
   BAD \u2014 these depend on each other, so must be sequential:
     \u2022 grep then read (grep finds a file, then you read it)
     \u2022 bash then read (you run a command, then read its output file)
@@ -13182,6 +13193,35 @@ import { exec } from "child_process";
 import { readFile, writeFile, mkdir, access, stat as fsStat } from "fs/promises";
 import { constants } from "fs";
 import { resolve, dirname } from "path";
+import { get as httpsGet } from "https";
+function safeResolve(workDir, userPath) {
+  const resolved = resolve(workDir, userPath);
+  const normalizedWd = resolve(workDir).replace(/\/+$/, "") + "/";
+  const normalizedResolved = resolved.replace(/\/+$/, "") + "/";
+  if (!normalizedResolved.startsWith(normalizedWd)) {
+    throw new Error(
+      `Path traversal blocked: "${userPath}" escapes the working directory. All file operations must stay within ${workDir}.`
+    );
+  }
+  return resolved;
+}
+var DANGEROUS_COMMANDS = [
+  { pattern: /(?:^|[;&|])\s*rm\s.*-rf\s*(?:\/|\/\*|\s+\/)/, reason: "rm -rf on root filesystem" },
+  { pattern: /(?:^|[;&|])\s*sudo\s/, reason: "sudo escalation" },
+  { pattern: /:.*\(.*\)\s*\{\s*:\|:.*&\s*\}\s*;\s*:/, reason: "fork bomb" },
+  { pattern: /(?:^|[;&|])\s*(?:dd|mkfs|fdisk|parted)\s.*if=\/dev\/|of=\/dev\//, reason: "raw device write" },
+  { pattern: /(?:^|[;&|])\s*chmod\s.*-R\s*(?:777|o\+rwx|a\+rwx)\s*(?:\/|\/etc|\/usr|\/var)/, reason: "recursive world-writable on system dirs" },
+  { pattern: /(?:^|[;&|])\s*(?:curl|wget)\s.*\|\s*(?:ba)?sh/, reason: "curl-pipe-shell \u2014 use safer methods" },
+  { pattern: /(?:^|[;&|])\s*git\s+push\s+--force.*main|master/, reason: "force push to main/master" }
+];
+function checkDangerousCommand(command) {
+  for (const { pattern, reason } of DANGEROUS_COMMANDS) {
+    if (pattern.test(command)) {
+      return `Blocked dangerous command (${reason}). If you need this, run it manually in your terminal.`;
+    }
+  }
+  return null;
+}
 var TOOL_DEFS = [
   {
     type: "function",
@@ -13387,6 +13427,52 @@ var TOOL_DEFS = [
         required: ["pattern"]
       }
     }
+  },
+  {
+    type: "function",
+    function: {
+      name: "web_search",
+      description: "Search the web for information. Uses DuckDuckGo (free, no API key needed). Returns relevant results including abstracts, answers, related topics, and web links. Use this for general knowledge, news, current events, or broad information not found locally.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Search query string"
+          },
+          count: {
+            type: "number",
+            description: "Maximum number of results to return (default 5, max 10)"
+          }
+        },
+        required: ["query"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "docs",
+      description: "Search library, framework, and API documentation. Uses DuckDuckGo site-targeted queries to search official documentation sources (MDN, Node.js docs, npm packages, Rust docs, Python docs, Go docs, etc.). Free \u2014 no API key needed. Use this for API signatures, method references, configuration options, package usage examples, or any programming documentation lookup.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: 'Documentation search query (e.g. "fs.readFile options", "React useEffect cleanup")'
+          },
+          library: {
+            type: "string",
+            description: 'Optional library/package name to narrow search (e.g. "react", "typescript", "express")'
+          },
+          count: {
+            type: "number",
+            description: "Maximum results (default 5, max 8)"
+          }
+        },
+        required: ["query"]
+      }
+    }
   }
 ];
 var MAX_OUTPUT_LINES = 2e3;
@@ -13420,6 +13506,8 @@ function truncateOutput(text) {
   return { text: truncated, totalLines, totalBytes, linesShown, truncated: true };
 }
 async function execBash(command, workDir, timeoutSec) {
+  const blocked = checkDangerousCommand(command);
+  if (blocked) return blocked;
   const timeout = Math.min(timeoutSec ?? 120, 300) * 1e3;
   return new Promise((resolve4) => {
     const child = exec(
@@ -13453,7 +13541,12 @@ async function execBash(command, workDir, timeoutSec) {
   });
 }
 async function readFileTool(path, workDir, offset, limit2) {
-  const fullPath = resolve(workDir, path);
+  let fullPath;
+  try {
+    fullPath = safeResolve(workDir, path);
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
   try {
     await access(fullPath, constants.R_OK);
   } catch {
@@ -13488,7 +13581,12 @@ function diffSummary(before, after) {
   return `(${linePart} lines, ${bytePart})`;
 }
 async function editFileTool(path, edits, workDir) {
-  const fullPath = resolve(workDir, path);
+  let fullPath;
+  try {
+    fullPath = safeResolve(workDir, path);
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
   let content;
   try {
     content = await readFile(fullPath, "utf-8");
@@ -13537,13 +13635,23 @@ ${errors.map((e2) => `  - ${e2}`).join("\n")}`;
   return parts.join("\n");
 }
 async function writeFileTool(path, content, workDir) {
-  const fullPath = resolve(workDir, path);
+  let fullPath;
+  try {
+    fullPath = safeResolve(workDir, path);
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
   await mkdir(dirname(fullPath), { recursive: true });
   await writeFile(fullPath, content, "utf-8");
   return `Successfully wrote ${Buffer.byteLength(content, "utf-8")} bytes to ${fullPath}`;
 }
 async function lsTool(path, workDir) {
-  const dir = resolve(workDir, path || ".");
+  let dir;
+  try {
+    dir = safeResolve(workDir, path || ".");
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
   const { readdir: readdir2, stat } = await import("fs/promises");
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
@@ -13583,7 +13691,12 @@ ${lines.join("\n")}`).text;
   }
 }
 async function findTool(pattern, searchPath, workDir) {
-  const base = resolve(workDir, searchPath || ".");
+  let base;
+  try {
+    base = safeResolve(workDir, searchPath || ".");
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
   const SKIP_DIRS2 = /* @__PURE__ */ new Set([
     "node_modules",
     ".git",
@@ -13649,7 +13762,12 @@ ${results.join("\n")}`
   ).text;
 }
 async function grepTool(pattern, searchPath, include, workDir) {
-  const base = resolve(workDir, searchPath || ".");
+  let base;
+  try {
+    base = safeResolve(workDir, searchPath || ".");
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
   const SKIP_DIRS2 = /* @__PURE__ */ new Set([
     "node_modules",
     ".git",
@@ -13740,7 +13858,12 @@ ${results.join("\n")}`
   ).text;
 }
 async function statTool(path, workDir) {
-  const fullPath = resolve(workDir, path);
+  let fullPath;
+  try {
+    fullPath = safeResolve(workDir, path);
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
   try {
     const s2 = await fsStat(fullPath);
     const parts = [`${fullPath}:`];
@@ -13789,6 +13912,285 @@ async function diffTool(path, staged, base, workDir) {
   else args.push("--", ".");
   return execBash(`git ${args.join(" ")}`, workDir, 30);
 }
+function httpsGetJSON(url, timeout = 8e3) {
+  return new Promise((resolve4, reject) => {
+    const req = httpsGet(url, { timeout }, (res) => {
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        httpsGetJSON(res.headers.location, timeout).then(resolve4).catch(reject);
+        return;
+      }
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk.toString();
+        if (data.length > 5e5) {
+          res.destroy();
+          reject(new Error("Response too large"));
+        }
+      });
+      res.on("end", () => {
+        try {
+          resolve4(JSON.parse(data));
+        } catch {
+          reject(new Error(`Failed to parse JSON (status ${res.statusCode})`));
+        }
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+  });
+}
+async function webSearchTool(query, count) {
+  const maxResults = Math.min(Math.max(count ?? 5, 1), 10);
+  const encoded = encodeURIComponent(query);
+  const ddgUrl = `https://api.duckduckgo.com/?q=${encoded}&format=json&no_html=1&skip_disambig=1`;
+  let json;
+  try {
+    json = await httpsGetJSON(ddgUrl, 1e4);
+  } catch (err) {
+    return `Error: Web search failed \u2014 ${err.message || err}`;
+  }
+  const parts = [];
+  if (json.Heading && json.Heading !== query) {
+    parts.push(`Topic: ${json.Heading}`);
+  }
+  if (json.Answer) {
+    parts.push(`Answer: ${json.Answer}`);
+  }
+  if (json.AbstractText && json.AbstractText.trim()) {
+    let abstract = json.AbstractText.trim();
+    if (json.AbstractSource) {
+      abstract += ` [Source: ${json.AbstractSource}]`;
+    }
+    if (json.AbstractURL) {
+      abstract += ` \u2014 ${json.AbstractURL}`;
+    }
+    parts.push(`Summary: ${abstract}`);
+  } else if (json.Abstract && json.Abstract.trim()) {
+    parts.push(`Summary: ${json.Abstract.trim()}`);
+  }
+  if (json.Definition) {
+    let def = `Definition: ${json.Definition}`;
+    if (json.DefinitionSource) def += ` [Source: ${json.DefinitionSource}]`;
+    parts.push(def);
+  }
+  if (json.Infobox?.content) {
+    const fields = json.Infobox.content.filter((c2) => c2.label && c2.value).map((c2) => `  ${c2.label}: ${c2.value}`).slice(0, 8);
+    if (fields.length > 0) {
+      parts.push(`Details:
+${fields.join("\n")}`);
+    }
+  }
+  if (json.RelatedTopics && json.RelatedTopics.length > 0) {
+    const topics = [];
+    for (const t2 of json.RelatedTopics) {
+      if (topics.length >= maxResults) break;
+      if (t2.Text && t2.FirstURL) {
+        const cleanText = t2.Text.replace(/<[^>]+>/g, "").trim();
+        topics.push(`  - ${cleanText.slice(0, 200)}
+    ${t2.FirstURL}`);
+      } else if (t2.Text) {
+        topics.push(`  - ${t2.Text.replace(/<[^>]+>/g, "").trim().slice(0, 200)}`);
+      }
+    }
+    if (topics.length > 0) {
+      parts.push(`Related:
+${topics.join("\n")}`);
+    }
+  }
+  if (json.Results && json.Results.length > 0) {
+    const results = [];
+    for (const r2 of json.Results) {
+      if (results.length >= maxResults) break;
+      if (r2.Text && r2.FirstURL) {
+        results.push(`  - ${r2.Text.replace(/<[^>]+>/g, "").trim().slice(0, 200)}
+    ${r2.FirstURL}`);
+      }
+    }
+    if (results.length > 0) {
+      parts.push(`Web Results:
+${results.join("\n")}`);
+    }
+  }
+  if (parts.length === 0) {
+    return `No results found for "${query}". Try different keywords or be more specific.`;
+  }
+  return truncateOutput(parts.join("\n\n")).text;
+}
+var KNOWN_DOC_SITES = [
+  // JavaScript/TypeScript ecosystem
+  { patterns: ["node", "nodejs", "node.js"], sites: ["nodejs.org", "nodejs.dev"] },
+  { patterns: ["javascript", "js", "mozilla", "mdn"], sites: ["developer.mozilla.org"] },
+  { patterns: ["typescript", "ts"], sites: ["typescriptlang.org"] },
+  { patterns: ["react", "reactjs", "react.js"], sites: ["react.dev", "reactjs.org", "legacy.reactjs.org"] },
+  { patterns: ["express", "expressjs", "express.js"], sites: ["expressjs.com"] },
+  { patterns: ["next", "nextjs", "next.js"], sites: ["nextjs.org"] },
+  { patterns: ["vue", "vuejs", "vue.js"], sites: ["vuejs.org"] },
+  { patterns: ["svelte", "sveltekit"], sites: ["svelte.dev", "kit.svelte.dev"] },
+  { patterns: ["tailwind", "tailwindcss"], sites: ["tailwindcss.com"] },
+  { patterns: ["prisma"], sites: ["prisma.io"] },
+  { patterns: ["vite"], sites: ["vitejs.dev"] },
+  { patterns: ["esbuild"], sites: ["esbuild.github.io"] },
+  { patterns: ["webpack"], sites: ["webpack.js.org"] },
+  { patterns: ["babel"], sites: ["babeljs.io"] },
+  { patterns: ["eslint"], sites: ["eslint.org"] },
+  { patterns: ["prettier"], sites: ["prettier.io"] },
+  { patterns: ["jest"], sites: ["jestjs.io"] },
+  { patterns: ["vitest"], sites: ["vitest.dev"] },
+  { patterns: ["playwright"], sites: ["playwright.dev"] },
+  { patterns: ["cypress"], sites: ["cypress.io", "docs.cypress.io"] },
+  { patterns: ["graphql"], sites: ["graphql.org"] },
+  { patterns: ["apollo"], sites: ["apollographql.com"] },
+  { patterns: ["trpc"], sites: ["trpc.io"] },
+  { patterns: ["zod"], sites: ["github.com/colinhacks/zod", "zod.dev"] },
+  { patterns: ["axios"], sites: ["axios-http.com"] },
+  { patterns: ["npm"], sites: ["npmjs.com", "docs.npmjs.com"] },
+  { patterns: ["pnpm"], sites: ["pnpm.io"] },
+  { patterns: ["yarn"], sites: ["yarnpkg.com"] },
+  { patterns: ["deno"], sites: ["deno.com", "deno.land", "docs.deno.com"] },
+  { patterns: ["bun"], sites: ["bun.sh"] },
+  // Python
+  { patterns: ["python", "py"], sites: ["docs.python.org"] },
+  { patterns: ["django"], sites: ["djangoproject.com", "docs.djangoproject.com"] },
+  { patterns: ["flask"], sites: ["flask.palletsprojects.com"] },
+  { patterns: ["fastapi"], sites: ["fastapi.tiangolo.com"] },
+  { patterns: ["pydantic"], sites: ["docs.pydantic.dev"] },
+  { patterns: ["pytest"], sites: ["docs.pytest.org"] },
+  { patterns: ["poetry"], sites: ["python-poetry.org"] },
+  { patterns: ["numpy"], sites: ["numpy.org"] },
+  { patterns: ["pandas"], sites: ["pandas.pydata.org"] },
+  { patterns: ["sqlalchemy"], sites: ["docs.sqlalchemy.org"] },
+  { patterns: ["alembic"], sites: ["alembic.sqlalchemy.org"] },
+  // Rust
+  { patterns: ["rust", "cargo", "rustc"], sites: ["doc.rust-lang.org", "docs.rs"] },
+  { patterns: ["tokio"], sites: ["docs.rs/tokio", "tokio.rs"] },
+  { patterns: ["serde"], sites: ["docs.rs/serde", "serde.rs"] },
+  { patterns: ["actix"], sites: ["actix.rs", "docs.rs/actix-web"] },
+  { patterns: ["axum"], sites: ["docs.rs/axum"] },
+  { patterns: ["bevy"], sites: ["bevyengine.org", "docs.rs/bevy"] },
+  // Go
+  { patterns: ["go", "golang"], sites: ["pkg.go.dev", "go.dev"] },
+  { patterns: ["gin"], sites: ["gin-gonic.com", "pkg.go.dev/github.com/gin-gonic"] },
+  { patterns: ["echo"], sites: ["echo.labstack.com", "pkg.go.dev/github.com/labstack/echo"] },
+  { patterns: ["fiber"], sites: ["docs.gofiber.io", "pkg.go.dev/github.com/gofiber/fiber"] },
+  // Ruby
+  { patterns: ["ruby", "rubygems"], sites: ["ruby-doc.org", "rubygems.org"] },
+  { patterns: ["rails", "ruby on rails"], sites: ["guides.rubyonrails.org", "api.rubyonrails.org"] },
+  { patterns: ["rspec"], sites: ["rspec.info", "rubydoc.info"] },
+  // Other
+  { patterns: ["linux", "man"], sites: ["man7.org", "linux.die.net"] },
+  { patterns: ["git"], sites: ["git-scm.com"] },
+  { patterns: ["docker"], sites: ["docs.docker.com"] },
+  { patterns: ["kubernetes", "k8s"], sites: ["kubernetes.io"] },
+  { patterns: ["nginx"], sites: ["nginx.org", "nginx.com"] },
+  { patterns: ["postgresql", "postgres", "pg"], sites: ["postgresql.org"] },
+  { patterns: ["mysql"], sites: ["dev.mysql.com"] },
+  { patterns: ["redis"], sites: ["redis.io"] },
+  { patterns: ["mongodb", "mongo"], sites: ["mongodb.com", "docs.mongodb.com"] },
+  { patterns: ["sqlite"], sites: ["sqlite.org"] },
+  { patterns: ["aws"], sites: ["docs.aws.amazon.com"] }
+  // Add more as needed — this list guides the agent to official docs
+];
+function resolveDocSites(query, library) {
+  const searchTerms = (library ? `${library} ${query}` : query).toLowerCase();
+  const sites = [];
+  for (const entry of KNOWN_DOC_SITES) {
+    for (const pat of entry.patterns) {
+      if (searchTerms.includes(pat) && !sites.some((s2) => entry.sites.includes(s2))) {
+        sites.push(...entry.sites);
+        break;
+      }
+    }
+  }
+  return sites;
+}
+async function docsSearchTool(query, library, count, useSites = true) {
+  const maxResults = Math.min(Math.max(count ?? 5, 1), 8);
+  const sites = useSites ? resolveDocSites(query, library) : [];
+  let searchQuery;
+  if (library) {
+    searchQuery = `${library} ${query}`;
+  } else {
+    searchQuery = query;
+  }
+  if (sites.length > 0) {
+    const siteFilters = sites.map((s2) => `site:${s2}`).join(" OR ");
+    searchQuery = `${searchQuery} (${siteFilters})`;
+  } else {
+    searchQuery = `${searchQuery} documentation`;
+  }
+  const ddgUrl = `https://api.duckduckgo.com/?q=${encodeURIComponent(searchQuery)}&format=json&no_html=1&skip_disambig=1`;
+  let json;
+  try {
+    json = await httpsGetJSON(ddgUrl, 1e4);
+  } catch (err) {
+    return `Error: Docs search failed \u2014 ${err.message || err}`;
+  }
+  const parts = [];
+  const headerParts = [];
+  if (library) headerParts.push(`Library: ${library}`);
+  if (sites.length > 0) headerParts.push(`Sources: ${sites.join(", ")}`);
+  if (headerParts.length > 0) {
+    parts.push(headerParts.join(" | "));
+  }
+  if (json.Answer) {
+    parts.push(`Answer: ${json.Answer}`);
+  }
+  if (json.AbstractText && json.AbstractText.trim()) {
+    const abstract = json.AbstractText.trim();
+    const source = json.AbstractSource ? ` [${json.AbstractSource}]` : "";
+    const url = json.AbstractURL ? ` \u2014 ${json.AbstractURL}` : "";
+    parts.push(`Summary: ${abstract}${source}${url}`);
+  } else if (json.Abstract && json.Abstract.trim()) {
+    parts.push(`Summary: ${json.Abstract.trim()}`);
+  }
+  if (json.Definition) {
+    let def = `Definition: ${json.Definition}`;
+    if (json.DefinitionSource) def += ` [Source: ${json.DefinitionSource}]`;
+    parts.push(def);
+  }
+  if (json.RelatedTopics && json.RelatedTopics.length > 0) {
+    const topics = [];
+    for (const t2 of json.RelatedTopics) {
+      if (topics.length >= maxResults) break;
+      if (t2.Text && t2.FirstURL) {
+        const cleanText = t2.Text.replace(/<[^>]+>/g, "").trim();
+        topics.push(`  - ${cleanText.slice(0, 250)}
+    ${t2.FirstURL}`);
+      } else if (t2.Text) {
+        topics.push(`  - ${t2.Text.replace(/<[^>]+>/g, "").trim().slice(0, 250)}`);
+      }
+    }
+    if (topics.length > 0) {
+      parts.push(`Documentation Results:
+${topics.join("\n")}`);
+    }
+  }
+  if (json.Results && json.Results.length > 0) {
+    const results = [];
+    for (const r2 of json.Results) {
+      if (results.length >= maxResults) break;
+      if (r2.Text && r2.FirstURL) {
+        results.push(`  - ${r2.Text.replace(/<[^>]+>/g, "").trim().slice(0, 200)}
+    ${r2.FirstURL}`);
+      }
+    }
+    if (results.length > 0) {
+      parts.push(`More:
+${results.join("\n")}`);
+    }
+  }
+  const hasContent = parts.length > (headerParts.length > 0 ? 1 : 0);
+  if (!hasContent && sites.length > 0) {
+    return docsSearchTool(query, library, count, false);
+  }
+  if (!hasContent) {
+    return `No documentation results for "${query}". Try different terms or use web_search for broader results.`;
+  }
+  return truncateOutput(parts.join("\n\n")).text;
+}
 async function executeTool(call, workDir) {
   const { id, function: fn } = call;
   let args;
@@ -13802,6 +14204,60 @@ async function executeTool(call, workDir) {
     };
   }
   let result;
+  try {
+    switch (fn.name) {
+      case "bash":
+        if (typeof args.command !== "string" || args.command.length === 0) throw new Error('bash requires a non-empty "command" (string)');
+        if (args.timeout !== void 0 && typeof args.timeout !== "number") throw new Error('bash "timeout" must be a number');
+        break;
+      case "read":
+        if (typeof args.path !== "string" || args.path.length === 0) throw new Error('read requires a non-empty "path" (string)');
+        if (args.offset !== void 0 && typeof args.offset !== "number") throw new Error('read "offset" must be a number');
+        if (args.limit !== void 0 && typeof args.limit !== "number") throw new Error('read "limit" must be a number');
+        break;
+      case "edit":
+        if (typeof args.path !== "string" || args.path.length === 0) throw new Error('edit requires a non-empty "path" (string)');
+        if (!Array.isArray(args.edits)) throw new Error('edit "edits" must be an array');
+        if (args.edits.length === 0) throw new Error('edit "edits" must be non-empty');
+        for (let i2 = 0; i2 < args.edits.length; i2++) {
+          const e2 = args.edits[i2];
+          if (typeof e2.oldText !== "string") throw new Error(`edit "edits[${i2}].oldText" must be a string`);
+          if (typeof e2.newText !== "string") throw new Error(`edit "edits[${i2}].newText" must be a string`);
+        }
+        break;
+      case "write":
+        if (typeof args.path !== "string" || args.path.length === 0) throw new Error('write requires a non-empty "path" (string)');
+        if (typeof args.content !== "string") throw new Error('write requires "content" (string)');
+        break;
+      case "find":
+        if (typeof args.pattern !== "string" || args.pattern.length === 0) throw new Error('find requires a non-empty "pattern" (string)');
+        if (args.path !== void 0 && typeof args.path !== "string") throw new Error('find "path" must be a string');
+        break;
+      case "grep":
+        if (typeof args.pattern !== "string" || args.pattern.length === 0) throw new Error('grep requires a non-empty "pattern" (string)');
+        if (args.path !== void 0 && typeof args.path !== "string") throw new Error('grep "path" must be a string');
+        if (args.include !== void 0 && typeof args.include !== "string") throw new Error('grep "include" must be a string');
+        break;
+      case "stat":
+        if (typeof args.path !== "string" || args.path.length === 0) throw new Error('stat requires a non-empty "path" (string)');
+        break;
+      case "web_search":
+        if (typeof args.query !== "string" || args.query.length === 0) throw new Error('web_search requires a non-empty "query" (string)');
+        if (args.count !== void 0 && typeof args.count !== "number") throw new Error('web_search "count" must be a number');
+        break;
+      case "docs":
+        if (typeof args.query !== "string" || args.query.length === 0) throw new Error('docs requires a non-empty "query" (string)');
+        if (args.count !== void 0 && typeof args.count !== "number") throw new Error('docs "count" must be a number');
+        if (args.library !== void 0 && typeof args.library !== "string") throw new Error('docs "library" must be a string');
+        break;
+    }
+  } catch (validationErr) {
+    return {
+      tool_call_id: id,
+      role: "tool",
+      content: `Error: ${validationErr.message}`
+    };
+  }
   try {
     switch (fn.name) {
       case "bash":
@@ -13850,6 +14306,19 @@ async function executeTool(call, workDir) {
       case "stat":
         result = await statTool(args.path, workDir);
         break;
+      case "web_search":
+        result = await webSearchTool(
+          args.query,
+          args.count
+        );
+        break;
+      case "docs":
+        result = await docsSearchTool(
+          args.query,
+          args.library,
+          args.count
+        );
+        break;
       default:
         result = `Error: Unknown tool: ${fn.name}`;
     }
@@ -13865,7 +14334,7 @@ async function executeTool(call, workDir) {
 
 // src/crypto.ts
 import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, access as access2 } from "fs/promises";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, access as access2, chmod } from "fs/promises";
 import { constants as constants2 } from "fs";
 import { homedir, hostname, userInfo } from "os";
 import { join } from "path";
@@ -13873,21 +14342,39 @@ var ALGORITHM = "aes-256-gcm";
 var IV_LENGTH = 16;
 var TAG_LENGTH = 16;
 var SALT = "jawere-agent-key-vault-2026";
-function deriveKey() {
+var PEPPER_FILE = join(homedir(), ".jawere", ".pepper");
+async function loadOrCreatePepper() {
+  try {
+    await access2(PEPPER_FILE, constants2.R_OK);
+    return await readFile2(PEPPER_FILE);
+  } catch {
+    const pepper = randomBytes(32);
+    await mkdir2(join(homedir(), ".jawere"), { recursive: true });
+    await writeFile2(PEPPER_FILE, pepper);
+    try {
+      await chmod(PEPPER_FILE, 384);
+    } catch {
+    }
+    return pepper;
+  }
+}
+var _pepper = null;
+async function deriveKey() {
+  if (!_pepper) _pepper = await loadOrCreatePepper();
   const machineId = `${hostname()}-${userInfo().username}-jawere`;
-  return scryptSync(machineId, SALT, 32);
+  return scryptSync(machineId, Buffer.concat([Buffer.from(SALT), _pepper]), 32);
 }
-function encrypt(plaintext) {
-  const key = deriveKey();
+async function encrypt(plaintext) {
+  const key = await deriveKey();
   const iv = randomBytes(IV_LENGTH);
   const cipher = createCipheriv(ALGORITHM, key, iv);
   const encrypted = Buffer.concat([cipher.update(plaintext, "utf-8"), cipher.final()]);
   const tag = cipher.getAuthTag();
   return Buffer.concat([iv, tag, encrypted]).toString("base64");
 }
-function decrypt(encoded) {
+async function decrypt(encoded) {
   try {
-    const key = deriveKey();
+    const key = await deriveKey();
     const buf = Buffer.from(encoded, "base64");
     const iv = buf.subarray(0, IV_LENGTH);
     const tag = buf.subarray(IV_LENGTH, IV_LENGTH + TAG_LENGTH);
@@ -13903,14 +14390,22 @@ var KEY_FILE = join(homedir(), ".jawere", "key.enc");
 async function saveKey(apiKey) {
   const dir = join(homedir(), ".jawere");
   await mkdir2(dir, { recursive: true });
-  const encrypted = encrypt(apiKey.trim());
+  const encrypted = await encrypt(apiKey.trim());
   await writeFile2(KEY_FILE, encrypted, "utf-8");
+  try {
+    await chmod(KEY_FILE, 384);
+  } catch {
+  }
+  try {
+    await chmod(dir, 448);
+  } catch {
+  }
 }
 async function loadKey() {
   try {
     await access2(KEY_FILE, constants2.R_OK);
     const encrypted = await readFile2(KEY_FILE, "utf-8");
-    return decrypt(encrypted.trim());
+    return await decrypt(encrypted.trim());
   } catch {
     return null;
   }
@@ -13925,8 +14420,6 @@ async function hasKey() {
 }
 
 // src/config.ts
-var CONVEX_DEV = "https://dazzling-jackal-33.convex.cloud";
-var CONVEX_PROD = "https://friendly-pigeon-624.convex.cloud";
 function isDevMode() {
   if (process.env.NODE_ENV === "production") return false;
   if (process.env.NODE_ENV === "development") return true;
@@ -13955,7 +14448,6 @@ async function loadConfig() {
     apiKey,
     model: process.env.DEEPSEEK_MODEL || "deepseek-v4-pro",
     workDir: process.env.WORK_DIR || process.cwd(),
-    convexUrl: process.env.CONVEX_URL || (isDev ? CONVEX_DEV : CONVEX_PROD),
     keyFromFile,
     isDev
   };
@@ -14218,93 +14710,6 @@ function createSpinner() {
   return self;
 }
 
-// src/convex-client.ts
-async function convexMutation(convexUrl, name, args) {
-  const res = await fetch(`${convexUrl}/api/mutation`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ path: name, format: "json", args })
-  });
-  if (!res.ok) {
-    const err = await res.text();
-    throw new Error(`Convex mutation ${name} failed (${res.status}): ${err}`);
-  }
-  const json = await res.json();
-  if (json.status === "error") {
-    throw new Error(`Convex mutation ${name} error: ${json.errorMessage || JSON.stringify(json)}`);
-  }
-  return json.value;
-}
-async function convexQuery(convexUrl, name, args) {
-  const res = await fetch(`${convexUrl}/api/query`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ path: name, format: "json", args })
-  });
-  if (!res.ok) {
-    const err = await res.text();
-    throw new Error(`Convex query ${name} failed (${res.status}): ${err}`);
-  }
-  const json = await res.json();
-  if (json.status === "error") {
-    throw new Error(`Convex query ${name} error: ${json.errorMessage || JSON.stringify(json)}`);
-  }
-  return json.value;
-}
-async function createSession(convexUrl, title, model, systemPrompt, toolNames) {
-  return convexMutation(convexUrl, "sessions:create", {
-    title,
-    model,
-    systemPrompt,
-    toolNames
-  });
-}
-async function appendUserMessage(convexUrl, sessionId, text) {
-  return convexMutation(convexUrl, "sessions:appendMessage", {
-    sessionId,
-    role: "user",
-    content: [{ type: "text", text }],
-    timestamp: Date.now()
-  });
-}
-async function appendAssistantMessage(convexUrl, sessionId, text, toolCalls, usage) {
-  const content = [];
-  if (text) {
-    content.push({ type: "text", text });
-  }
-  if (toolCalls) {
-    for (const tc of toolCalls) {
-      content.push({
-        type: "tool_call",
-        id: tc.id,
-        name: tc.name,
-        arguments: tc.arguments
-      });
-    }
-  }
-  return convexMutation(convexUrl, "sessions:appendMessage", {
-    sessionId,
-    role: "assistant",
-    content,
-    timestamp: Date.now(),
-    usage
-  });
-}
-async function appendToolResult(convexUrl, sessionId, toolCallId, toolName, result, isError) {
-  return convexMutation(convexUrl, "sessions:appendMessage", {
-    sessionId,
-    role: "toolResult",
-    content: [{ type: "tool_result", toolCallId, content: result }],
-    toolCallId,
-    toolName,
-    isError,
-    timestamp: Date.now()
-  });
-}
-async function listSessions(convexUrl) {
-  return convexQuery(convexUrl, "sessions:list", {});
-}
-
 // src/agent.ts
 var MAX_TURNS = 500;
 var MAX_OUTPUT_TOKENS = 393216;
@@ -14312,11 +14717,20 @@ var COL = () => process.stdout.columns || 80;
 var GRUVBOX_GREEN = "\x1B[38;2;184;187;3m";
 var GRUVBOX_GRAY = "\x1B[38;2;146;131;116m";
 var GRUVBOX_RED = "\x1B[38;2;251;73;52m";
+var GRUVBOX_AQUA = "\x1B[38;2;142;192;124m";
 var RESET2 = "\x1B[0m";
 var FILE_TOOLS = /* @__PURE__ */ new Set(["read", "write", "edit", "stat"]);
+var SEARCH_TOOLS = /* @__PURE__ */ new Set(["web_search", "docs"]);
 var SILENT_TOOLS = /* @__PURE__ */ new Set(["diff"]);
 function toolDetail(name, args) {
   switch (name) {
+    case "web_search":
+      return String(args.query || "?");
+    case "docs": {
+      let d2 = String(args.query || "?");
+      if (args.library) d2 = `${args.library}: ${d2}`;
+      return d2;
+    }
     case "read": {
       let d2 = String(args.path || "?");
       if (args.offset) d2 += ` [L${args.offset}${args.limit ? `-${Number(args.offset) + Number(args.limit) - 1}` : "+"}]`;
@@ -14345,7 +14759,7 @@ function displayToolLine(name, args, ok, spin) {
   }
   const statusIcon = ok ? "\u2713" : "\u2717";
   const statusColor = ok ? GRUVBOX_GREEN : GRUVBOX_RED;
-  const toolColor = FILE_TOOLS.has(name) ? GRUVBOX_GREEN : GRUVBOX_GRAY;
+  const toolColor = SEARCH_TOOLS.has(name) ? GRUVBOX_AQUA : FILE_TOOLS.has(name) ? GRUVBOX_GREEN : GRUVBOX_GRAY;
   const prefix = `${toolColor}${name}${RESET2}: `;
   const suffix = ` ${statusColor}${statusIcon}${RESET2}`;
   let detail = toolDetail(name, args);
@@ -14355,13 +14769,6 @@ function displayToolLine(name, args, ok, spin) {
     spin.start("Working\u2026");
   }
 }
-async function safeCall(fn, label) {
-  try {
-    return await fn();
-  } catch {
-    return void 0;
-  }
-}
 async function withRetry(fn, maxRetries = 3, baseDelay = 1e3) {
   let lastErr;
   for (let i2 = 0; i2 <= maxRetries; i2++) {
@@ -14465,26 +14872,7 @@ async function runAgent(userMessage, options = {}) {
     baseURL: config.baseURL,
     apiKey: config.apiKey
   });
-  const toolNames = TOOL_DEFS.map((t2) => t2.function.name);
-  let sessionId = options.sessionId || "local";
-  const hasRealSession = sessionId !== "local";
-  const isNewSession = !options.sessionId;
-  if (isNewSession) {
-    const created = await safeCall(
-      () => createSession(
-        config.convexUrl,
-        options.title || userMessage.slice(0, 100),
-        config.model,
-        SYSTEM_PROMPT,
-        toolNames
-      ),
-      "createSession"
-    );
-    if (created) sessionId = created;
-  }
-  if (hasRealSession || sessionId !== "local") {
-    safeCall(() => appendUserMessage(config.convexUrl, sessionId, userMessage), "appendUserMessage");
-  }
+  const sessionId = options.sessionId || "local";
   const messages = [
     { role: "system", content: SYSTEM_PROMPT }
   ];
@@ -14574,21 +14962,6 @@ async function runAgent(userMessage, options = {}) {
     const hasToolCalls = streamedToolCalls.size > 0;
     if (hasToolCalls) {
       const toolCallArray = Array.from(streamedToolCalls.entries()).sort(([a2], [b2]) => a2 - b2).map(([_2, tc]) => tc);
-      const toolCallsMeta = toolCallArray.map((tc) => ({
-        id: tc.id,
-        name: tc.name,
-        arguments: tc.arguments
-      }));
-      safeCall(
-        () => appendAssistantMessage(
-          config.convexUrl,
-          sessionId,
-          streamedContent || null,
-          toolCallsMeta.length > 0 ? toolCallsMeta : null,
-          streamUsage
-        ),
-        "appendAssistantMessage"
-      );
       const openaiToolCalls = toolCallArray.map((tc) => ({
         id: tc.id,
         type: "function",
@@ -14626,34 +14999,17 @@ async function runAgent(userMessage, options = {}) {
           tool_call_id: result.tool_call_id,
           content: result.content
         });
-        const isError = !ok;
-        safeCall(
-          () => appendToolResult(
-            config.convexUrl,
-            sessionId,
-            result.tool_call_id,
-            tc.name,
-            result.content,
-            isError
-          ),
-          "appendToolResult"
-        );
       }
       continue;
     }
     spin.stop();
     const text = stripThinking(streamedContent) || "(empty response)";
-    safeCall(
-      () => appendAssistantMessage(config.convexUrl, sessionId, text, null, streamUsage),
-      "appendAssistantMessage"
-    );
     console.log("");
     printAssistantResponse(text);
     return { text, sessionId, history: messages };
   }
   spin.stop();
   const msg = "Agent reached maximum turns without completing the task.";
-  safeCall(() => appendAssistantMessage(config.convexUrl, sessionId, msg, null), "appendAssistantMessage");
   return { text: msg, sessionId, history: messages };
 }
 
@@ -15370,8 +15726,7 @@ function printHelp() {
   console.log(`
 ${G_GREEN}Commands:${R3}
   ${G_GRAY2}/help${R3}          Show this help
-  ${G_GRAY2}/sessions${R3}      List recent Convex sessions
-  ${G_GRAY2}/load${R3} <num>    Resume a session (run /sessions first)
+
   ${G_GRAY2}/key${R3}           Show API key status
   ${G_GRAY2}/setup${R3}         Re-enter API key
   ${G_GRAY2}/clear${R3}         Clear screen & start fresh session
@@ -15397,31 +15752,6 @@ async function setupKey() {
   await saveKey(key);
   console.log(`API key encrypted and saved to ~/.jawere/key.enc`);
 }
-async function showSessions(convexUrl) {
-  const map = /* @__PURE__ */ new Map();
-  try {
-    const sessions = await listSessions(convexUrl);
-    if (sessions.length === 0) {
-      console.log("No sessions found.");
-      return map;
-    }
-    console.log(`
-Recent sessions:`);
-    let i2 = 1;
-    for (const s2 of sessions) {
-      const date = new Date(s2.updatedAt).toLocaleString();
-      const shortId = s2._id.slice(0, 10);
-      console.log(`  ${i2}. ${shortId}\u2026  ${date}  ${s2.title.slice(0, 50)}`);
-      map.set(i2, s2._id);
-      i2++;
-    }
-    console.log(`
-Use /load <number> to resume a session.`);
-  } catch (err) {
-    console.log(`Error fetching sessions: ${err.message}`);
-  }
-  return map;
-}
 async function main() {
   const setupMode = process.argv.includes("--setup");
   const config = await loadConfig();
@@ -15463,7 +15793,6 @@ async function main() {
   }
   let currentSessionId;
   let conversationHistory = [];
-  let sessionMap = /* @__PURE__ */ new Map();
   let sessionShown = false;
   try {
     const codebaseDir = resolve3(config.workDir, ".codebase");
@@ -15512,35 +15841,12 @@ async function main() {
         case "help":
           printHelp();
           break;
-        case "sessions":
-          sessionMap = await showSessions(config.convexUrl);
-          break;
-        case "load":
-          if (arg) {
-            const num = parseInt(arg, 10);
-            if (!isNaN(num) && sessionMap.has(num)) {
-              currentSessionId = sessionMap.get(num);
-              conversationHistory = [];
-              sessionShown = true;
-              console.log(`Resumed session #${num}: ${currentSessionId?.slice(0, 12)}\u2026`);
-            } else if (arg.length > 10) {
-              currentSessionId = arg;
-              conversationHistory = [];
-              sessionShown = true;
-              console.log(`Resumed session: ${arg.slice(0, 12)}\u2026`);
-            } else {
-              console.log(`Session #${arg} not found. Run /sessions first.`);
-            }
-          } else {
-            console.log("Usage: /load <number>  (run /sessions first)");
-          }
-          break;
         case "key": {
           const savedKey = await loadKey();
           if (savedKey) {
-            console.log(`Key status: saved (encrypted) \u2014 ${savedKey.slice(0, 8)}...`);
+            console.log(`Key status: saved (encrypted) \u2014 ${savedKey.slice(0, 3)}...`);
           } else if (process.env.DEEPSEEK_API_KEY) {
-            console.log(`Key status: DEEPSEEK_API_KEY env var`);
+            console.log(`Key status: DEEPSEEK_API_KEY env var (starts ${process.env.DEEPSEEK_API_KEY.slice(0, 3)}...)`);
           } else {
             console.log(`Key status: NOT SET`);
           }

package/package.json

@@ -1,28 +1,21 @@
 {
   "name": "jawere",
-  "version": "1.5.1",
+  "version": "1.6.1",
   "type": "module",
   "bin": {
     "jawere": "bin/jawere.js"
   },
   "files": [
     "bin",
-    "dist",
-    "convex/_generated"
+    "dist"
   ],
   "scripts": {
     "start": "node --env-file .env.local --import tsx src/index.ts",
     "start:prod": "tsx src/index.ts",
     "build": "node scripts/build.js",
-    "dev": "npx convex dev",
-    "deploy:dev": "npx convex dev --env-file .env.local",
-    "deploy:prod": "npx convex deploy --env-file .env.prod",
-    "seed:dev": "CONVEX_URL=https://dazzling-jackal-33.convex.cloud tsx scripts/seed.ts",
-    "seed:prod": "CONVEX_URL=https://friendly-pigeon-624.convex.cloud tsx scripts/seed.ts",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "convex": "^1.42.1",
     "marked": "^18.0.5",
     "openai": "^4.73.0"
   },