@modeloslab/modelcode 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,1669 @@
+#!/usr/bin/env node
+// @bun
+import {
+  COLUMNS,
+  MAINNET,
+  MUTATING_TOOLS,
+  addCard,
+  addEntity,
+  addJob,
+  addRelation,
+  analyzeImpact,
+  buildTurnContext,
+  chat,
+  compactionThreshold,
+  contextStatus,
+  createTransfer,
+  decryptWallet,
+  encryptWallet,
+  estimateTokens,
+  exports_external,
+  findCompactionCut,
+  fireEvent,
+  generateMnemonic,
+  getTool,
+  globMatch,
+  globalDir,
+  imageToDataUrl,
+  impactSummary,
+  importWalletHex,
+  indexCodebase,
+  indexFile,
+  isImagePath,
+  isProtectedBuiltin,
+  listJobs,
+  loadProjectContext,
+  loadSubagents,
+  lspFor,
+  moveCard,
+  newTurn,
+  postToolUse,
+  preToolUse,
+  query,
+  recordCreate,
+  recordPatch,
+  recordTurn,
+  register,
+  rememberFact,
+  removeCard,
+  removeJob,
+  renderBoard,
+  renderDiff,
+  route,
+  runProc,
+  runSubagent,
+  runTeam,
+  searchFacts,
+  searchSessions,
+  snapshot,
+  spawnProc,
+  toolSchemas,
+  userPromptSubmit,
+  validateMnemonic,
+  walletFromMnemonic,
+  which
+} from "./main-2aqyq9g6.mjs";
+import"./main-p2xnn95s.mjs";
+import {
+  __require
+} from "./main-8y3fe7c3.mjs";
+
+// src/cli/main.ts
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+import { readFileSync as readFileSync8 } from "fs";
+
+// src/config/config.ts
+import { homedir } from "os";
+import { join } from "path";
+import { mkdirSync, existsSync, readFileSync, writeFileSync } from "fs";
+var MODELOS_API_BASE = "https://compute.modeloslab.xyz/api/v1";
+var ConfigSchema = exports_external.object({
+  provider: exports_external.string().default("modelos"),
+  apiKey: exports_external.string().optional(),
+  baseUrl: exports_external.string().default(MODELOS_API_BASE),
+  model: exports_external.string().default("gemini-2.5-flash"),
+  subagentModel: exports_external.string().optional(),
+  maxTokens: exports_external.number().int().positive().default(8192),
+  stream: exports_external.boolean().default(true),
+  autoRoute: exports_external.boolean().default(false),
+  autoReview: exports_external.boolean().default(false),
+  autoSummary: exports_external.boolean().default(true),
+  theme: exports_external.enum(["amber", "mono", "ocean"]).default("amber"),
+  teamMemoryUrl: exports_external.string().optional(),
+  spendCapMdl: exports_external.number().default(0),
+  providers: exports_external.record(exports_external.object({ baseUrl: exports_external.string(), apiKey: exports_external.string().optional(), model: exports_external.string().optional() })).default({})
+});
+function globalDir2() {
+  const base = process.env.MODELCODE_HOME || homedir();
+  const d = join(base, process.env.MODELCODE_HOME ? "" : ".modelcode");
+  if (!existsSync(d))
+    mkdirSync(d, { recursive: true, mode: 448 });
+  return d;
+}
+function projectDir(cwd = process.cwd()) {
+  return join(cwd, ".modelcode");
+}
+function loadConfig(cwd = process.cwd()) {
+  let raw = {};
+  for (const p of [join(globalDir2(), "config.json"), join(projectDir(cwd), "config.json")]) {
+    try {
+      if (existsSync(p))
+        raw = { ...raw, ...JSON.parse(readFileSync(p, "utf8")) };
+    } catch {}
+  }
+  const envKey = process.env.MODELCODE_API_KEY || process.env.MODELOS_API_KEY;
+  if (envKey)
+    raw.apiKey = envKey;
+  return ConfigSchema.parse(raw);
+}
+function saveConfig(patch) {
+  const p = join(globalDir2(), "config.json");
+  let cur = {};
+  try {
+    if (existsSync(p))
+      cur = JSON.parse(readFileSync(p, "utf8"));
+  } catch {}
+  writeFileSync(p, JSON.stringify({ ...cur, ...patch }, null, 2), { mode: 384 });
+}
+
+// src/tools/coreTools.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, statSync } from "fs";
+import { resolve, relative, isAbsolute } from "path";
+var MAX_READ = 400000;
+function inside(cwd, p) {
+  const abs = isAbsolute(p) ? p : resolve(cwd, p);
+  const rel = relative(cwd, abs);
+  if (rel.startsWith(".."))
+    throw new Error(`path escapes the working directory: ${p}`);
+  return abs;
+}
+var bash = {
+  name: "bash",
+  description: "Run a shell command in the working directory; returns combined stdout+stderr. Use for builds, tests, git, file ops.",
+  permission: "ask",
+  parameters: {
+    type: "object",
+    properties: {
+      command: { type: "string", description: "the shell command to run" },
+      timeout_ms: { type: "number", description: "max runtime in ms (default 120000)" }
+    },
+    required: ["command"]
+  },
+  async run(args, ctx) {
+    const cmd = String(args.command ?? "");
+    const timeout = Number(args.timeout_ms) || 120000;
+    const r = await runProc(["bash", "-lc", cmd], { cwd: ctx.cwd, timeoutMs: timeout, onChunk: (s) => ctx.onStream?.(s) });
+    return `exit ${r.code}
+${(r.stdout + (r.stderr ? `
+[stderr]
+${r.stderr}` : "")).slice(0, MAX_READ)}`;
+  }
+};
+var readFile = {
+  name: "read",
+  description: "Read a UTF-8 text file. Returns its contents (truncated if very large).",
+  permission: "safe",
+  parameters: {
+    type: "object",
+    properties: { path: { type: "string", description: "file path (relative to cwd or absolute within it)" } },
+    required: ["path"]
+  },
+  async run(args, ctx) {
+    const p = inside(ctx.cwd, String(args.path ?? ""));
+    if (!existsSync2(p))
+      return `error: no such file: ${args.path}`;
+    if (statSync(p).size > MAX_READ * 2)
+      return `error: file too large (> ${MAX_READ * 2} bytes)`;
+    return readFileSync2(p, "utf8").slice(0, MAX_READ);
+  }
+};
+var writeFile = {
+  name: "write",
+  description: "Create or overwrite a file with the given content. Prefer `edit` for changes to existing files.",
+  permission: "ask",
+  parameters: {
+    type: "object",
+    properties: { path: { type: "string" }, content: { type: "string" } },
+    required: ["path", "content"]
+  },
+  async run(args, ctx) {
+    const p = inside(ctx.cwd, String(args.path ?? ""));
+    writeFileSync2(p, String(args.content ?? ""));
+    return `wrote ${args.path} (${String(args.content ?? "").length} chars)`;
+  }
+};
+var edit = {
+  name: "edit",
+  description: "Diff-based edit: replace an exact unique string with a new one (fast path, no full rewrite).",
+  permission: "ask",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string" },
+      old_string: { type: "string", description: "exact text to replace (must be unique in the file)" },
+      new_string: { type: "string", description: "replacement text" },
+      replace_all: { type: "boolean", description: "replace every occurrence (default false)" }
+    },
+    required: ["path", "old_string", "new_string"]
+  },
+  async run(args, ctx) {
+    const p = inside(ctx.cwd, String(args.path ?? ""));
+    if (!existsSync2(p))
+      return `error: no such file: ${args.path}`;
+    const src = readFileSync2(p, "utf8");
+    const oldS = String(args.old_string ?? "");
+    const newS = String(args.new_string ?? "");
+    if (oldS === "")
+      return "error: old_string is empty";
+    const count = src.split(oldS).length - 1;
+    if (count === 0)
+      return "error: old_string not found";
+    if (count > 1 && !args.replace_all)
+      return `error: old_string matches ${count}x - make it unique or set replace_all`;
+    const updated = args.replace_all ? src.split(oldS).join(newS) : src.replace(oldS, newS);
+    writeFileSync2(p, updated);
+    return `edited ${args.path} (${count} replacement${count === 1 ? "" : "s"})
+${renderDiff(oldS, newS, String(args.path))}`;
+  }
+};
+var glob = {
+  name: "glob",
+  description: "List files matching a glob pattern (e.g. 'src/**/*.ts').",
+  permission: "safe",
+  parameters: { type: "object", properties: { pattern: { type: "string" } }, required: ["pattern"] },
+  async run(args, ctx) {
+    const matches = globMatch(ctx.cwd, String(args.pattern ?? "**/*"), 1000);
+    return matches.join(`
+`) || "(no matches)";
+  }
+};
+var grep = {
+  name: "grep",
+  description: "Search file contents for a regex (ripgrep). Returns matching path:line:text.",
+  permission: "safe",
+  parameters: {
+    type: "object",
+    properties: { pattern: { type: "string" }, path: { type: "string", description: "dir/file (default cwd)" } },
+    required: ["pattern"]
+  },
+  async run(args, ctx) {
+    const pat = String(args.pattern ?? "");
+    const where = args.path ? inside(ctx.cwd, String(args.path)) : ctx.cwd;
+    const tool = which("rg") ? `rg -n --no-heading -e ${JSON.stringify(pat)} ${JSON.stringify(where)}` : `grep -rnE ${JSON.stringify(pat)} ${JSON.stringify(where)}`;
+    const r = await runProc(["bash", "-lc", `${tool} 2>/dev/null | head -200`], { cwd: ctx.cwd });
+    return r.stdout.trim() || "(no matches)";
+  }
+};
+function registerCoreTools() {
+  for (const t of [bash, readFile, writeFile, edit, glob, grep])
+    register(t);
+}
+
+// src/memory/tools.ts
+var CATEGORIES = ["identity", "role", "project", "preference", "constraint", "interest", "style"];
+var remember = {
+  name: "remember",
+  description: "Save a durable fact to long-term memory (persists across sessions). Use for user preferences, project facts, conventions, and anything worth recalling later.",
+  permission: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      text: { type: "string", description: "the fact, stated concisely" },
+      category: { type: "string", enum: CATEGORIES, description: "fact category (default project)" }
+    },
+    required: ["text"]
+  },
+  async run(args, ctx) {
+    const cat = CATEGORIES.includes(String(args.category)) ? String(args.category) : "project";
+    rememberFact(String(args.text ?? ""), cat, ctx.cwd);
+    return `remembered [${cat}]: ${String(args.text ?? "").slice(0, 120)}`;
+  }
+};
+var recall = {
+  name: "recall",
+  description: "Search long-term memory (facts + past sessions) for something relevant to the current task.",
+  permission: "safe",
+  parameters: {
+    type: "object",
+    properties: { query: { type: "string", description: "what to look up" } },
+    required: ["query"]
+  },
+  async run(args, ctx) {
+    const q = String(args.query ?? "");
+    const facts = searchFacts(q, 8, ctx.cwd, true).map((f) => `• [${f.category}]${f.project ? " (project)" : ""} ${f.text}`);
+    const sessions = searchSessions(q, 5).map((s) => `· (${new Date(s.created_at).toLocaleDateString()}) ${s.text.slice(0, 200)}`);
+    const out = [];
+    if (facts.length)
+      out.push("FACTS:", ...facts);
+    if (sessions.length)
+      out.push("PAST SESSIONS:", ...sessions);
+    return out.length ? out.join(`
+`) : "(nothing relevant in memory)";
+  }
+};
+function registerMemoryTools() {
+  register(remember);
+  register(recall);
+}
+
+// src/tools/agentTool.ts
+function registerAgentTool(cfg, onProgress) {
+  const agents = loadSubagents();
+  const names = [...agents.keys()];
+  const agentTool = {
+    name: "agent",
+    description: "Delegate a task to a specialized subagent that runs in its own isolated context and returns its " + "conclusion. Available subagents: " + names.join(", ") + ". Use for focused work (exploration, " + "planning, review, debugging, research) to keep the main thread clean.",
+    permission: "safe",
+    parameters: {
+      type: "object",
+      properties: {
+        subagent_type: { type: "string", description: "which subagent to run", enum: names },
+        prompt: { type: "string", description: "the task/question for the subagent" }
+      },
+      required: ["subagent_type", "prompt"]
+    },
+    async run(args, ctx) {
+      const agent = agents.get(String(args.subagent_type ?? ""));
+      if (!agent)
+        return `error: unknown subagent '${args.subagent_type}'. available: ${names.join(", ")}`;
+      const { text, feeGrains } = await runSubagent(cfg, agent, String(args.prompt ?? ""), ctx, onProgress);
+      return `[${agent.name} · ${(feeGrains / 1e8).toFixed(6)} MDL · free/uncapped]
+${text}`;
+    }
+  };
+  register(agentTool);
+  const teamTool = {
+    name: "team",
+    description: "Convene a TEAM of subagents on one task — they share a channel and message each other across a " + "few rounds (coordinate, build on, and challenge each other), then return the full transcript for " + "you to synthesize. Members from: " + names.join(", ") + ".",
+    permission: "safe",
+    parameters: {
+      type: "object",
+      properties: {
+        members: { type: "array", items: { type: "string", enum: names }, description: "subagents to put on the team" },
+        prompt: { type: "string", description: "the shared task" },
+        rounds: { type: "number", description: "messaging rounds (default 2)" }
+      },
+      required: ["members", "prompt"]
+    },
+    async run(args, ctx) {
+      const members = Array.isArray(args.members) ? args.members.map(String) : [];
+      const { transcript, feeGrains } = await runTeam(cfg, members, String(args.prompt ?? ""), ctx, Number(args.rounds) || 2, onProgress);
+      return `[team · ${(feeGrains / 1e8).toFixed(6)} MDL · free/uncapped]
+${transcript}`;
+    }
+  };
+  register(teamTool);
+}
+
+// src/agent/loop.ts
+var MAX_STEPS = 50;
+var SYSTEM = `You are modelcode, a coding agent running on modelOS (decentralized, pay-per-use in MDL).
+You work in the user's repository via tools: read/write/edit files, run bash, glob, grep.
+Be concise. Prefer the diff-based 'edit' tool over rewriting whole files. Verify with bash (build/tests)
+when relevant. Explain what you changed in one or two lines.
+
+Memory & self-improvement: call 'remember' to save durable facts (preferences, project conventions) and
+'recall' to look them up. After solving a non-trivial, repeatable task, use 'skill_manager' to distill it
+into a reusable skill so it's a /command next time. Delegate focused work to subagents via 'agent', and
+convene 'team' for multi-perspective reviews.
+
+Tool discipline (important): call each tool ONCE for a given action — never repeat an identical tool call.
+A tool result is authoritative: once a write/edit succeeds, trust it and move on. Do NOT claim a task is
+done in the same message where you call the tool to do it — call the tool first, then confirm only after
+you see its result. Keep confirmations to one short sentence.`;
+
+class Agent {
+  cfg;
+  ctx;
+  h;
+  history;
+  constructor(cfg, ctx, h) {
+    this.cfg = cfg;
+    this.ctx = ctx;
+    this.h = h;
+    this.history = [{ role: "system", content: SYSTEM + loadProjectContext(ctx.cwd) }];
+  }
+  mode = "default";
+  get planMode() {
+    return this.mode === "plan";
+  }
+  set planMode(on) {
+    this.mode = on ? "plan" : "default";
+  }
+  lastTurnToolCount = 0;
+  abortController = null;
+  abort() {
+    this.abortController?.abort();
+  }
+  get running() {
+    return this.abortController !== null;
+  }
+  injectedContext = new Set;
+  sessionStart = Date.now();
+  note(text) {
+    this.history.push({ role: "system", content: `User steering note (apply going forward): ${text}` });
+  }
+  get messages() {
+    return [...this.history];
+  }
+  restore(saved) {
+    if (!saved.length)
+      return;
+    const head = this.history[0];
+    const rest = saved[0]?.role === "system" ? saved.slice(1) : saved;
+    this.history = [head, ...rest];
+    this.injectedContext.clear();
+  }
+  reset() {
+    this.history = [this.history[0]];
+    this.injectedContext.clear();
+  }
+  compact(summary) {
+    this.history = [this.history[0], { role: "system", content: `Summary of earlier conversation: ${summary}` }];
+    this.injectedContext.clear();
+  }
+  modelFor(userText = "") {
+    if (this.cfg.autoRoute && userText) {
+      const r = route(userText);
+      if (r)
+        return r.model;
+    }
+    return this.cfg.model;
+  }
+  contextStatus() {
+    return contextStatus(this.history, this.modelFor());
+  }
+  async autoCompact(model) {
+    if (estimateTokens(this.history) < compactionThreshold(model))
+      return false;
+    const keep = Number(process.env.MODELCODE_COMPACT_KEEP || "10");
+    const cut = findCompactionCut(this.history, keep);
+    if (cut < 0)
+      return false;
+    await fireEvent("preCompact", this.ctx.cwd).catch(() => {});
+    const head = this.history[0];
+    const middle = this.history.slice(1, cut);
+    const tail = this.history.slice(cut);
+    const rendered = middle.map((m) => {
+      const tc = m.tool_calls;
+      const body = typeof m.content === "string" ? m.content : tc ? `(tool calls: ${tc.map((c) => c.function?.name).join(", ")})` : "";
+      return `${m.role}: ${body}`.slice(0, 4000);
+    }).join(`
+`);
+    let summary = "";
+    try {
+      const res = await chat(this.cfg, [
+        { role: "system", content: "Summarize this conversation segment into a concise but COMPLETE brief that a coding agent can resume from: the task/goal, decisions made, files changed (with paths), key facts/values, and any open threads. Preserve specifics; omit chatter." },
+        { role: "user", content: rendered.slice(0, 60000) }
+      ], [], () => {}, this.cfg.model, 90000);
+      summary = (res.content || "").trim();
+    } catch {}
+    const note = summary ? `Summary of earlier conversation (auto-compacted to free context):
+${summary}` : "Earlier conversation was auto-compacted to free context (summary unavailable).";
+    this.history = [head, { role: "system", content: note }, ...tail];
+    this.injectedContext.clear();
+    this.h.onCompact?.(contextStatus(this.history, model));
+    return true;
+  }
+  async send(userText, imagePaths = []) {
+    const promptGate = await userPromptSubmit(userText, this.ctx.cwd);
+    if (!promptGate.allowed) {
+      this.h.onToolResult("hook", `prompt blocked: ${promptGate.reason}`);
+      return;
+    }
+    if (promptGate.inject)
+      this.history.push({ role: "system", content: `[hook] ${promptGate.inject}` });
+    const modelForTurn = this.modelFor(userText);
+    await this.autoCompact(modelForTurn);
+    const turnCtx = buildTurnContext(userText, this.ctx.cwd, { injected: this.injectedContext, sessionStart: this.sessionStart });
+    if (turnCtx)
+      this.history.push({ role: "system", content: turnCtx });
+    const parts = imagePaths.map((p) => imageToDataUrl(p)).filter((u) => !!u).map((url) => ({ type: "image_url", image_url: { url } }));
+    this.history.push(parts.length ? { role: "user", content: [{ type: "text", text: userText }, ...parts] } : { role: "user", content: userText });
+    recordTurn(this.ctx.cwd, "user", userText);
+    newTurn();
+    this._doneCalls.clear();
+    const ac = this.abortController = new AbortController;
+    const signal = ac.signal;
+    let turnGrains = 0;
+    let toolCount = 0;
+    let editedCode = false;
+    if (this.cfg.autoRoute && modelForTurn !== this.cfg.model) {
+      this.h.onToolResult("router", `→ ${modelForTurn}`);
+    }
+    try {
+      for (let step = 0;step < MAX_STEPS; step++) {
+        if (signal.aborted) {
+          this.h.onToolResult("interrupt", "⎋ interrupted");
+          break;
+        }
+        await this.autoCompact(modelForTurn);
+        const res = await chat(this.cfg, this.history, toolSchemas(), this.h.onAssistantDelta, modelForTurn, undefined, signal);
+        turnGrains += res.feeGrains;
+        this.history.push({
+          role: "assistant",
+          content: res.toolCalls.length ? null : res.content || null,
+          ...res.toolCalls.length ? { tool_calls: res.toolCalls } : {}
+        });
+        if (res.content && !res.toolCalls.length)
+          recordTurn(this.ctx.cwd, "assistant", res.content);
+        if (!res.toolCalls.length)
+          break;
+        const safeCalls = res.toolCalls.filter((c) => getTool(c.function.name)?.permission === "safe");
+        const seqCalls = res.toolCalls.filter((c) => getTool(c.function.name)?.permission !== "safe");
+        const results = new Map;
+        await Promise.all(safeCalls.map(async (c) => results.set(c.id, await this.execToolCall(c))));
+        for (const c of seqCalls)
+          results.set(c.id, await this.execToolCall(c));
+        const cap = Number(process.env.MODELCODE_MAX_TOOL_RESULT || "40000");
+        for (const call of res.toolCalls) {
+          const r = results.get(call.id) ?? { content: "error: tool did not run", edited: false };
+          if (r.edited)
+            editedCode = true;
+          let content = r.content;
+          if (content.length > cap) {
+            const head = content.slice(0, Math.floor(cap * 0.7));
+            const tail = content.slice(-Math.floor(cap * 0.2));
+            content = `${head}
+
+…[truncated ${content.length - head.length - tail.length} chars to fit context]…
+
+${tail}`;
+          }
+          this.history.push({ role: "tool", tool_call_id: call.id, name: call.function.name, content });
+          toolCount++;
+        }
+      }
+    } catch (e) {
+      if (signal.aborted || e?.name === "AbortError")
+        this.h.onToolResult("interrupt", "⎋ interrupted");
+      else
+        throw e;
+    } finally {
+      this.abortController = null;
+    }
+    this.h.onCost(turnGrains);
+    this.lastTurnToolCount = toolCount;
+    if (toolCount >= 5 && !this._suggested) {
+      this._suggested = true;
+      this.h.onSuggestSkill?.(toolCount);
+    }
+    if (editedCode && this.cfg.autoReview) {
+      try {
+        const reviewer = loadSubagents(this.ctx.cwd).get("code-reviewer");
+        if (reviewer) {
+          const { text } = await runSubagent(this.cfg, reviewer, "Review the current working-tree diff (git diff). Report bugs + cleanups by severity with file:line.", this.ctx);
+          this.h.onReview?.(text);
+        }
+      } catch {}
+    }
+  }
+  _suggested = false;
+  _doneCalls = new Map;
+  async execToolCall(call) {
+    const tool = getTool(call.function.name);
+    let args = {};
+    try {
+      args = call.function.arguments ? JSON.parse(call.function.arguments) : {};
+    } catch {}
+    const sig = `${call.function.name}:${JSON.stringify(args)}`;
+    if (this._doneCalls.has(sig)) {
+      return { content: `already done this turn (identical call) → ${this._doneCalls.get(sig).slice(0, 200)}`, edited: false };
+    }
+    if (!tool)
+      return { content: `error: unknown tool '${call.function.name}'`, edited: false };
+    this.h.onToolStart(tool.name, args);
+    let result;
+    let edited = false;
+    if (this.mode === "plan" && tool.permission !== "safe") {
+      result = "blocked: plan mode is on (read-only). Finish planning, then /mode (or /exit-plan) to allow changes.";
+    } else {
+      const gate = await preToolUse(tool.name, args, this.ctx.cwd);
+      const isEdit = MUTATING_TOOLS.has(tool.name);
+      const needsConfirm = tool.permission !== "safe" && this.mode !== "yolo" && !(this.mode === "acceptEdits" && isEdit);
+      if (!gate.allowed) {
+        result = `blocked by hook: ${gate.reason}`;
+      } else if (needsConfirm && !await this.h.confirm(tool.name, args)) {
+        result = "denied by user";
+      } else {
+        if (MUTATING_TOOLS.has(tool.name) && typeof args.path === "string")
+          snapshot(this.ctx.cwd, args.path);
+        const runCtx = { ...this.ctx, onStream: (c) => this.h.onToolStream?.(c) };
+        try {
+          result = await tool.run(args, runCtx);
+        } catch (e) {
+          result = `error: ${e.message}`;
+        }
+        if (MUTATING_TOOLS.has(tool.name) && typeof args.path === "string" && !result.startsWith("error")) {
+          try {
+            indexFile(this.ctx.cwd, args.path);
+          } catch {}
+          edited = true;
+        }
+        const post = await postToolUse(tool.name, result, this.ctx.cwd);
+        if (post)
+          result += `
+[hook] ${post}`;
+      }
+    }
+    this.h.onToolResult(tool.name, result);
+    if (!result.startsWith("error") && !result.startsWith("denied") && !result.startsWith("blocked"))
+      this._doneCalls.set(sig, result);
+    return { content: result, edited };
+  }
+}
+
+// src/skills/manager.ts
+import { join as join2 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, rmSync, readFileSync as readFileSync3 } from "fs";
+var NAME_RE = /^[a-z0-9][a-z0-9-]{1,48}$/;
+function userSkillsDir() {
+  const d = join2(globalDir(), "skills");
+  if (!existsSync3(d))
+    mkdirSync2(d, { recursive: true });
+  return d;
+}
+function skillDir(name) {
+  return join2(userSkillsDir(), name);
+}
+function writeSkill(spec, origin) {
+  if (!NAME_RE.test(spec.name))
+    throw new Error("skill name must be kebab-case (a-z, 0-9, -)");
+  if (!spec.description?.trim())
+    throw new Error("skill needs a description");
+  if (!spec.body?.trim())
+    throw new Error("skill needs instructions (body)");
+  const dir = skillDir(spec.name);
+  const existed = existsSync3(join2(dir, "SKILL.md"));
+  mkdirSync2(dir, { recursive: true });
+  const md = `---
+name: ${spec.name}
+description: ${spec.description.trim()}
+---
+
+${spec.body.trim()}
+`;
+  writeFileSync3(join2(dir, "SKILL.md"), md);
+  existed ? recordPatch(spec.name) : recordCreate(spec.name, origin);
+  return `${existed ? "updated" : "created"} skill /${spec.name}`;
+}
+function deleteSkill(name) {
+  if (isProtectedBuiltin(name))
+    throw new Error(`'${name}' is a protected builtin and can't be deleted`);
+  const dir = skillDir(name);
+  if (!existsSync3(dir))
+    throw new Error(`no user skill named '${name}'`);
+  rmSync(dir, { recursive: true, force: true });
+  return `deleted skill /${name}`;
+}
+var skillManager = {
+  name: "skill_manager",
+  description: "Create, update, or delete a reusable skill (a SKILL.md callable as /<name>). Use `create` to " + "distill a successful multi-step approach into a repeatable procedure for next time.",
+  permission: "ask",
+  parameters: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["create", "update", "delete"] },
+      name: { type: "string", description: "kebab-case skill name" },
+      description: { type: "string" },
+      body: { type: "string", description: "step-by-step instructions (markdown)" }
+    },
+    required: ["action", "name"]
+  },
+  async run(args) {
+    const action = String(args.action);
+    const name = String(args.name ?? "");
+    if (action === "delete")
+      return deleteSkill(name);
+    return writeSkill({ name, description: String(args.description ?? ""), body: String(args.body ?? "") }, "agent");
+  }
+};
+function registerSkillManager() {
+  register(skillManager);
+}
+
+// src/cli/mentions.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join3 } from "path";
+function expandFileMentions(line, cwd) {
+  const mentions = [...line.matchAll(/(?:^|\s)@([\w./\-]+)/g)].map((m) => m[1]).filter(Boolean);
+  if (!mentions.length)
+    return line;
+  const blocks = [];
+  for (const rel of mentions) {
+    if (isImagePath(rel))
+      continue;
+    try {
+      const p = join3(cwd, rel);
+      if (existsSync4(p))
+        blocks.push(`
+
+--- @${rel} ---
+${readFileSync4(p, "utf8").slice(0, 50000)}`);
+    } catch {}
+  }
+  return blocks.length ? line + blocks.join("") : line;
+}
+function imageMentions(line, cwd) {
+  return [...line.matchAll(/(?:^|\s)@([\w./\-]+)/g)].map((m) => m[1]).filter(Boolean).filter(isImagePath).map((rel) => join3(cwd, rel)).filter((p) => existsSync4(p));
+}
+
+// src/wallet/credits.ts
+var COMPUTE = process.env.MODELOS_COMPUTE || "https://compute.modeloslab.xyz";
+async function creditBalance(address) {
+  try {
+    const r = await fetch(`${COMPUTE}/api/v1/credits/balance?address=${encodeURIComponent(address)}`, { signal: AbortSignal.timeout(6000) });
+    if (!r.ok)
+      return null;
+    const j = await r.json();
+    const grains = Number(j?.balance_grains ?? 0);
+    return { grains, mdl: grains / 1e8 };
+  } catch {
+    return null;
+  }
+}
+async function claimDeposit(apiKey, address, txid) {
+  try {
+    const r = await fetch(`${COMPUTE}/api/v1/credits/claim`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+      body: JSON.stringify({ walletAddr: address, txid }),
+      signal: AbortSignal.timeout(15000)
+    });
+    const j = await r.json().catch(() => ({}));
+    if (!r.ok)
+      return { ok: false, message: j.error || `claim failed (HTTP ${r.status})` };
+    return { ok: true, message: `credited ${(Number(j.credited_grains ?? 0) / 1e8).toFixed(6)} MDL` };
+  } catch (e) {
+    return { ok: false, message: e.message };
+  }
+}
+var FUND_INSTRUCTIONS = "Fund credits in one command: `modelcode credits fund <mdl>` (signs from your CLI wallet, broadcasts, " + "and claims automatically). Or send MDL manually to the deposit address and run `credits claim <addr> <txid>`.";
+var EXPLORER = process.env.MODELOS_EXPLORER || "https://explorer.modeloslab.xyz";
+async function registerApiKey(walletAddr, label = "modelcode CLI") {
+  const rnd = crypto.getRandomValues(new Uint8Array(24));
+  const apiKey = "mdlk_" + Array.from(rnd).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const r = await fetch(`${COMPUTE}/api/v1/keys/register`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ apiKey, walletAddr, label }),
+    signal: AbortSignal.timeout(1e4)
+  });
+  const j = await r.json().catch(() => ({}));
+  if (!r.ok || j.error)
+    throw new Error(j.error || `key registration failed (HTTP ${r.status})`);
+  return { apiKey, depositAddr: j.depositAddr ?? "" };
+}
+async function accountInfo(address) {
+  try {
+    const r = await fetch(`${COMPUTE}/api/v1/credits/balance?address=${encodeURIComponent(address)}`, { signal: AbortSignal.timeout(6000) });
+    if (!r.ok)
+      return null;
+    const j = await r.json();
+    if (!j.deposit_addr)
+      return null;
+    return { grains: Number(j.balance_grains ?? 0), depositAddr: j.deposit_addr };
+  } catch {
+    return null;
+  }
+}
+async function fetchUtxos(address) {
+  const r = await fetch(`${EXPLORER}/api/v2/utxo/${address}`, { signal: AbortSignal.timeout(8000) });
+  if (!r.ok)
+    return [];
+  return (await r.json()).map((u) => ({ txid: u.txid, vout: u.vout, value: BigInt(u.value || "0") }));
+}
+async function broadcast(hex) {
+  const r = await fetch(`${COMPUTE}/api/chain/broadcast`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ hex }),
+    signal: AbortSignal.timeout(15000)
+  });
+  const j = await r.json().catch(() => ({}));
+  if (!r.ok || j.error)
+    throw new Error(j.error || `broadcast failed (HTTP ${r.status})`);
+  if (!j.txid)
+    throw new Error("broadcast returned no txid");
+  return j.txid;
+}
+
+// src/tools/moreTools.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync5 } from "fs";
+import { resolve as resolve2 } from "path";
+function stripHtml(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&[a-z]+;/g, " ").replace(/\s+/g, " ").trim();
+}
+function assertPublicUrl(raw) {
+  let u;
+  try {
+    u = new URL(raw);
+  } catch {
+    throw new Error(`invalid URL: ${raw}`);
+  }
+  if (u.protocol !== "http:" && u.protocol !== "https:")
+    throw new Error(`blocked scheme: ${u.protocol}`);
+  const h = u.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  const blocked = h === "localhost" || h.endsWith(".localhost") || h === "metadata.google.internal" || /^(0|127|10)\./.test(h) || /^169\.254\./.test(h) || /^192\.168\./.test(h) || /^172\.(1[6-9]|2\d|3[01])\./.test(h) || /^(::1|fe80:|fc00:|fd[0-9a-f]{2}:)/.test(h) || h === "0.0.0.0" || h === "::";
+  if (blocked)
+    throw new Error(`blocked host (SSRF guard): ${u.hostname}`);
+  return u;
+}
+var webFetch = {
+  name: "web_fetch",
+  description: "Fetch a URL and return its readable text content.",
+  permission: "ask",
+  parameters: { type: "object", properties: { url: { type: "string" } }, required: ["url"] },
+  async run(args) {
+    try {
+      const u = assertPublicUrl(String(args.url));
+      const r = await fetch(u, { signal: AbortSignal.timeout(15000), headers: { "User-Agent": "modelcode" } });
+      const ct = r.headers.get("content-type") || "";
+      const body = await r.text();
+      return (ct.includes("html") ? stripHtml(body) : body).slice(0, 20000);
+    } catch (e) {
+      return `error: ${e.message}`;
+    }
+  }
+};
+var webSearch = {
+  name: "web_search",
+  description: "Search the web (DuckDuckGo) and return top result titles + URLs.",
+  permission: "ask",
+  parameters: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+  async run(args) {
+    try {
+      const r = await fetch(`https://duckduckgo.com/html/?q=${encodeURIComponent(String(args.query))}`, { signal: AbortSignal.timeout(15000), headers: { "User-Agent": "Mozilla/5.0 modelcode" } });
+      const html = await r.text();
+      const cleanUrl = (href) => {
+        const u = href.replace(/^.*uddg=/, "").replace(/&(amp;)?rut=.*$/i, "");
+        try {
+          return decodeURIComponent(u);
+        } catch {
+          return u;
+        }
+      };
+      const hits = [...html.matchAll(/result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/g)].slice(0, 8).map((m) => `${stripHtml(m[2] ?? "")} — ${cleanUrl(m[1] ?? "")}`);
+      return hits.join(`
+`) || "(no results)";
+    } catch (e) {
+      return `error: ${e.message}`;
+    }
+  }
+};
+var notebookEdit = {
+  name: "notebook_edit",
+  description: "Edit a Jupyter .ipynb cell: replace the source of the cell at the given index.",
+  permission: "ask",
+  parameters: { type: "object", properties: { path: { type: "string" }, cell: { type: "number" }, source: { type: "string" } }, required: ["path", "cell", "source"] },
+  async run(args, ctx) {
+    const p = resolve2(ctx.cwd, String(args.path));
+    if (!existsSync5(p))
+      return `error: no such notebook: ${args.path}`;
+    const nb = JSON.parse(readFileSync5(p, "utf8"));
+    const i = Number(args.cell);
+    if (!nb.cells?.[i])
+      return `error: cell ${i} out of range (${nb.cells?.length ?? 0} cells)`;
+    nb.cells[i].source = String(args.source).split(/(?<=\n)/);
+    writeFileSync4(p, JSON.stringify(nb, null, 1));
+    return `edited cell ${i} of ${args.path}`;
+  }
+};
+var sshExec = {
+  name: "ssh_exec",
+  description: "Run a command on a remote host over SSH (uses your ssh config/keys). host like user@server.",
+  permission: "ask",
+  parameters: { type: "object", properties: { host: { type: "string" }, command: { type: "string" } }, required: ["host", "command"] },
+  async run(args) {
+    const r = await runProc(["ssh", "-o", "BatchMode=yes", String(args.host), String(args.command)]);
+    return `exit ${r.code}
+${(r.stdout + (r.stderr ? `
+[stderr]
+${r.stderr}` : "")).slice(0, 20000)}`;
+  }
+};
+var lsp = {
+  name: "lsp",
+  description: "Language-server queries: 'definition' / 'references' / 'hover' at a file position, or 'diagnostics' for a file. Real LSP (precise), not text search.",
+  permission: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["definition", "references", "hover", "diagnostics"] },
+      path: { type: "string" },
+      line: { type: "number", description: "0-based line (for definition/references/hover)" },
+      character: { type: "number", description: "0-based column" }
+    },
+    required: ["action", "path"]
+  },
+  async run(args, ctx) {
+    const file = String(args.path);
+    const action = String(args.action);
+    const srv = lspFor(file, ctx.cwd);
+    if (!srv) {
+      const cmds = [
+        existsSync5(resolve2(ctx.cwd, "tsconfig.json")) && "npx -y typescript tsc --noEmit",
+        existsSync5(resolve2(ctx.cwd, "go.mod")) && "go vet ./...",
+        existsSync5(resolve2(ctx.cwd, "Cargo.toml")) && "cargo check -q"
+      ].filter(Boolean);
+      if (action === "diagnostics" && cmds.length) {
+        const r = await runProc(["bash", "-lc", `${cmds[0]} 2>&1 | head -120`], { cwd: ctx.cwd });
+        return `(no language server installed; shelled typecheck)
+${r.stdout.trim() || "no diagnostics"}`;
+      }
+      return "no language server for this file type (install e.g. typescript-language-server, pyright, gopls)";
+    }
+    const ln = Number(args.line) || 0, ch = Number(args.character) || 0;
+    try {
+      if (action === "diagnostics") {
+        const d = await srv.diags(file);
+        return d.length ? d.map((x) => `${file}:${x.range.start.line + 1}:${x.range.start.character + 1} [${x.severity === 1 ? "error" : "warn"}] ${x.message}`).join(`
+`) : "no diagnostics";
+      }
+      if (action === "hover") {
+        const h = await srv.hover(file, ln, ch);
+        const c = h?.contents;
+        return (typeof c === "string" ? c : c?.value ?? JSON.stringify(c)) || "(no hover info)";
+      }
+      const locs = action === "definition" ? await srv.definition(file, ln, ch) : await srv.references(file, ln, ch);
+      const arr = Array.isArray(locs) ? locs : locs ? [locs] : [];
+      return arr.length ? arr.map((l) => `${decodeURIComponent((l.uri || "").replace("file://", ""))}:${(l.range?.start?.line ?? 0) + 1}:${(l.range?.start?.character ?? 0) + 1}`).join(`
+`) : "(none found)";
+    } catch (e) {
+      return `lsp error: ${e.message}`;
+    }
+  }
+};
+var browserExtract = {
+  name: "browser",
+  description: "Open a page and extract its main readable content (baseline; interactive automation is on the roadmap).",
+  permission: "ask",
+  parameters: { type: "object", properties: { url: { type: "string" } }, required: ["url"] },
+  run: webFetch.run
+};
+var kgQueryTool = {
+  name: "kg_query",
+  description: "Query the knowledge graph (entities + relationships) — semantic memory AND the codebase graph (files/symbols).",
+  permission: "safe",
+  parameters: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+  async run(args) {
+    const hits = query(String(args.query), 8);
+    if (!hits.length)
+      return "(nothing in the graph)";
+    return hits.map((h) => `• ${h.entity.kind}:${h.entity.name}${h.entity.data ? ` (${h.entity.data})` : ""}` + (h.relations.length ? `
+   → ${h.relations.map((r) => `${r.rel} ${r.dst}`).join(", ")}` : "")).join(`
+`);
+  }
+};
+var kgIndexTool = {
+  name: "kg_index",
+  description: "Index this repository into the knowledge graph (files + symbols + contains edges) for structural recall.",
+  permission: "safe",
+  parameters: { type: "object", properties: {} },
+  async run(_args, ctx) {
+    const r = await indexCodebase(ctx.cwd);
+    return `indexed ${r.files} files, ${r.symbols} symbols into the knowledge graph`;
+  }
+};
+var kgRemember = {
+  name: "kg_relate",
+  description: "Add an entity or a relationship to the knowledge graph (e.g. decision/component facts).",
+  permission: "safe",
+  parameters: { type: "object", properties: { kind: { type: "string" }, name: { type: "string" }, data: { type: "string" }, rel: { type: "string", description: "optional relationship" }, to_kind: { type: "string" }, to_name: { type: "string" } }, required: ["kind", "name"] },
+  async run(args) {
+    const id = addEntity(String(args.kind), String(args.name), String(args.data ?? ""));
+    if (args.rel && args.to_kind && args.to_name) {
+      const d = addEntity(String(args.to_kind), String(args.to_name));
+      addRelation(id, String(args.rel), d);
+    }
+    return `added ${id}`;
+  }
+};
+var kgImpactTool = {
+  name: "kg_impact",
+  description: "Impact analysis BEFORE changing a symbol: shows where it's declared + which files reference it (callers/usages). Call this before refactoring/renaming/changing a function/class/type so you know the blast radius.",
+  permission: "safe",
+  parameters: { type: "object", properties: { symbol: { type: "string", description: "the function/class/type/const name to analyze" } }, required: ["symbol"] },
+  async run(args, ctx) {
+    return impactSummary(analyzeImpact(ctx.cwd, String(args.symbol ?? "").trim()));
+  }
+};
+function registerMoreTools() {
+  for (const t of [webFetch, webSearch, notebookEdit, sshExec, lsp, browserExtract, kgQueryTool, kgIndexTool, kgRemember, kgImpactTool])
+    register(t);
+}
+
+// src/tools/browser.ts
+import { existsSync as existsSync6 } from "fs";
+var CHROME_CANDIDATES = [
+  process.env.MODELCODE_CHROME,
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/Applications/Chromium.app/Contents/MacOS/Chromium",
+  "/usr/bin/google-chrome",
+  "/usr/bin/chromium",
+  "/usr/bin/chromium-browser"
+].filter(Boolean);
+function chromePath() {
+  return CHROME_CANDIDATES.find((p) => existsSync6(p)) ?? null;
+}
+var _browser = null;
+var _page = null;
+async function page() {
+  if (_page)
+    return _page;
+  const exe = chromePath();
+  if (!exe)
+    throw new Error("no Chrome/Chromium found — set MODELCODE_CHROME to its path");
+  const puppeteer = (await import("./puppeteer-core-qdv3v3fq.mjs")).default;
+  _browser = await puppeteer.launch({ executablePath: exe, headless: true, args: ["--no-sandbox"] });
+  _page = await _browser.newPage();
+  return _page;
+}
+async function closeBrowser() {
+  try {
+    await _browser?.close();
+  } catch {} finally {
+    _browser = null;
+    _page = null;
+  }
+}
+var browserTool = {
+  name: "browser_action",
+  description: "Drive a headless browser: navigate to a URL, extract readable text, click/type a CSS selector, or screenshot. Use for JS-rendered pages, flows, and scraping.",
+  permission: "ask",
+  parameters: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["navigate", "extract", "click", "type", "screenshot"] },
+      url: { type: "string", description: "for navigate" },
+      selector: { type: "string", description: "CSS selector for click/type/extract scope" },
+      text: { type: "string", description: "text to type" },
+      path: { type: "string", description: "screenshot output path" }
+    },
+    required: ["action"]
+  },
+  async run(args, ctx) {
+    try {
+      const p = await page();
+      switch (String(args.action)) {
+        case "navigate":
+          await p.goto(String(args.url), { waitUntil: "networkidle2", timeout: 30000 });
+          return `navigated to ${args.url} — title: ${await p.title()}`;
+        case "extract": {
+          const sel = args.selector ? String(args.selector) : "body";
+          const txt = await p.$eval(sel, (el) => el.innerText).catch(() => "");
+          return txt.slice(0, 20000) || "(no text)";
+        }
+        case "click":
+          await p.click(String(args.selector));
+          return `clicked ${args.selector}`;
+        case "type":
+          await p.type(String(args.selector), String(args.text ?? ""));
+          return `typed into ${args.selector}`;
+        case "screenshot": {
+          const out = args.path ? `${ctx.cwd}/${args.path}` : `${ctx.cwd}/screenshot-${Date.now()}.png`;
+          await p.screenshot({ path: out });
+          return `saved screenshot ${out}`;
+        }
+        default:
+          return `unknown action '${args.action}'`;
+      }
+    } catch (e) {
+      return `browser error: ${e.message}`;
+    }
+  }
+};
+function registerBrowserTool() {
+  register(browserTool);
+}
+
+// src/lsp/client.ts
+import { join as join4, extname } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { pathToFileURL } from "url";
+class LspServer {
+  cwd;
+  proc;
+  id = 1;
+  pending = new Map;
+  diagnostics = new Map;
+  buf = Buffer.alloc(0);
+  opened = new Set;
+  ready;
+  constructor(cmd, cwd) {
+    this.cwd = cwd;
+    const parts = cmd.split(" ");
+    this.proc = spawnProc(parts, { cwd });
+    this.readLoop();
+    this.ready = this.initialize();
+  }
+  send(msg) {
+    const body = Buffer.from(JSON.stringify(msg), "utf8");
+    const header = Buffer.from(`Content-Length: ${body.length}\r
+\r
+`, "ascii");
+    this.proc.stdin?.write(Buffer.concat([header, body]));
+  }
+  request(method, params) {
+    const id = this.id++;
+    this.send({ jsonrpc: "2.0", id, method, params });
+    return new Promise((resolve3, reject) => {
+      this.pending.set(id, { resolve: resolve3, reject });
+      setTimeout(() => {
+        if (this.pending.delete(id))
+          reject(new Error(`LSP ${method} timed out`));
+      }, 20000);
+    });
+  }
+  notify(method, params) {
+    this.send({ jsonrpc: "2.0", method, params });
+  }
+  readLoop() {
+    this.proc.stdout?.on("data", (value) => {
+      this.buf = Buffer.concat([this.buf, value]);
+      for (;; ) {
+        const sep = this.buf.indexOf(`\r
+\r
+`);
+        if (sep === -1)
+          break;
+        const header = this.buf.subarray(0, sep).toString("ascii");
+        const m = header.match(/Content-Length:\s*(\d+)/i);
+        if (!m) {
+          this.buf = this.buf.subarray(sep + 4);
+          continue;
+        }
+        const len = Number(m[1]);
+        const start = sep + 4;
+        if (this.buf.length < start + len)
+          break;
+        const body = this.buf.subarray(start, start + len).toString("utf8");
+        this.buf = this.buf.subarray(start + len);
+        try {
+          this.dispatch(JSON.parse(body));
+        } catch {}
+      }
+    });
+  }
+  dispatch(msg) {
+    if (msg.id !== undefined && this.pending.has(msg.id)) {
+      const p = this.pending.get(msg.id);
+      this.pending.delete(msg.id);
+      msg.error ? p.reject(new Error(msg.error.message)) : p.resolve(msg.result);
+    } else if (msg.method === "textDocument/publishDiagnostics") {
+      this.diagnostics.set(msg.params.uri, msg.params.diagnostics ?? []);
+    }
+  }
+  async initialize() {
+    await this.request("initialize", {
+      processId: process.pid,
+      rootUri: pathToFileURL(this.cwd).href,
+      capabilities: { textDocument: { publishDiagnostics: {}, definition: {}, references: {}, hover: {} } }
+    });
+    this.notify("initialized", {});
+  }
+  uri(file) {
+    return pathToFileURL(join4(this.cwd, file)).href;
+  }
+  async openDoc(file) {
+    const uri = this.uri(file);
+    if (!this.opened.has(uri)) {
+      const text = readFileSync6(join4(this.cwd, file), "utf8");
+      const languageId = extname(file).replace(/^\./, "");
+      this.notify("textDocument/didOpen", { textDocument: { uri, languageId, version: 1, text } });
+      this.opened.add(uri);
+      await new Promise((r) => setTimeout(r, 600));
+    }
+    return uri;
+  }
+  async definition(file, line, character) {
+    await this.ready;
+    const uri = await this.openDoc(file);
+    return this.request("textDocument/definition", { textDocument: { uri }, position: { line, character } });
+  }
+  async references(file, line, character) {
+    await this.ready;
+    const uri = await this.openDoc(file);
+    return this.request("textDocument/references", { textDocument: { uri }, position: { line, character }, context: { includeDeclaration: true } });
+  }
+  async hover(file, line, character) {
+    await this.ready;
+    const uri = await this.openDoc(file);
+    return this.request("textDocument/hover", { textDocument: { uri }, position: { line, character } });
+  }
+  async diags(file) {
+    await this.ready;
+    const uri = await this.openDoc(file);
+    return this.diagnostics.get(uri) ?? [];
+  }
+  close() {
+    try {
+      this.proc.kill();
+    } catch {}
+  }
+}
+var _servers = new Map;
+function closeAllLsp() {
+  for (const s of _servers.values())
+    s.close();
+  _servers.clear();
+}
+
+// src/tools/taskTools.ts
+var kanban = {
+  name: "kanban",
+  description: "Track multi-step work on a kanban board: add/move/list/remove cards across todo→doing→review→done. Resumable across sessions.",
+  permission: "safe",
+  parameters: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["add", "move", "list", "remove"] },
+      title: { type: "string" },
+      body: { type: "string" },
+      id: { type: "number" },
+      column: { type: "string", enum: COLUMNS }
+    },
+    required: ["action"]
+  },
+  async run(args, ctx) {
+    switch (String(args.action)) {
+      case "add": {
+        const c = addCard(ctx.cwd, String(args.title ?? "untitled"), String(args.body ?? ""));
+        return `added #${c.id} "${c.title}" → todo`;
+      }
+      case "move": {
+        if (!args.id || !args.column)
+          return "need id + column";
+        moveCard(Number(args.id), String(args.column));
+        return `moved #${args.id} → ${args.column}`;
+      }
+      case "remove": {
+        if (!args.id)
+          return "need id";
+        removeCard(Number(args.id));
+        return `removed #${args.id}`;
+      }
+      default:
+        return renderBoard(ctx.cwd) || "(board empty)";
+    }
+  }
+};
+var schedule = {
+  name: "schedule",
+  description: "Schedule a task: run a prompt later/repeatedly. schedule is interval seconds ('300') or a 5-field cron string ('0 9 * * 1'). Use to set up background or recurring work.",
+  permission: "ask",
+  parameters: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["add", "list", "remove"] },
+      name: { type: "string" },
+      schedule: { type: "string" },
+      prompt: { type: "string" },
+      id: { type: "number" }
+    },
+    required: ["action"]
+  },
+  async run(args, ctx) {
+    switch (String(args.action)) {
+      case "add": {
+        if (!args.schedule || !args.prompt)
+          return "need schedule + prompt";
+        const j = addJob(String(args.name ?? "job"), String(args.schedule), String(args.prompt), ctx.cwd);
+        return `scheduled #${j.id} "${j.name}" — next run ${new Date(j.next_run).toLocaleString()}`;
+      }
+      case "remove": {
+        if (!args.id)
+          return "need id";
+        removeJob(Number(args.id));
+        return `removed job #${args.id}`;
+      }
+      default: {
+        const js = listJobs();
+        return js.length ? js.map((j) => `#${j.id} ${j.name} [${j.schedule}] next ${new Date(j.next_run).toLocaleString()} ${j.last_status ? "· " + j.last_status : ""}`).join(`
+`) : "(no scheduled jobs)";
+      }
+    }
+  }
+};
+function registerTaskTools() {
+  register(kanban);
+  register(schedule);
+}
+
+// src/tips/tips.ts
+var FREQUENCY = Math.max(1, Number(process.env.MODELCODE_TIP_FREQUENCY || "1"));
+
+// src/wallet/store.ts
+import { join as join5 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+function walletPath() {
+  return join5(globalDir(), "wallet.json");
+}
+function walletExists() {
+  return existsSync8(walletPath());
+}
+function walletAddress() {
+  try {
+    return JSON.parse(readFileSync7(walletPath(), "utf8")).address;
+  } catch {
+    return null;
+  }
+}
+async function createNew(password) {
+  const mnemonic = generateMnemonic(128);
+  const w = walletFromMnemonic(mnemonic, MAINNET);
+  writeFileSync5(walletPath(), JSON.stringify(await encryptWallet(w, password), null, 2), { mode: 384 });
+  return { address: w.address, mnemonic };
+}
+async function importWallet(secret, password) {
+  const s = secret.trim();
+  let w;
+  if (/^(0x)?[0-9a-fA-F]{64}$/.test(s))
+    w = importWalletHex(s, MAINNET);
+  else if (validateMnemonic(s))
+    w = walletFromMnemonic(s, MAINNET);
+  else
+    throw new Error("not a valid BIP-39 phrase or 64-char private-key hex");
+  writeFileSync5(walletPath(), JSON.stringify(await encryptWallet(w, password), null, 2), { mode: 384 });
+  return { address: w.address };
+}
+async function loadWallet(password) {
+  if (!walletExists())
+    throw new Error("no wallet — run `modelcode wallet new` or `wallet import`");
+  const enc = JSON.parse(readFileSync7(walletPath(), "utf8"));
+  return decryptWallet(enc, password, MAINNET);
+}
+// src/cli/main.ts
+var C = { dim: "\x1B[2m", green: "\x1B[32m", amber: "\x1B[33m", cyan: "\x1B[36m", reset: "\x1B[0m", bold: "\x1B[1m" };
+var grainsToMdl = (g) => (g / 1e8).toFixed(6);
+async function login() {
+  const rl = createInterface({ input: stdin, output: stdout });
+  const ok = await interactiveLogin(rl, loadConfig());
+  rl.close();
+  if (!ok)
+    process.exit(1);
+}
+async function interactiveLogin(rl, cfg) {
+  stdout.write(`How would you like to start?
+` + `  ${C.cyan}1${C.reset}) paste an existing API key (mdlk_\u2026)
+` + `  ${C.cyan}2${C.reset}) create a wallet + API key  ${C.dim}(fund the wallet to buy credits)${C.reset}
+` + `  ${C.cyan}3${C.reset}) skip for now
+`);
+  const choice = (await rl.question(`${C.green}choose 1-3\u203A${C.reset} `)).trim();
+  if (choice === "1" || choice.startsWith("mdlk_")) {
+    const key = choice.startsWith("mdlk_") ? choice : (await rl.question("API key (mdlk_\u2026): ")).trim();
+    if (!key.startsWith("mdlk_")) {
+      stdout.write(`${C.amber}that doesn't look like an mdlk_ key${C.reset}
+`);
+      return false;
+    }
+    saveConfig({ apiKey: key });
+    cfg.apiKey = key;
+    stdout.write(`${C.green}\u2713 logged in${C.reset} (key saved to ~/.modelcode/config.json)
+`);
+    return true;
+  }
+  if (choice === "2") {
+    if (walletExists()) {
+      stdout.write(`${C.dim}a wallet already exists; registering a key for it\u2026${C.reset}
+`);
+    }
+    let address = walletAddress() ?? "";
+    if (!address) {
+      const pw = (await rl.question("set a wallet password: ")).trim();
+      if (!pw) {
+        stdout.write(`${C.amber}password required${C.reset}
+`);
+        return false;
+      }
+      const r = await createNew(pw);
+      address = r.address;
+      stdout.write(`${C.green}\u2713 wallet created${C.reset}  ${address}
+` + `${C.amber}RECOVERY PHRASE (write it down, shown once):${C.reset}
+  ${r.mnemonic}
+`);
+    }
+    try {
+      const { apiKey, depositAddr } = await registerApiKey(address);
+      saveConfig({ apiKey });
+      cfg.apiKey = apiKey;
+      stdout.write(`${C.green}\u2713 API key created + saved${C.reset}
+` + `${C.dim}To buy credits: send MDL to your wallet, then run ${C.reset}modelcode credits fund <mdl>${C.dim} ` + `(it funds the API bank ${depositAddr ? depositAddr.slice(0, 16) + "\u2026" : ""} and claims credits).${C.reset}
+`);
+      return true;
+    } catch (e) {
+      stdout.write(`${C.amber}key registration failed: ${e.message}${C.reset}
+`);
+      return false;
+    }
+  }
+  stdout.write(`${C.dim}(skipped \u2014 /help works; paste a key anytime to run prompts)${C.reset}
+`);
+  return false;
+}
+async function maybeAutoKey(address) {
+  const cfg = loadConfig();
+  if (cfg.apiKey) {
+    stdout.write(`${C.dim}(an API key is already configured; keeping it)${C.reset}
+`);
+    return;
+  }
+  const rl = createInterface({ input: stdin, output: stdout });
+  const ans = (await rl.question("Generate an API key for this wallet now (use the internal wallet for inference)? [Y/n] ")).trim().toLowerCase();
+  rl.close();
+  if (ans === "n" || ans === "no")
+    return;
+  try {
+    const { apiKey, depositAddr } = await registerApiKey(address);
+    saveConfig({ apiKey });
+    stdout.write(`${C.green}API key created & saved${C.reset} (${apiKey.slice(0, 12)}\u2026)
+` + `deposit address: ${depositAddr}
+fund it in one command: ${C.cyan}modelcode credits fund <mdl>${C.reset}
+`);
+  } catch (e) {
+    stdout.write(`${C.amber}could not auto-create key: ${e.message}${C.reset}
+`);
+  }
+}
+async function password(prompt = "Wallet password: ") {
+  if (process.env.MODELCODE_WALLET_PASSWORD)
+    return process.env.MODELCODE_WALLET_PASSWORD;
+  const rl = createInterface({ input: stdin, output: stdout });
+  const p = await rl.question(prompt);
+  rl.close();
+  return p;
+}
+async function walletCmd(sub, arg) {
+  if (sub === "new") {
+    if (walletExists()) {
+      stdout.write(`a wallet already exists (~/.modelcode/wallet.json). Remove it first to replace.
+`);
+      return;
+    }
+    const pw = await password("Set a password to encrypt the wallet: ");
+    const { address, mnemonic } = await createNew(pw);
+    stdout.write(`${C.green}wallet created${C.reset}
+address: ${address}
+
+${C.amber}RECOVERY PHRASE (write it down, shown once):${C.reset}
+${mnemonic}
+`);
+    await maybeAutoKey(address);
+  } else if (sub === "import") {
+    if (!arg) {
+      stdout.write(`usage: modelcode wallet import "<12/24-word phrase>" | <privkey-hex>
+`);
+      return;
+    }
+    const pw = await password("Set a password to encrypt the wallet: ");
+    const { address } = await importWallet(arg, pw);
+    stdout.write(`${C.green}wallet imported${C.reset}
+address: ${address}
+`);
+    await maybeAutoKey(address);
+  } else if (sub === "address") {
+    stdout.write((walletAddress() ?? "no wallet \u2014 `modelcode wallet new`") + `
+`);
+  } else if (sub === "balance") {
+    const addr = walletAddress();
+    if (!addr) {
+      stdout.write(`no wallet
+`);
+      return;
+    }
+    const utxos = await fetchUtxos(addr);
+    const total = utxos.reduce((s, u) => s + u.value, 0n);
+    stdout.write(`on-chain: ${(Number(total) / 1e8).toFixed(6)} MDL across ${utxos.length} UTXO(s)
+address: ${addr}
+`);
+  } else if (sub === "export") {
+    const pw = await password();
+    try {
+      const w = await loadWallet(pw);
+      stdout.write(`${C.amber}KEEP SECRET${C.reset}
+address: ${w.address}
+private key: ${Buffer.from(w.privateKey).toString("hex")}
+${w.mnemonic ? "phrase: " + w.mnemonic + `
+` : ""}`);
+    } catch (e) {
+      stdout.write(`${C.amber}${e.message}${C.reset}
+`);
+    }
+  } else {
+    stdout.write(`wallet commands: new | import <secret> | address | balance | export
+`);
+  }
+}
+async function fundCmd(cfg, mdlStr) {
+  const mdl = Number(mdlStr);
+  if (!cfg.apiKey) {
+    stdout.write("login first (`modelcode login`)\n");
+    return;
+  }
+  if (!walletExists()) {
+    stdout.write("no wallet \u2014 `modelcode wallet new` or `wallet import` first\n");
+    return;
+  }
+  if (!(mdl > 0)) {
+    stdout.write(`usage: modelcode credits fund <mdl>
+`);
+    return;
+  }
+  const pw = await password();
+  const w = await loadWallet(pw);
+  const info = await accountInfo(w.address);
+  if (!info) {
+    stdout.write(`could not reach the credits API / get the deposit address
+`);
+    return;
+  }
+  const utxos = await fetchUtxos(w.address);
+  if (!utxos.length) {
+    stdout.write(`wallet ${w.address} has no funds. Send MDL to it first.
+`);
+    return;
+  }
+  const amount = BigInt(Math.round(mdl * 1e8));
+  stdout.write(`${C.dim}signing transfer of ${mdl} MDL \u2192 bank ${info.depositAddr.slice(0, 16)}\u2026${C.reset}
+`);
+  const built = createTransfer(w, utxos, info.depositAddr, amount);
+  const txid = await broadcast(built.hex);
+  stdout.write(`${C.green}broadcast${C.reset} txid ${txid}
+`);
+  const deadline = Date.now() + 6 * 60000;
+  stdout.write(`${C.dim}waiting for confirmation, then claiming as credits\u2026${C.reset}
+`);
+  for (let i = 0;; i++) {
+    const r = await claimDeposit(cfg.apiKey, w.address, txid);
+    if (r.ok) {
+      stdout.write(`${C.green}\u2713 ${r.message}${C.reset}
+`);
+      return;
+    }
+    if (!/confirmation/i.test(r.message)) {
+      stdout.write(`${C.amber}\u2717 ${r.message}${C.reset}
+`);
+      return;
+    }
+    if (Date.now() >= deadline) {
+      stdout.write(`${C.amber}deposit broadcast but not yet confirmed \u2014 finish later with:${C.reset}
+` + `  modelcode credits claim ${w.address} ${txid}
+`);
+      return;
+    }
+    if (i === 0)
+      stdout.write(`${C.dim}  ${r.message} \u2014 retrying\u2026${C.reset}
+`);
+    await new Promise((res) => setTimeout(res, 12000));
+  }
+}
+async function main() {
+  const [cmd, sub, arg] = process.argv.slice(2);
+  const cfg = loadConfig();
+  if (cmd === "login")
+    return login();
+  if (cmd === "config") {
+    stdout.write(JSON.stringify({ ...cfg, apiKey: cfg.apiKey ? "mdlk_\u2026(set)" : undefined }, null, 2) + `
+`);
+    return;
+  }
+  if (cmd === "wallet")
+    return walletCmd(sub ?? "", arg);
+  async function launchTui(resume) {
+    if (!cfg.apiKey) {
+      const rl = createInterface({ input: stdin, output: stdout });
+      await interactiveLogin(rl, cfg);
+      rl.close();
+    }
+    if (!cfg.apiKey)
+      return;
+    const { runTui } = await import("./tui-0r2q70wm.mjs");
+    return runTui(cfg, resume);
+  }
+  if (cmd === "tui")
+    return launchTui("none");
+  if (cmd === "credits") {
+    if (sub === "fund")
+      return void await fundCmd(cfg, arg ?? "");
+    if (sub === "claim") {
+      const claimAddr = arg, claimTxid = process.argv[5];
+      if (!claimAddr || !claimTxid) {
+        stdout.write(`usage: modelcode credits claim <address> <txid>
+`);
+        return;
+      }
+      if (!cfg.apiKey) {
+        stdout.write("No API key. Run `modelcode login` first.\n");
+        return;
+      }
+      const r = await claimDeposit(cfg.apiKey, claimAddr, claimTxid);
+      stdout.write(`${r.ok ? C.green + "\u2713 " : C.amber + "\u2717 "}${r.message}${C.reset}
+`);
+      return;
+    }
+    const addr = walletAddress();
+    const b = addr ? await creditBalance(addr) : null;
+    stdout.write(b ? `credits: ${b.mdl.toFixed(6)} MDL (wallet ${addr})
+` : `${FUND_INSTRUCTIONS}
+`);
+    return;
+  }
+  if (cmd === "-p" || cmd === "--print" || cmd === "run" && sub) {
+    if (!cfg.apiKey) {
+      stdout.write("No API key. Run `modelcode login` first.\n");
+      process.exit(1);
+    }
+    const promptArg = (cmd === "run" ? process.argv.slice(3) : process.argv.slice(3)).join(" ").trim();
+    const prompt = promptArg || (!stdin.isTTY ? readFileSync8(0, "utf8").trim() : "");
+    if (!prompt) {
+      stdout.write(`usage: modelcode -p "<prompt>"
+`);
+      process.exit(1);
+    }
+    return runOnce(cfg, prompt);
+  }
+  const resumeMode = cmd === "--continue" || cmd === "-c" ? "continue" : cmd === "--resume" || cmd === "-r" ? "resume" : "none";
+  return launchTui(resumeMode);
+}
+async function runOnce(cfg, prompt) {
+  const ctx = { cwd: process.cwd() };
+  registerCoreTools();
+  registerMemoryTools();
+  registerAgentTool(cfg);
+  registerSkillManager();
+  registerMoreTools();
+  registerBrowserTool();
+  registerTaskTools();
+  let cost = 0;
+  const agent = new Agent(cfg, ctx, {
+    onAssistantDelta: (t) => stdout.write(t),
+    onToolStart: (n, a) => stdout.write(`
+${C.dim}\u2699 ${n} ${JSON.stringify(a).slice(0, 100)}${C.reset}
+`),
+    onToolResult: () => {},
+    onCost: (g) => {
+      cost += g;
+    },
+    confirm: async () => true
+  });
+  try {
+    await agent.send(expandFileMentions(prompt, ctx.cwd), imageMentions(prompt, ctx.cwd));
+  } catch (e) {
+    stdout.write(`
+error: ${e.message}
+`);
+    process.exitCode = 1;
+  } finally {
+    stdout.write(`
+${C.dim}\u2014 ${grainsToMdl(cost)} MDL${C.reset}
+`);
+    await closeBrowser();
+    closeAllLsp();
+  }
+}
+main().catch((e) => {
+  stdout.write(`fatal: ${e?.message ?? e}
+`);
+  process.exit(1);
+});