anycodex 0.0.26 → 0.0.27

package/dist/{chunk-2X6YJUFL.js → chunk-LDC53EZT.js}

@@ -4,33 +4,22 @@ import {
   ModelID,
   ProviderID,
   Todo,
-  iife
-} from "./chunk-4SPBQLA5.js";
-import {
-  Identifier,
-  MessageID,
-  PartID
-} from "./chunk-6Q6QFZOB.js";
-import {
-  Flag,
-  NamedError,
   basename,
-  consoleLogger,
   dirname,
   extname,
   isAbsolute,
   join,
   relative,
   resolve
-} from "./chunk-NRFXEZ7N.js";
+} from "./chunk-47OV6PTE.js";
 import {
-  Schema_exports,
+  Identifier,
+  MessageID,
+  PartID,
   __callDispose,
   __using,
-  external_exports,
-  withStatics,
   zod_default
-} from "./chunk-M6C7CWX3.js";
+} from "./chunk-RKAEZ54R.js";
 import {
   __commonJS
 } from "./chunk-77HVPD4G.js";
@@ -5080,32 +5069,32 @@ var require_URL = __commonJS({
           else
             return basepath.substring(0, lastslash + 1) + refpath;
         }
-        function remove_dot_segments(path) {
-          if (!path) return path;
+        function remove_dot_segments(path3) {
+          if (!path3) return path3;
           var output = "";
-          while (path.length > 0) {
-            if (path === "." || path === "..") {
-              path = "";
+          while (path3.length > 0) {
+            if (path3 === "." || path3 === "..") {
+              path3 = "";
               break;
             }
-            var twochars = path.substring(0, 2);
-            var threechars = path.substring(0, 3);
-            var fourchars = path.substring(0, 4);
+            var twochars = path3.substring(0, 2);
+            var threechars = path3.substring(0, 3);
+            var fourchars = path3.substring(0, 4);
             if (threechars === "../") {
-              path = path.substring(3);
+              path3 = path3.substring(3);
             } else if (twochars === "./") {
-              path = path.substring(2);
+              path3 = path3.substring(2);
             } else if (threechars === "/./") {
-              path = "/" + path.substring(3);
-            } else if (twochars === "/." && path.length === 2) {
-              path = "/";
-            } else if (fourchars === "/../" || threechars === "/.." && path.length === 3) {
-              path = "/" + path.substring(4);
+              path3 = "/" + path3.substring(3);
+            } else if (twochars === "/." && path3.length === 2) {
+              path3 = "/";
+            } else if (fourchars === "/../" || threechars === "/.." && path3.length === 3) {
+              path3 = "/" + path3.substring(4);
               output = output.replace(/\/?[^\/]*$/, "");
             } else {
-              var segment = path.match(/(\/?([^\/]*))/)[0];
+              var segment = path3.match(/(\/?([^\/]*))/)[0];
               output += segment;
-              path = path.substring(segment.length);
+              path3 = path3.substring(segment.length);
             }
           }
           return output;
@@ -16695,6 +16684,714 @@ var require_lib = __commonJS({
   }
 });
 
+// ../utils/dist/index.js
+import fs from "fs/promises";
+import { existsSync, statSync, readdirSync } from "fs";
+import path from "path";
+import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
+import fs2 from "fs/promises";
+import path2 from "path";
+import fs3 from "fs";
+import nodePath from "path";
+var consoleLogger = {
+  debug: console.debug.bind(console),
+  info: console.info.bind(console),
+  warn: console.warn.bind(console),
+  error: console.error.bind(console)
+};
+var SqliteNoSqlDb = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  insert(table, row) {
+    const cols = Object.keys(row);
+    const placeholders = cols.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`;
+    this.raw.run(sql, cols.map((c) => serialize(row[c])));
+  }
+  upsert(table, row, conflictKeys, updateFields) {
+    const cols = Object.keys(row);
+    const placeholders = cols.map(() => "?").join(", ");
+    const conflict = conflictKeys.map((k) => `"${k}"`).join(", ");
+    const updates = Object.keys(updateFields).map((k) => `"${k}" = ?`).join(", ");
+    const sql = `INSERT INTO "${table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders}) ON CONFLICT (${conflict}) DO UPDATE SET ${updates}`;
+    const params = [
+      ...cols.map((c) => serialize(row[c])),
+      ...Object.keys(updateFields).map((k) => serialize(updateFields[k]))
+    ];
+    this.raw.run(sql, params);
+  }
+  findOne(table, filter, options) {
+    const fields = options?.select?.map((f) => `"${f}"`).join(", ") ?? "*";
+    const { clause, params } = filter ? buildWhere(filter) : { clause: "", params: [] };
+    const where = clause ? ` WHERE ${clause}` : "";
+    const sql = `SELECT ${fields} FROM "${table}"${where} LIMIT 1`;
+    const row = this.raw.get(sql, params);
+    return row ? deserializeRow(row) : void 0;
+  }
+  findMany(table, options) {
+    const fields = options?.select?.map((f) => `"${f}"`).join(", ") ?? "*";
+    const { clause, params } = options?.filter ? buildWhere(options.filter) : { clause: "", params: [] };
+    const where = clause ? ` WHERE ${clause}` : "";
+    let orderClause = "";
+    if (options?.orderBy?.length) {
+      const parts = options.orderBy.map(
+        (o) => `"${o.field}" ${o.direction === "desc" ? "DESC" : "ASC"}`
+      );
+      orderClause = ` ORDER BY ${parts.join(", ")}`;
+    }
+    const limitClause = options?.limit != null ? ` LIMIT ${options.limit}` : "";
+    const sql = `SELECT ${fields} FROM "${table}"${where}${orderClause}${limitClause}`;
+    return this.raw.all(sql, params).map(deserializeRow);
+  }
+  update(table, filter, set) {
+    const setCols = Object.keys(set);
+    const setClause = setCols.map((k) => `"${k}" = ?`).join(", ");
+    const { clause, params } = buildWhere(filter);
+    const sql = `UPDATE "${table}" SET ${setClause} WHERE ${clause} RETURNING *`;
+    const setParams = setCols.map((k) => serialize(set[k]));
+    const row = this.raw.get(sql, [...setParams, ...params]);
+    return row ? deserializeRow(row) : void 0;
+  }
+  remove(table, filter) {
+    const { clause, params } = buildWhere(filter);
+    this.raw.run(`DELETE FROM "${table}" WHERE ${clause}`, params);
+  }
+  transaction(fn) {
+    this.raw.transaction(() => {
+      fn(this);
+    });
+  }
+};
+function buildWhere(filter) {
+  switch (filter.op) {
+    case "eq":
+      return { clause: `"${filter.field}" = ?`, params: [serialize(filter.value)] };
+    case "ne":
+      return { clause: `"${filter.field}" != ?`, params: [serialize(filter.value)] };
+    case "gt":
+      return { clause: `"${filter.field}" > ?`, params: [serialize(filter.value)] };
+    case "gte":
+      return { clause: `"${filter.field}" >= ?`, params: [serialize(filter.value)] };
+    case "lt":
+      return { clause: `"${filter.field}" < ?`, params: [serialize(filter.value)] };
+    case "like":
+      return { clause: `"${filter.field}" LIKE ?`, params: [filter.value] };
+    case "isNull":
+      return { clause: `"${filter.field}" IS NULL`, params: [] };
+    case "in": {
+      const placeholders = filter.values.map(() => "?").join(", ");
+      return { clause: `"${filter.field}" IN (${placeholders})`, params: filter.values.map(serialize) };
+    }
+    case "and": {
+      const parts = filter.conditions.map(buildWhere);
+      return {
+        clause: parts.map((p) => `(${p.clause})`).join(" AND "),
+        params: parts.flatMap((p) => p.params)
+      };
+    }
+    case "or": {
+      const parts = filter.conditions.map(buildWhere);
+      return {
+        clause: parts.map((p) => `(${p.clause})`).join(" OR "),
+        params: parts.flatMap((p) => p.params)
+      };
+    }
+  }
+}
+function serialize(value) {
+  if (value === void 0) return null;
+  if (value === null) return null;
+  if (typeof value === "object" && !(value instanceof Buffer) && !(value instanceof Uint8Array)) {
+    return JSON.stringify(value);
+  }
+  return value;
+}
+function deserializeRow(row) {
+  const result = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+      try {
+        result[key] = JSON.parse(value);
+      } catch {
+        result[key] = value;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+var NodeFS = class {
+  async exists(p) {
+    return existsSync(p);
+  }
+  async stat(p) {
+    try {
+      const s = statSync(p);
+      return {
+        size: typeof s.size === "bigint" ? Number(s.size) : s.size,
+        isDirectory: s.isDirectory(),
+        isFile: s.isFile(),
+        mtimeMs: s.mtimeMs
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  async isDir(p) {
+    const s = await this.stat(p);
+    return s?.isDirectory ?? false;
+  }
+  async readText(p) {
+    return fs.readFile(p, "utf-8");
+  }
+  async readBytes(p) {
+    return fs.readFile(p);
+  }
+  async readJson(p) {
+    return JSON.parse(await this.readText(p));
+  }
+  async readDir(p) {
+    const entries = readdirSync(p, { withFileTypes: true });
+    return entries.map((e) => ({
+      name: e.name,
+      isDirectory: e.isDirectory(),
+      isFile: e.isFile()
+    }));
+  }
+  async write(p, content) {
+    try {
+      await fs.writeFile(p, content);
+    } catch (e) {
+      if (e?.code === "ENOENT") {
+        await fs.mkdir(path.dirname(p), { recursive: true });
+        await fs.writeFile(p, content);
+        return;
+      }
+      throw e;
+    }
+  }
+  async writeJson(p, data) {
+    await this.write(p, JSON.stringify(data, null, 2));
+  }
+  async mkdir(p) {
+    await fs.mkdir(p, { recursive: true });
+  }
+  async remove(p) {
+    await fs.unlink(p).catch(() => {
+    });
+  }
+  async grep(pattern, searchPath, options) {
+    return new Promise((resolve2) => {
+      const args = [
+        "--json",
+        "--line-number",
+        "--column",
+        "--no-heading",
+        ...options?.maxResults ? ["--max-count", String(options.maxResults)] : [],
+        ...options?.include?.flatMap((g) => ["--glob", g]) ?? [],
+        pattern,
+        searchPath
+      ];
+      const rg = spawn("rg", args, { stdio: ["ignore", "pipe", "pipe"] });
+      let output = "";
+      rg.stdout.on("data", (data) => {
+        output += data.toString();
+      });
+      rg.on("close", () => {
+        const results = [];
+        for (const line of output.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            const parsed = JSON.parse(line);
+            if (parsed.type === "match") {
+              results.push({
+                file: parsed.data.path.text,
+                line: parsed.data.line_number,
+                column: parsed.data.submatches?.[0]?.start ?? 0,
+                content: parsed.data.lines.text.trimEnd()
+              });
+            }
+          } catch {
+          }
+        }
+        resolve2(results);
+      });
+      rg.on("error", () => resolve2([]));
+    });
+  }
+  async glob(pattern, options = {}) {
+    const searchPath = options.cwd ?? process.cwd();
+    const { glob: fsGlob } = await import("fs/promises").catch(() => ({ glob: void 0 }));
+    if (fsGlob) {
+      try {
+        const results = [];
+        for await (const entry of fsGlob(pattern, { cwd: searchPath })) {
+          if (options.absolute) {
+            results.push(path.resolve(searchPath, entry));
+          } else {
+            results.push(entry);
+          }
+        }
+        return results;
+      } catch {
+      }
+    }
+    return new Promise((resolve2) => {
+      const rg = spawn("rg", ["--files", "--glob", pattern, searchPath], {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let output = "";
+      rg.stdout.on("data", (data) => {
+        output += data.toString();
+      });
+      rg.on("close", () => {
+        resolve2(
+          output.split("\n").map((l) => l.trim()).filter(Boolean)
+        );
+      });
+      rg.on("error", () => resolve2([]));
+    });
+  }
+};
+var NodeSearchProvider = class {
+  async grep(options) {
+    options.signal?.throwIfAborted();
+    return new Promise((resolve2, reject) => {
+      const args = ["-rnH", "--color=never"];
+      if (options.include) {
+        args.push(`--include=${options.include}`);
+      }
+      args.push("--exclude-dir=.git");
+      args.push("-E");
+      args.push("--", options.pattern, options.path);
+      const proc = spawn2("grep", args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        signal: options.signal
+      });
+      let output = "";
+      proc.stdout.on("data", (data) => {
+        output += data.toString();
+      });
+      proc.on("close", () => {
+        const results = [];
+        for (const line of output.split("\n")) {
+          if (!line.trim()) continue;
+          const match = line.match(/^(.+?):(\d+):(.*)$/);
+          if (match) {
+            let content = match[3];
+            if (options.maxLineLength !== void 0 && content.length > options.maxLineLength) {
+              content = content.slice(0, options.maxLineLength) + "...";
+            }
+            results.push({
+              file: match[1],
+              line: parseInt(match[2], 10),
+              column: 0,
+              content
+            });
+          }
+        }
+        resolve2(results);
+      });
+      proc.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+  async listFiles(options) {
+    options.signal?.throwIfAborted();
+    const showHidden = options.hidden === true;
+    const results = [];
+    const limit = options.limit ?? Infinity;
+    const excludePatterns = [".git"];
+    const includePatterns = [];
+    for (const g of options.glob ?? []) {
+      if (g.startsWith("!")) {
+        excludePatterns.push(g.slice(1).replace(/[/*]+$/, ""));
+      } else {
+        includePatterns.push(g);
+      }
+    }
+    const walk = async (dir, depth) => {
+      if (results.length >= limit) return;
+      if (options.maxDepth !== void 0 && depth > options.maxDepth) return;
+      options.signal?.throwIfAborted();
+      let entries;
+      try {
+        entries = await fs2.readdir(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (results.length >= limit) return;
+        const name = entry.name;
+        if (!showHidden && name.startsWith(".")) continue;
+        const fullPath = path2.join(dir, name);
+        const relativePath = path2.relative(options.cwd, fullPath);
+        if (excludePatterns.some((p) => relativePath.startsWith(p) || name === p)) continue;
+        const isDir = entry.isDirectory() || options.follow && entry.isSymbolicLink();
+        if (isDir) {
+          await walk(fullPath, depth + 1);
+        } else if (entry.isFile()) {
+          if (includePatterns.length > 0) {
+            const matches = includePatterns.some((p) => simpleGlobMatch(name, p));
+            if (!matches) continue;
+          }
+          results.push(relativePath);
+        }
+      }
+    };
+    await walk(options.cwd, 0);
+    return results;
+  }
+  async tree(options) {
+    const limit = options.limit ?? 50;
+    const files = await this.listFiles({ cwd: options.cwd, signal: options.signal });
+    function dir(node, name) {
+      const existing = node.children.get(name);
+      if (existing) return existing;
+      const next2 = { name, children: /* @__PURE__ */ new Map() };
+      node.children.set(name, next2);
+      return next2;
+    }
+    const root2 = { name: "", children: /* @__PURE__ */ new Map() };
+    for (const file of files) {
+      if (file.includes(".opencode")) continue;
+      const parts = file.split(/[\/\\]/);
+      if (parts.length < 2) continue;
+      let node = root2;
+      for (const part of parts.slice(0, -1)) {
+        node = dir(node, part);
+      }
+    }
+    function count(node) {
+      let total2 = 0;
+      for (const child of node.children.values()) {
+        total2 += 1 + count(child);
+      }
+      return total2;
+    }
+    const total = count(root2);
+    const lines = [];
+    const queue = [];
+    for (const child of Array.from(root2.children.values()).sort((a, b) => a.name.localeCompare(b.name))) {
+      queue.push({ node: child, path: child.name });
+    }
+    let used = 0;
+    for (let i = 0; i < queue.length && used < limit; i++) {
+      const { node, path: p } = queue[i];
+      lines.push(p);
+      used++;
+      for (const child of Array.from(node.children.values()).sort((a, b) => a.name.localeCompare(b.name))) {
+        queue.push({ node: child, path: `${p}/${child.name}` });
+      }
+    }
+    if (total > used) lines.push(`[${total - used} truncated]`);
+    return lines.join("\n");
+  }
+};
+function simpleGlobMatch(filename, pattern) {
+  if (pattern === "*") return true;
+  if (pattern.startsWith("*.")) {
+    const ext = pattern.slice(1);
+    if (ext.startsWith(".{") && ext.endsWith("}")) {
+      const exts = ext.slice(2, -1).split(",");
+      return exts.some((e) => filename.endsWith(`.${e}`));
+    }
+    return filename.endsWith(ext);
+  }
+  return filename === pattern;
+}
+var INITIAL_MIGRATION = `-- project table
+CREATE TABLE IF NOT EXISTS "project" (
+  "id" TEXT PRIMARY KEY NOT NULL,
+  "worktree" TEXT NOT NULL,
+  "vcs" TEXT,
+  "name" TEXT,
+  "icon_url" TEXT,
+  "icon_color" TEXT,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_initialized" INTEGER,
+  "sandboxes" TEXT NOT NULL DEFAULT '[]',
+  "commands" TEXT
+);
+
+-- session table
+CREATE TABLE IF NOT EXISTS "session" (
+  "id" TEXT PRIMARY KEY NOT NULL,
+  "project_id" TEXT NOT NULL REFERENCES "project"("id") ON DELETE CASCADE,
+  "workspace_id" TEXT,
+  "parent_id" TEXT,
+  "slug" TEXT NOT NULL,
+  "directory" TEXT NOT NULL,
+  "title" TEXT NOT NULL,
+  "version" TEXT NOT NULL,
+  "share_url" TEXT,
+  "summary_additions" INTEGER,
+  "summary_deletions" INTEGER,
+  "summary_files" INTEGER,
+  "summary_diffs" TEXT,
+  "revert" TEXT,
+  "permission" TEXT,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_compacting" INTEGER,
+  "time_archived" INTEGER
+);
+CREATE INDEX IF NOT EXISTS "session_project_idx" ON "session"("project_id");
+CREATE INDEX IF NOT EXISTS "session_workspace_idx" ON "session"("workspace_id");
+CREATE INDEX IF NOT EXISTS "session_parent_idx" ON "session"("parent_id");
+
+-- message table
+CREATE TABLE IF NOT EXISTS "message" (
+  "id" TEXT PRIMARY KEY NOT NULL,
+  "session_id" TEXT NOT NULL REFERENCES "session"("id") ON DELETE CASCADE,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "data" TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS "message_session_time_created_id_idx" ON "message"("session_id", "time_created", "id");
+
+-- part table
+CREATE TABLE IF NOT EXISTS "part" (
+  "id" TEXT PRIMARY KEY NOT NULL,
+  "message_id" TEXT NOT NULL REFERENCES "message"("id") ON DELETE CASCADE,
+  "session_id" TEXT NOT NULL,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "data" TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS "part_message_id_id_idx" ON "part"("message_id", "id");
+CREATE INDEX IF NOT EXISTS "part_session_idx" ON "part"("session_id");
+
+-- todo table
+CREATE TABLE IF NOT EXISTS "todo" (
+  "session_id" TEXT NOT NULL REFERENCES "session"("id") ON DELETE CASCADE,
+  "content" TEXT NOT NULL,
+  "status" TEXT NOT NULL,
+  "priority" TEXT NOT NULL,
+  "position" INTEGER NOT NULL,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  PRIMARY KEY ("session_id", "position")
+);
+CREATE INDEX IF NOT EXISTS "todo_session_idx" ON "todo"("session_id");
+
+-- permission table
+CREATE TABLE IF NOT EXISTS "permission" (
+  "project_id" TEXT PRIMARY KEY NOT NULL REFERENCES "project"("id") ON DELETE CASCADE,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "data" TEXT NOT NULL
+);
+
+-- session_share table
+CREATE TABLE IF NOT EXISTS "session_share" (
+  "session_id" TEXT PRIMARY KEY NOT NULL REFERENCES "session"("id") ON DELETE CASCADE,
+  "id" TEXT NOT NULL,
+  "secret" TEXT NOT NULL,
+  "url" TEXT NOT NULL,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+
+-- workspace table
+CREATE TABLE IF NOT EXISTS "workspace" (
+  "id" TEXT PRIMARY KEY NOT NULL,
+  "type" TEXT NOT NULL,
+  "branch" TEXT,
+  "name" TEXT,
+  "directory" TEXT,
+  "extra" TEXT,
+  "project_id" TEXT NOT NULL REFERENCES "project"("id") ON DELETE CASCADE
+);
+
+-- account table
+CREATE TABLE IF NOT EXISTS "account" (
+  "id" TEXT PRIMARY KEY NOT NULL,
+  "email" TEXT NOT NULL,
+  "url" TEXT NOT NULL,
+  "access_token" TEXT NOT NULL,
+  "refresh_token" TEXT NOT NULL,
+  "token_expiry" INTEGER,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+
+-- account_state table
+CREATE TABLE IF NOT EXISTS "account_state" (
+  "id" INTEGER PRIMARY KEY,
+  "active_account_id" TEXT REFERENCES "account"("id") ON DELETE SET NULL,
+  "active_org_id" TEXT
+);
+
+-- control_account table (legacy)
+CREATE TABLE IF NOT EXISTS "control_account" (
+  "email" TEXT NOT NULL,
+  "url" TEXT NOT NULL,
+  "access_token" TEXT NOT NULL,
+  "refresh_token" TEXT NOT NULL,
+  "token_expiry" INTEGER,
+  "active" INTEGER NOT NULL DEFAULT 0,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  PRIMARY KEY ("email", "url")
+);`;
+function getDefaultMigrations() {
+  return [
+    { sql: INITIAL_MIGRATION, timestamp: Date.UTC(2024, 0, 1), name: "20240101000000_initial" }
+  ];
+}
+var SqlJsStorage = class {
+  db = null;
+  noSqlDb = null;
+  dbPath;
+  flushTimer = null;
+  migrations;
+  constructor(dbPath, migrations) {
+    this.dbPath = dbPath ?? null;
+    this.migrations = migrations ?? getDefaultMigrations();
+  }
+  async connect() {
+    if (this.noSqlDb) return this.noSqlDb;
+    const initSqlJs = (await import("sql.js")).default;
+    const SQL = await initSqlJs();
+    if (this.dbPath && fs3.existsSync(this.dbPath)) {
+      const buffer = fs3.readFileSync(this.dbPath);
+      this.db = new SQL.Database(new Uint8Array(buffer));
+    } else {
+      this.db = new SQL.Database();
+    }
+    this.db.run("PRAGMA foreign_keys = ON");
+    this.applyMigrations(this.migrations);
+    this.flushSync();
+    const raw = this.createRawDb();
+    this.noSqlDb = new SqliteNoSqlDb(raw);
+    return this.noSqlDb;
+  }
+  // ── Flush to disk ──────────────────────────────────────────────
+  /** Schedule an async flush (debounced 100ms). */
+  scheduleFlush() {
+    if (!this.dbPath) return;
+    if (this.flushTimer) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      this.flushSync();
+    }, 100);
+  }
+  /** Synchronously write the entire database to disk. */
+  flushSync() {
+    if (!this.dbPath || !this.db) return;
+    const dir = nodePath.dirname(this.dbPath);
+    fs3.mkdirSync(dir, { recursive: true });
+    const data = this.db.export();
+    fs3.writeFileSync(this.dbPath, Buffer.from(data));
+  }
+  // ── RawSqliteDb wrapper ────────────────────────────────────────
+  createRawDb() {
+    const db = this.db;
+    const self = this;
+    return {
+      run(sql, params) {
+        db.run(sql, params);
+        self.scheduleFlush();
+      },
+      get(sql, params) {
+        const stmt = db.prepare(sql);
+        if (params) stmt.bind(params);
+        if (!stmt.step()) {
+          stmt.free();
+          return void 0;
+        }
+        const result = stmt.getAsObject();
+        stmt.free();
+        return result;
+      },
+      all(sql, params) {
+        const stmt = db.prepare(sql);
+        if (params) stmt.bind(params);
+        const results = [];
+        while (stmt.step()) {
+          results.push(stmt.getAsObject());
+        }
+        stmt.free();
+        return results;
+      },
+      transaction(fn) {
+        db.run("BEGIN TRANSACTION");
+        try {
+          fn();
+          db.run("COMMIT");
+          self.scheduleFlush();
+        } catch (e) {
+          db.run("ROLLBACK");
+          throw e;
+        }
+      }
+    };
+  }
+  // ── Migrations ─────────────────────────────────────────────────
+  applyMigrations(entries) {
+    if (!this.db) throw new Error("SqlJsStorage: db not initialized");
+    this.db.run(`
+            CREATE TABLE IF NOT EXISTS "__drizzle_migrations" (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                hash TEXT NOT NULL,
+                created_at INTEGER
+            )
+        `);
+    const applied = /* @__PURE__ */ new Set();
+    const rows = this.db.exec(`SELECT hash FROM "__drizzle_migrations"`);
+    if (rows.length > 0) {
+      for (const row of rows[0].values) {
+        applied.add(row[0]);
+      }
+    }
+    for (const entry of entries) {
+      const hash = entry.name;
+      if (applied.has(hash)) continue;
+      this.db.run(entry.sql);
+      this.db.run(
+        `INSERT INTO "__drizzle_migrations" (hash, created_at) VALUES (?, ?)`,
+        [hash, entry.timestamp]
+      );
+    }
+  }
+  /** Run raw SQL (for server-specific DDL like extra tables). */
+  exec(sql) {
+    if (!this.db) throw new Error("SqlJsStorage: db not initialized");
+    this.db.run(sql);
+    this.scheduleFlush();
+  }
+  /** Run a SELECT query and return rows as objects. */
+  query(sql, params) {
+    if (!this.db) throw new Error("SqlJsStorage: db not initialized");
+    const stmt = this.db.prepare(sql);
+    if (params) stmt.bind(params);
+    const results = [];
+    while (stmt.step()) {
+      results.push(stmt.getAsObject());
+    }
+    stmt.free();
+    return results;
+  }
+  close() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flushSync();
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+    this.noSqlDb = null;
+  }
+};
+
 // ../../node_modules/.pnpm/diff@8.0.2/node_modules/diff/libesm/diff/base.js
 var Diff = class {
   diff(oldStr, newStr, options = {}) {
@@ -16795,16 +17492,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path, added, removed, oldPosInc, options) {
-    const last = path.lastComponent;
+  addToPath(path3, added, removed, oldPosInc, options) {
+    const last = path3.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path.oldPos + oldPosInc,
+        oldPos: path3.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path.oldPos + oldPosInc,
+        oldPos: path3.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -17718,7 +18415,7 @@ TurndownService.prototype = {
       );
     }
     if (input === "") return "";
-    var output = process.call(this, new RootNode(input, this.options));
+    var output = process2.call(this, new RootNode(input, this.options));
     return postProcess.call(this, output);
   },
   /**
@@ -17785,7 +18482,7 @@ TurndownService.prototype = {
     }, string);
   }
 };
-function process(parentNode) {
+function process2(parentNode) {
   var self = this;
   return reduce.call(parentNode.childNodes, function(output, node) {
     node = new Node(node, self.options);
@@ -17809,7 +18506,7 @@ function postProcess(output) {
 }
 function replacementForNode(node) {
   var rule = this.rules.forNode(node);
-  var content = process.call(this, node);
+  var content = process2.call(this, node);
   var whitespace = node.flankingWhitespace;
   if (whitespace.leading || whitespace.trailing) content = content.trim();
   return whitespace.leading + rule.replacement(content, node, this.options) + whitespace.trailing;
@@ -17826,9 +18523,7 @@ function canConvert(input) {
 }
 var turndown_es_default = TurndownService;
 
-// ../agent/dist/chunk-MD6BEIK2.js
-import { pathToFileURL as pathToFileURL2 } from "url";
-import { pathToFileURL } from "url";
+// ../agent/dist/chunk-HV5GDH4X.js
 var SchedulerService = class {
   tasks = /* @__PURE__ */ new Map();
   timers = /* @__PURE__ */ new Map();
@@ -17875,14 +18570,10 @@ var Scheduler;
   }
   Scheduler2.register = register;
 })(Scheduler || (Scheduler = {}));
-var toolIdSchema = Schema_exports.String.pipe(Schema_exports.brand("ToolID"));
-var ToolID = toolIdSchema.pipe(
-  withStatics((schema) => ({
-    make: (id) => schema.makeUnsafe(id),
-    ascending: (id) => schema.makeUnsafe(Identifier.ascending("tool", id)),
-    zod: Identifier.schema("tool").pipe(zod_default.custom())
-  }))
-);
+var ToolID = {
+  make: (id) => id,
+  ascending: (id) => Identifier.ascending("tool", id)
+};
 var Truncate;
 ((Truncate2) => {
   Truncate2.MAX_LINES = 2e3;
@@ -18051,8 +18742,8 @@ var PlanExitTool = Tool.define("plan_exit", {
       agent: "build",
       model
     };
-    await ctx.session.updateMessage(userMsg);
-    await ctx.session.updatePart({
+    await ctx.memory.updateMessage(userMsg);
+    await ctx.memory.updatePart({
       id: PartID.ascending(),
       messageID: userMsg.id,
       sessionID: ctx.sessionID,
@@ -18067,6 +18758,130 @@ var PlanExitTool = Tool.define("plan_exit", {
     };
   }
 });
+var _env = {};
+function truthy(key) {
+  const value = _env[key]?.toLowerCase();
+  return value === "true" || value === "1";
+}
+function falsy(key) {
+  const value = _env[key]?.toLowerCase();
+  return value === "false" || value === "0";
+}
+function number(key) {
+  const value = _env[key];
+  if (!value) return void 0;
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+var Flag;
+((Flag2) => {
+  function init(env) {
+    _env = env;
+    Flag2.OPENCODE_AUTO_SHARE = truthy("OPENCODE_AUTO_SHARE");
+    Flag2.OPENCODE_GIT_BASH_PATH = _env["OPENCODE_GIT_BASH_PATH"];
+    Flag2.OPENCODE_CONFIG = _env["OPENCODE_CONFIG"];
+    Flag2.OPENCODE_CONFIG_CONTENT = _env["OPENCODE_CONFIG_CONTENT"];
+    Flag2.OPENCODE_DISABLE_AUTOUPDATE = truthy("OPENCODE_DISABLE_AUTOUPDATE");
+    Flag2.OPENCODE_DISABLE_PRUNE = truthy("OPENCODE_DISABLE_PRUNE");
+    Flag2.OPENCODE_DISABLE_TERMINAL_TITLE = truthy("OPENCODE_DISABLE_TERMINAL_TITLE");
+    Flag2.OPENCODE_PERMISSION = _env["OPENCODE_PERMISSION"];
+    Flag2.OPENCODE_DISABLE_DEFAULT_PLUGINS = truthy("OPENCODE_DISABLE_DEFAULT_PLUGINS");
+    Flag2.OPENCODE_DISABLE_LSP_DOWNLOAD = truthy("OPENCODE_DISABLE_LSP_DOWNLOAD");
+    Flag2.OPENCODE_ENABLE_EXPERIMENTAL_MODELS = truthy("OPENCODE_ENABLE_EXPERIMENTAL_MODELS");
+    Flag2.OPENCODE_DISABLE_AUTOCOMPACT = truthy("OPENCODE_DISABLE_AUTOCOMPACT");
+    Flag2.OPENCODE_DISABLE_MODELS_FETCH = truthy("OPENCODE_DISABLE_MODELS_FETCH");
+    Flag2.OPENCODE_DISABLE_CLAUDE_CODE = truthy("OPENCODE_DISABLE_CLAUDE_CODE");
+    Flag2.OPENCODE_DISABLE_CLAUDE_CODE_PROMPT = Flag2.OPENCODE_DISABLE_CLAUDE_CODE || truthy("OPENCODE_DISABLE_CLAUDE_CODE_PROMPT");
+    Flag2.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS = Flag2.OPENCODE_DISABLE_CLAUDE_CODE || truthy("OPENCODE_DISABLE_CLAUDE_CODE_SKILLS");
+    Flag2.OPENCODE_DISABLE_EXTERNAL_SKILLS = Flag2.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS || truthy("OPENCODE_DISABLE_EXTERNAL_SKILLS");
+    Flag2.OPENCODE_FAKE_VCS = _env["OPENCODE_FAKE_VCS"];
+    Flag2.OPENCODE_SERVER_PASSWORD = _env["OPENCODE_SERVER_PASSWORD"];
+    Flag2.OPENCODE_SERVER_USERNAME = _env["OPENCODE_SERVER_USERNAME"];
+    Flag2.OPENCODE_ENABLE_QUESTION_TOOL = truthy("OPENCODE_ENABLE_QUESTION_TOOL");
+    Flag2.OPENCODE_EXPERIMENTAL = truthy("OPENCODE_EXPERIMENTAL");
+    Flag2.OPENCODE_EXPERIMENTAL_FILEWATCHER = truthy("OPENCODE_EXPERIMENTAL_FILEWATCHER");
+    Flag2.OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER = truthy("OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER");
+    Flag2.OPENCODE_EXPERIMENTAL_ICON_DISCOVERY = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_ICON_DISCOVERY");
+    Flag2.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT = (() => {
+      const copy = _env["OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT"];
+      return copy === void 0 ? false : truthy("OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT");
+    })();
+    Flag2.OPENCODE_ENABLE_EXA = truthy("OPENCODE_ENABLE_EXA") || Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_EXA");
+    Flag2.OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS = number("OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS");
+    Flag2.OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX = number("OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX");
+    Flag2.OPENCODE_EXPERIMENTAL_OXFMT = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_OXFMT");
+    Flag2.OPENCODE_EXPERIMENTAL_LSP_TY = truthy("OPENCODE_EXPERIMENTAL_LSP_TY");
+    Flag2.OPENCODE_EXPERIMENTAL_LSP_TOOL = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_LSP_TOOL");
+    Flag2.OPENCODE_DISABLE_FILETIME_CHECK = truthy("OPENCODE_DISABLE_FILETIME_CHECK");
+    Flag2.OPENCODE_EXPERIMENTAL_PLAN_MODE = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_PLAN_MODE");
+    Flag2.OPENCODE_EXPERIMENTAL_WORKSPACES = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_WORKSPACES");
+    Flag2.OPENCODE_EXPERIMENTAL_MARKDOWN = !falsy("OPENCODE_EXPERIMENTAL_MARKDOWN");
+    Flag2.OPENCODE_MODELS_URL = _env["OPENCODE_MODELS_URL"];
+    Flag2.OPENCODE_MODELS_PATH = _env["OPENCODE_MODELS_PATH"];
+    Flag2.OPENCODE_DISABLE_CHANNEL_DB = truthy("OPENCODE_DISABLE_CHANNEL_DB");
+    Flag2.OPENCODE_SKIP_MIGRATIONS = truthy("OPENCODE_SKIP_MIGRATIONS");
+    Flag2.OPENCODE_STRICT_CONFIG_DEPS = truthy("OPENCODE_STRICT_CONFIG_DEPS");
+  }
+  Flag2.init = init;
+  Flag2.OPENCODE_AUTO_SHARE = false;
+  Flag2.OPENCODE_DISABLE_AUTOUPDATE = false;
+  Flag2.OPENCODE_DISABLE_PRUNE = false;
+  Flag2.OPENCODE_DISABLE_TERMINAL_TITLE = false;
+  Flag2.OPENCODE_DISABLE_DEFAULT_PLUGINS = false;
+  Flag2.OPENCODE_DISABLE_LSP_DOWNLOAD = false;
+  Flag2.OPENCODE_ENABLE_EXPERIMENTAL_MODELS = false;
+  Flag2.OPENCODE_DISABLE_AUTOCOMPACT = false;
+  Flag2.OPENCODE_DISABLE_MODELS_FETCH = false;
+  Flag2.OPENCODE_DISABLE_CLAUDE_CODE = false;
+  Flag2.OPENCODE_DISABLE_CLAUDE_CODE_PROMPT = false;
+  Flag2.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS = false;
+  Flag2.OPENCODE_DISABLE_EXTERNAL_SKILLS = false;
+  Flag2.OPENCODE_ENABLE_QUESTION_TOOL = false;
+  Flag2.OPENCODE_EXPERIMENTAL = false;
+  Flag2.OPENCODE_EXPERIMENTAL_FILEWATCHER = false;
+  Flag2.OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER = false;
+  Flag2.OPENCODE_EXPERIMENTAL_ICON_DISCOVERY = false;
+  Flag2.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT = false;
+  Flag2.OPENCODE_ENABLE_EXA = false;
+  Flag2.OPENCODE_EXPERIMENTAL_OXFMT = false;
+  Flag2.OPENCODE_EXPERIMENTAL_LSP_TY = false;
+  Flag2.OPENCODE_EXPERIMENTAL_LSP_TOOL = false;
+  Flag2.OPENCODE_DISABLE_FILETIME_CHECK = false;
+  Flag2.OPENCODE_EXPERIMENTAL_PLAN_MODE = false;
+  Flag2.OPENCODE_EXPERIMENTAL_WORKSPACES = false;
+  Flag2.OPENCODE_EXPERIMENTAL_MARKDOWN = true;
+  Flag2.OPENCODE_DISABLE_CHANNEL_DB = false;
+  Flag2.OPENCODE_SKIP_MIGRATIONS = false;
+  Flag2.OPENCODE_STRICT_CONFIG_DEPS = false;
+})(Flag || (Flag = {}));
+Object.defineProperty(Flag, "OPENCODE_DISABLE_PROJECT_CONFIG", {
+  get() {
+    return truthy("OPENCODE_DISABLE_PROJECT_CONFIG");
+  },
+  enumerable: true,
+  configurable: false
+});
+Object.defineProperty(Flag, "OPENCODE_TUI_CONFIG", {
+  get() {
+    return _env["OPENCODE_TUI_CONFIG"];
+  },
+  enumerable: true,
+  configurable: false
+});
+Object.defineProperty(Flag, "OPENCODE_CONFIG_DIR", {
+  get() {
+    return _env["OPENCODE_CONFIG_DIR"];
+  },
+  enumerable: true,
+  configurable: false
+});
+Object.defineProperty(Flag, "OPENCODE_CLIENT", {
+  get() {
+    return _env["OPENCODE_CLIENT"] ?? "cli";
+  },
+  enumerable: true,
+  configurable: false
+});
 var DESCRIPTION = `Executes a given bash command in a persistent shell session with optional timeout, ensuring proper handling and security measures.
 
 All commands run in \${directory} by default. Use the \`workdir\` parameter if you need to run a command in a different directory. AVOID using \`cd <directory> && <command>\` patterns - use \`workdir\` instead.
@@ -18377,64 +19192,6 @@ var BashTool = Tool.define("bash", async (initCtx) => {
     }
   };
 });
-var LSP;
-((LSP2) => {
-  LSP2.Diagnostic = {
-    pretty(d) {
-      return `${d.range.start.line}:${d.range.start.character} ${d.severity === 1 ? "error" : "warning"}: ${d.message}`;
-    }
-  };
-  async function init() {
-  }
-  LSP2.init = init;
-  async function touchFile(_filepath, _wait) {
-  }
-  LSP2.touchFile = touchFile;
-  async function diagnostics() {
-    return /* @__PURE__ */ new Map();
-  }
-  LSP2.diagnostics = diagnostics;
-  async function hasClients(_file) {
-    return false;
-  }
-  LSP2.hasClients = hasClients;
-  async function definition(_position) {
-    return [];
-  }
-  LSP2.definition = definition;
-  async function references(_position) {
-    return [];
-  }
-  LSP2.references = references;
-  async function hover(_position) {
-    return null;
-  }
-  LSP2.hover = hover;
-  async function documentSymbol(_uri) {
-    return [];
-  }
-  LSP2.documentSymbol = documentSymbol;
-  async function workspaceSymbol(_query) {
-    return [];
-  }
-  LSP2.workspaceSymbol = workspaceSymbol;
-  async function implementation(_position) {
-    return [];
-  }
-  LSP2.implementation = implementation;
-  async function prepareCallHierarchy(_position) {
-    return [];
-  }
-  LSP2.prepareCallHierarchy = prepareCallHierarchy;
-  async function incomingCalls(_position) {
-    return [];
-  }
-  LSP2.incomingCalls = incomingCalls;
-  async function outgoingCalls(_position) {
-    return [];
-  }
-  LSP2.outgoingCalls = outgoingCalls;
-})(LSP || (LSP = {}));
 async function assertExternalDirectory(ctx, target, options) {
   if (!target) return;
   if (options?.bypass) return;
@@ -18463,7 +19220,6 @@ Usage:
 - The edit will FAIL if \`oldString\` is found multiple times in the file with an error "Found multiple matches for oldString. Provide more surrounding lines in oldString to identify the correct match." Either provide a larger string with more surrounding context to make it unique or use \`replaceAll\` to change every instance of \`oldString\`. 
 - Use \`replaceAll\` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.
 `;
-var MAX_DIAGNOSTICS_PER_FILE = 20;
 function normalizeLineEndings(text) {
   return text.replaceAll("\r\n", "\n");
 }
@@ -18561,25 +19317,9 @@ var EditTool = Tool.define("edit", {
       }
     });
     let output = "Edit applied successfully.";
-    await LSP.touchFile(filePath, true);
-    const diagnostics = await LSP.diagnostics();
-    const normalizedFilePath = filePath;
-    const issues = diagnostics.get(normalizedFilePath) ?? [];
-    const errors = issues.filter((item) => item.severity === 1);
-    if (errors.length > 0) {
-      const limited = errors.slice(0, MAX_DIAGNOSTICS_PER_FILE);
-      const suffix = errors.length > MAX_DIAGNOSTICS_PER_FILE ? `
-... and ${errors.length - MAX_DIAGNOSTICS_PER_FILE} more` : "";
-      output += `
-
-LSP errors detected in this file, please fix:
-<diagnostics file="${filePath}">
-${limited.map(LSP.Diagnostic.pretty).join("\n")}${suffix}
-</diagnostics>`;
-    }
     return {
       metadata: {
-        diagnostics,
+        diagnostics: {},
         diff,
         filediff
       },
@@ -19189,8 +19929,8 @@ var BatchTool = Tool.define("batch", async () => {
     }),
     formatValidationError(error) {
       const formattedErrors = error.issues.map((issue) => {
-        const path = issue.path.length > 0 ? issue.path.join(".") : "root";
-        return `  - ${path}: ${issue.message}`;
+        const path3 = issue.path.length > 0 ? issue.path.join(".") : "root";
+        return `  - ${path3}: ${issue.message}`;
       }).join("\n");
       return `Invalid parameters for tool 'batch':
 ${formattedErrors}
@@ -19199,11 +19939,11 @@ Expected payload format:
   [{"tool": "tool_name", "parameters": {...}}, {...}]`;
     },
     async execute(params, ctx) {
-      const { Session } = await import("./session-3H7MDN6G-ILPE3VAH.js");
-      const { PartID: PartID2 } = await import("./schema-2CACIKZR-3CAWV3IP.js");
+      const { Session } = await import("./session-636PXOZA-R22RGDNY.js");
+      const { PartID: PartID2 } = await import("./schema-5YFIZCUA-MSI3TUIK.js");
       const toolCalls = params.tool_calls.slice(0, 25);
       const discardedCalls = params.tool_calls.slice(25);
-      const { ToolRegistry: ToolRegistry2 } = await import("./registry-N6XVTLPC-H2PNFK4G.js");
+      const { ToolRegistry } = await import("./registry-QKGWHOWL-MO5OSMIR.js");
       const availableTools = await ctx.toolRegistry.tools({ modelID: ModelID.make(""), providerID: ProviderID.make("") });
       const toolMap = new Map(availableTools.map((t) => [t.id, t]));
       const executeCall = async (call) => {
@@ -19223,7 +19963,7 @@ Expected payload format:
             );
           }
           const validatedParams = tool.parameters.parse(call.parameters);
-          await ctx.session.updatePart({
+          await ctx.memory.updatePart({
             id: partID,
             messageID: ctx.messageID,
             sessionID: ctx.sessionID,
@@ -19245,7 +19985,7 @@ Expected payload format:
             sessionID: ctx.sessionID,
             messageID: ctx.messageID
           }));
-          await ctx.session.updatePart({
+          await ctx.memory.updatePart({
             id: partID,
             messageID: ctx.messageID,
             sessionID: ctx.sessionID,
@@ -19267,7 +20007,7 @@ Expected payload format:
           });
           return { success: true, tool: call.tool, result };
         } catch (error) {
-          await ctx.session.updatePart({
+          await ctx.memory.updatePart({
             id: partID,
             messageID: ctx.messageID,
             sessionID: ctx.sessionID,
@@ -19291,7 +20031,7 @@ Expected payload format:
       const now = Date.now();
       for (const call of discardedCalls) {
         const partID = PartID2.ascending();
-        await ctx.session.updatePart({
+        await ctx.memory.updatePart({
           id: partID,
           messageID: ctx.messageID,
           sessionID: ctx.sessionID,
@@ -19504,7 +20244,6 @@ ${suggestions.join("\n")}`);
 (End of file - total ${totalLines} lines)`;
     }
     output += "\n</content>";
-    LSP.touchFile(filepath, false);
     ctx.fileTime.read(ctx.sessionID, filepath);
     return {
       title,
@@ -19964,8 +20703,6 @@ Usage:
 - NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
 - Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.
 `;
-var MAX_DIAGNOSTICS_PER_FILE2 = 20;
-var MAX_PROJECT_DIAGNOSTICS_FILES = 5;
 var WriteTool = Tool.define("write", {
   description: DESCRIPTION7,
   parameters: zod_default.object({
@@ -19991,39 +20728,11 @@ var WriteTool = Tool.define("write", {
     await ctx.fs.write(filepath, params.content);
     ctx.emit("file.edited", { file: filepath });
     ctx.fileTime.read(ctx.sessionID, filepath);
-    let output = "Wrote file successfully.";
-    await LSP.touchFile(filepath, true);
-    const diagnostics = await LSP.diagnostics();
-    const normalizedFilepath = filepath;
-    let projectDiagnosticsCount = 0;
-    for (const [file, issues] of Object.entries(diagnostics)) {
-      const errors = issues.filter((item) => item.severity === 1);
-      if (errors.length === 0) continue;
-      const limited = errors.slice(0, MAX_DIAGNOSTICS_PER_FILE2);
-      const suffix = errors.length > MAX_DIAGNOSTICS_PER_FILE2 ? `
-... and ${errors.length - MAX_DIAGNOSTICS_PER_FILE2} more` : "";
-      if (file === normalizedFilepath) {
-        output += `
-
-LSP errors detected in this file, please fix:
-<diagnostics file="${filepath}">
-${limited.map(LSP.Diagnostic.pretty).join("\n")}${suffix}
-</diagnostics>`;
-        continue;
-      }
-      if (projectDiagnosticsCount >= MAX_PROJECT_DIAGNOSTICS_FILES) continue;
-      projectDiagnosticsCount++;
-      output += `
-
-LSP errors detected in other files:
-<diagnostics file="${file}">
-${limited.map(LSP.Diagnostic.pretty).join("\n")}${suffix}
-</diagnostics>`;
-    }
+    const output = "Wrote file successfully.";
     return {
       title: relative(ctx.worktree, filepath),
       metadata: {
-        diagnostics,
+        diagnostics: {},
         filepath,
         exists
       },
@@ -20045,274 +20754,6 @@ var InvalidTool = Tool.define("invalid", {
     };
   }
 });
-function parseFrontmatter(input) {
-  const match = input.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match) return { data: {}, content: input };
-  const yaml = match[1];
-  const data = {};
-  for (const line of yaml.split(/\r?\n/)) {
-    const kv = line.match(/^([a-zA-Z_]\w*)\s*:\s*(.*)$/);
-    if (kv) data[kv[1]] = kv[2].trim().replace(/^["']|["']$/g, "");
-  }
-  const content = input.slice(match[0].length).replace(/^\r?\n/, "");
-  return { data, content };
-}
-var ConfigMarkdown;
-((ConfigMarkdown2) => {
-  ConfigMarkdown2.FILE_REGEX = /(?<![\w`])@(\.?[^\s`,.]*(?:\.[^\s`,.]+)*)/g;
-  ConfigMarkdown2.SHELL_REGEX = /!`([^`]+)`/g;
-  function files(template) {
-    return Array.from(template.matchAll(ConfigMarkdown2.FILE_REGEX));
-  }
-  ConfigMarkdown2.files = files;
-  function shell(template) {
-    return Array.from(template.matchAll(ConfigMarkdown2.SHELL_REGEX));
-  }
-  ConfigMarkdown2.shell = shell;
-  function fallbackSanitization(content) {
-    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-    if (!match) return content;
-    const frontmatter = match[1];
-    const lines = frontmatter.split(/\r?\n/);
-    const result = [];
-    for (const line of lines) {
-      if (line.trim().startsWith("#") || line.trim() === "") {
-        result.push(line);
-        continue;
-      }
-      if (line.match(/^\s+/)) {
-        result.push(line);
-        continue;
-      }
-      const kvMatch = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.*)$/);
-      if (!kvMatch) {
-        result.push(line);
-        continue;
-      }
-      const key = kvMatch[1];
-      const value = kvMatch[2].trim();
-      if (value === "" || value === ">" || value === "|" || value.startsWith('"') || value.startsWith("'")) {
-        result.push(line);
-        continue;
-      }
-      if (value.includes(":")) {
-        result.push(`${key}: |-`);
-        result.push(`  ${value}`);
-        continue;
-      }
-      result.push(line);
-    }
-    const processed = result.join("\n");
-    return content.replace(frontmatter, () => processed);
-  }
-  ConfigMarkdown2.fallbackSanitization = fallbackSanitization;
-  async function parse(context, filePath) {
-    const template = await context.fs.readText(filePath);
-    try {
-      return parseFrontmatter(template);
-    } catch {
-      try {
-        return parseFrontmatter(fallbackSanitization(template));
-      } catch (err) {
-        throw new ConfigMarkdown2.FrontmatterError(
-          {
-            path: filePath,
-            message: `${filePath}: Failed to parse YAML frontmatter: ${err instanceof Error ? err.message : String(err)}`
-          },
-          { cause: err }
-        );
-      }
-    }
-  }
-  ConfigMarkdown2.parse = parse;
-  ConfigMarkdown2.FrontmatterError = NamedError.create(
-    "ConfigFrontmatterError",
-    external_exports.object({
-      path: external_exports.string(),
-      message: external_exports.string()
-    })
-  );
-})(ConfigMarkdown || (ConfigMarkdown = {}));
-var Skill;
-((Skill2) => {
-  Skill2.Info = zod_default.object({
-    name: zod_default.string(),
-    description: zod_default.string(),
-    location: zod_default.string(),
-    content: zod_default.string()
-  });
-  const SKILL_DIRS = [".claude", ".agents", ".opencode"];
-  const SKILL_GLOB = "skills/**/SKILL.md";
-  const ANY_SKILL_GLOB = "**/SKILL.md";
-  class SkillService {
-    _promise;
-    constructor(context) {
-      this._promise = discover(context);
-    }
-    async get(name) {
-      return (await this._promise).skills[name];
-    }
-    async all() {
-      return Object.values((await this._promise).skills);
-    }
-    async dirs() {
-      return (await this._promise).dirs;
-    }
-  }
-  Skill2.SkillService = SkillService;
-  async function discover(context) {
-    const log = context.log.create({ service: "skill" });
-    const skills = {};
-    const dirs = /* @__PURE__ */ new Set();
-    const addSkill = async (match) => {
-      const md = await ConfigMarkdown.parse(context, match).catch((err) => {
-        log.error("failed to load skill", { skill: match, err });
-        return void 0;
-      });
-      if (!md) return;
-      const parsed = Skill2.Info.pick({ name: true, description: true }).safeParse(md.data);
-      if (!parsed.success) return;
-      if (skills[parsed.data.name]) {
-        log.warn("duplicate skill", { name: parsed.data.name, existing: skills[parsed.data.name].location, duplicate: match });
-      }
-      dirs.add(dirname(match));
-      skills[parsed.data.name] = {
-        name: parsed.data.name,
-        description: parsed.data.description,
-        location: match,
-        content: md.content
-      };
-    };
-    const scan = async (pattern, cwd) => {
-      const matches = await context.fs.glob(pattern, { cwd, absolute: true, dot: true, follow: true, nodir: true }).catch(() => []);
-      await Promise.all(matches.map(addSkill));
-    };
-    let current = context.directory;
-    while (true) {
-      for (const target of SKILL_DIRS) {
-        const search = join(current, target);
-        if (await context.fs.exists(search)) await scan(SKILL_GLOB, search);
-      }
-      if (context.worktree === current) break;
-      const parent = dirname(current);
-      if (parent === current) break;
-      current = parent;
-    }
-    for (const skillPath of context.config.skills?.paths ?? []) {
-      const resolved = isAbsolute(skillPath) ? skillPath : join(context.directory, skillPath);
-      if (!await context.fs.isDir(resolved)) {
-        log.warn("skill path not found", { path: resolved });
-        continue;
-      }
-      await scan(ANY_SKILL_GLOB, resolved);
-    }
-    return { skills, dirs: Array.from(dirs) };
-  }
-  function fmt(list, opts) {
-    if (list.length === 0) return "No skills are currently available.";
-    if (opts.verbose) {
-      return [
-        "<available_skills>",
-        ...list.flatMap((s) => [
-          `  <skill>`,
-          `    <name>${s.name}</name>`,
-          `    <description>${s.description}</description>`,
-          `    <location>${pathToFileURL(s.location).href}</location>`,
-          `  </skill>`
-        ]),
-        "</available_skills>"
-      ].join("\n");
-    }
-    return ["## Available Skills", ...list.map((s) => `- **${s.name}**: ${s.description}`)].join("\n");
-  }
-  Skill2.fmt = fmt;
-})(Skill || (Skill = {}));
-var SkillTool = Tool.define("skill", async (ctx) => {
-  const list = await ctx?.agentContext?.skill.all() ?? [];
-  const description = list.length === 0 ? "Load a specialized skill that provides domain-specific instructions and workflows. No skills are currently available." : [
-    "Load a specialized skill that provides domain-specific instructions and workflows.",
-    "",
-    "When you recognize that a task matches one of the available skills listed below, use this tool to load the full skill instructions.",
-    "",
-    "The skill will inject detailed instructions, workflows, and access to bundled resources (scripts, references, templates) into the conversation context.",
-    "",
-    'Tool output includes a `<skill_content name="...">` block with the loaded content.',
-    "",
-    "The following skills provide specialized sets of instructions for particular tasks",
-    "Invoke this tool to load a skill when a task matches one of the available skills listed below:",
-    "",
-    Skill.fmt(list, { verbose: false })
-  ].join("\n");
-  const examples = list.map((skill) => `'${skill.name}'`).slice(0, 3).join(", ");
-  const hint = examples.length > 0 ? ` (e.g., ${examples}, ...)` : "";
-  const parameters = zod_default.object({
-    name: zod_default.string().describe(`The name of the skill from available_skills${hint}`)
-  });
-  return {
-    description,
-    parameters,
-    async execute(params, ctx2) {
-      const skill = await ctx2.skill.get(params.name);
-      if (!skill) {
-        const available = await ctx2.skill.all().then((x) => x.map((skill2) => skill2.name).join(", "));
-        throw new Error(`Skill "${params.name}" not found. Available skills: ${available || "none"}`);
-      }
-      await ctx2.ask({
-        permission: "skill",
-        patterns: [params.name],
-        always: [params.name],
-        metadata: {}
-      });
-      const dir = dirname(skill.location);
-      const base = pathToFileURL2(dir).href;
-      const limit = 10;
-      const files = await iife(async () => {
-        if (!ctx2.search) throw new Error("Search provider is required for the skill tool");
-        const filePaths = await ctx2.search.listFiles({
-          cwd: dir,
-          follow: false,
-          hidden: true,
-          limit: limit + 1,
-          // Extra to filter out SKILL.md
-          signal: ctx2.abort
-        });
-        const arr = [];
-        for (const file of filePaths) {
-          if (file.includes("SKILL.md")) {
-            continue;
-          }
-          arr.push(resolve(dir, file));
-          if (arr.length >= limit) {
-            break;
-          }
-        }
-        return arr;
-      }).then((f) => f.map((file) => `<file>${file}</file>`).join("\n"));
-      return {
-        title: `Loaded skill: ${skill.name}`,
-        output: [
-          `<skill_content name="${skill.name}">`,
-          `# Skill: ${skill.name}`,
-          "",
-          skill.content.trim(),
-          "",
-          `Base directory for this skill: ${base}`,
-          "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.",
-          "Note: file list is sampled.",
-          "",
-          "<skill_files>",
-          files,
-          "</skill_files>",
-          "</skill_content>"
-        ].join("\n"),
-        metadata: {
-          name: skill.name,
-          dir
-        }
-      };
-    }
-  };
-});
 var DESCRIPTION8 = `- Search the web using Exa AI - performs real-time web searches and can scrape content from specific URLs
 - Provides up-to-date information for current events and recent data
 - Supports configurable result counts and returns the content from the most relevant websites
@@ -21199,12 +21640,6 @@ var ApplyPatchTool = Tool.define("apply_patch", {
         ctx.emit("file.edited", { file: edited });
       }
     }
-    for (const change of fileChanges) {
-      if (change.type === "delete") continue;
-      const target = change.movePath ?? change.filePath;
-      await LSP.touchFile(target, true);
-    }
-    const diagnostics = await LSP.diagnostics();
     const summaryLines = fileChanges.map((change) => {
       if (change.type === "add") {
         return `A ${relative(ctx.worktree, change.filePath).replaceAll("\\", "/")}`;
@@ -21215,91 +21650,35 @@ var ApplyPatchTool = Tool.define("apply_patch", {
       const target = change.movePath ?? change.filePath;
       return `M ${relative(ctx.worktree, target).replaceAll("\\", "/")}`;
     });
-    let output = `Success. Updated the following files:
+    const output = `Success. Updated the following files:
 ${summaryLines.join("\n")}`;
-    const MAX_DIAGNOSTICS_PER_FILE3 = 20;
-    for (const change of fileChanges) {
-      if (change.type === "delete") continue;
-      const target = change.movePath ?? change.filePath;
-      const normalized = target;
-      const issues = diagnostics.get(normalized) ?? [];
-      const errors = issues.filter((item) => item.severity === 1);
-      if (errors.length > 0) {
-        const limited = errors.slice(0, MAX_DIAGNOSTICS_PER_FILE3);
-        const suffix = errors.length > MAX_DIAGNOSTICS_PER_FILE3 ? `
-... and ${errors.length - MAX_DIAGNOSTICS_PER_FILE3} more` : "";
-        output += `
-
-LSP errors detected in ${relative(ctx.worktree, target).replaceAll("\\", "/")}, please fix:
-<diagnostics file="${target}">
-${limited.map(LSP.Diagnostic.pretty).join("\n")}${suffix}
-</diagnostics>`;
-      }
-    }
     return {
       title: output,
       metadata: {
         diff: totalDiff,
         files,
-        diagnostics
+        diagnostics: {}
       },
       output
     };
   }
 });
-var ToolRegistry;
-((ToolRegistry2) => {
-  class ToolRegistryService {
-    _promise;
-    context;
-    constructor(context) {
-      this.context = context;
-      this._promise = initTools(context);
-    }
-    async register(tool) {
-      const { custom } = await this._promise;
-      const idx = custom.findIndex((t) => t.id === tool.id);
-      if (idx >= 0) {
-        custom.splice(idx, 1, tool);
-        return;
-      }
-      custom.push(tool);
-    }
-    async tools(model) {
-      return ToolRegistry2.tools(this.context, model);
-    }
+var ToolRegistryService = class {
+  _custom = [];
+  context;
+  constructor(context) {
+    this.context = context;
   }
-  ToolRegistry2.ToolRegistryService = ToolRegistryService;
-  async function initTools(context) {
-    const custom = [];
-    return { custom };
-  }
-  function fromPlugin(id, def) {
-    return {
-      id,
-      init: async (initCtx) => ({
-        parameters: zod_default.object(def.args),
-        description: def.description,
-        execute: async (args, ctx) => {
-          const pluginCtx = {
-            ...ctx,
-            directory: ctx.directory,
-            worktree: ctx.worktree
-          };
-          const result = await def.execute(args, pluginCtx);
-          const out = await Truncate.output(ctx, result, {});
-          return {
-            title: "",
-            output: out.truncated ? out.content : result,
-            metadata: { truncated: out.truncated, outputPath: out.truncated ? out.outputPath : void 0 }
-          };
-        }
-      })
-    };
+  async register(tool) {
+    const idx = this._custom.findIndex((t) => t.id === tool.id);
+    if (idx >= 0) {
+      this._custom.splice(idx, 1, tool);
+      return;
+    }
+    this._custom.push(tool);
   }
-  async function all(context) {
-    const custom = await context.toolRegistry._promise.then((x) => x.custom);
-    const config = context.config;
+  all() {
+    const config = this.context.config;
     return [
       InvalidTool,
       BashTool,
@@ -21313,22 +21692,21 @@ var ToolRegistry;
       // TodoReadTool,
       WebSearchTool,
       CodeSearchTool,
-      SkillTool,
       ApplyPatchTool,
-      ...context.tools ?? [],
+      ...this.context.tools ?? [],
       ...config.experimental?.batch_tool === true ? [BatchTool] : [],
       ...Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE && Flag.OPENCODE_CLIENT === "cli" ? [PlanExitTool] : [],
-      ...custom
+      ...this._custom
     ];
   }
-  async function ids(context) {
-    return all(context).then((x) => x.map((t) => t.id));
+  async ids() {
+    return this.all().map((t) => t.id);
   }
-  ToolRegistry2.ids = ids;
-  async function tools(context, model) {
-    const tools2 = await all(context);
+  async tools(model) {
+    const tools = this.all();
+    const context = this.context;
     const result = await Promise.all(
-      tools2.filter((t) => {
+      tools.filter((t) => {
         if (t.id === "codesearch" || t.id === "websearch") {
           return model.providerID === ProviderID.opencode || Flag.OPENCODE_ENABLE_EXA;
         }
@@ -21360,17 +21738,18 @@ var ToolRegistry;
     );
     return result;
   }
-  ToolRegistry2.tools = tools;
-})(ToolRegistry || (ToolRegistry = {}));
+};
 
 export {
+  consoleLogger,
+  NodeFS,
+  NodeSearchProvider,
+  SqlJsStorage,
   SchedulerService,
   Tool,
-  LSP,
+  Flag,
   ReadTool,
-  ConfigMarkdown,
-  Skill,
-  ToolRegistry
+  ToolRegistryService
 };
 /*! Bundled license information: