@deepagents/text2sql 0.13.1 → 0.14.0

package/dist/index.js

@@ -387,7 +387,7 @@ function getTablesWithRelated(allTables, relationships, filter) {
 
 // packages/text2sql/src/lib/agents/developer.agent.ts
 import { tool } from "ai";
-import dedent from "dedent";
+import dedent2 from "dedent";
 import z2 from "zod";
 import { toState } from "@deepagents/agent";
 
@@ -405,6 +405,7 @@ import spawn2 from "nano-spawn";
 import {
   createBashTool
 } from "bash-tool";
+import dedent from "dedent";
 import YAML from "yaml";
 import { DatabaseSync } from "node:sqlite";
 import { groq } from "@ai-sdk/groq";
@@ -626,7 +627,7 @@ function assistantText(content, options) {
     parts: [{ type: "text", text: content }]
   });
 }
-var LAZY_ID = Symbol("lazy-id");
+var LAZY_ID = Symbol.for("@deepagents/context:lazy-id");
 function isLazyFragment(fragment2) {
   return LAZY_ID in fragment2;
 }
@@ -1013,7 +1014,7 @@ var ContextEngine = class {
   async #createBranchFrom(messageId, switchTo) {
     const branches = await this.#store.listBranches(this.#chatId);
     const samePrefix = branches.filter(
-      (b) => b.name === this.#branchName || b.name.startsWith(`${this.#branchName}-v`)
+      (it) => it.name === this.#branchName || it.name.startsWith(`${this.#branchName}-v`)
     );
     const newBranchName = `${this.#branchName}-v${samePrefix.length + 1}`;
     const newBranch = {
@@ -1041,6 +1042,15 @@ var ContextEngine = class {
       createdAt: newBranch.createdAt
     };
   }
+  /**
+   * Rewind to a message without clearing pending messages.
+   * Used internally when saving an update to an existing message.
+   */
+  async #rewindForUpdate(messageId) {
+    const pendingBackup = [...this.#pendingMessages];
+    await this.rewind(messageId);
+    this.#pendingMessages = pendingBackup;
+  }
   /**
    * Get the current chat ID.
    */
@@ -1125,7 +1135,18 @@ var ContextEngine = class {
         messages.push(message(msg.data).codec?.decode());
       }
     }
+    for (let i = 0; i < this.#pendingMessages.length; i++) {
+      const fragment2 = this.#pendingMessages[i];
+      if (isLazyFragment(fragment2)) {
+        this.#pendingMessages[i] = await this.#resolveLazyFragment(fragment2);
+      }
+    }
     for (const fragment2 of this.#pendingMessages) {
+      if (!fragment2.codec) {
+        throw new Error(
+          `Fragment "${fragment2.name}" is missing codec. Lazy fragments must be resolved before decode.`
+        );
+      }
       const decoded = fragment2.codec.decode();
       messages.push(decoded);
     }
@@ -1156,9 +1177,24 @@ var ContextEngine = class {
         this.#pendingMessages[i] = await this.#resolveLazyFragment(fragment2);
       }
     }
+    for (const fragment2 of this.#pendingMessages) {
+      if (fragment2.id) {
+        const existing = await this.#store.getMessage(fragment2.id);
+        if (existing && existing.parentId) {
+          await this.#rewindForUpdate(existing.parentId);
+          fragment2.id = crypto.randomUUID();
+          break;
+        }
+      }
+    }
     let parentId = this.#branch.headMessageId;
     const now = Date.now();
     for (const fragment2 of this.#pendingMessages) {
+      if (!fragment2.codec) {
+        throw new Error(
+          `Fragment "${fragment2.name}" is missing codec. Lazy fragments must be resolved before encode.`
+        );
+      }
       const messageData = {
         id: fragment2.id ?? crypto.randomUUID(),
         chatId: this.#chatId,
@@ -1518,33 +1554,28 @@ var ContextEngine = class {
     return void 0;
   }
   /**
-   * Extract skill path mappings from available_skills fragments.
-   * Returns array of { host, sandbox } for mounting in sandbox filesystem.
-   *
-   * Reads the original `paths` configuration stored in fragment metadata
-   * by the skills() fragment helper.
+   * Extract skill mounts from available_skills fragments.
+   * Returns unified mount array where entries with `name` are individual skills.
    *
    * @example
    * ```ts
    * const context = new ContextEngine({ store, chatId, userId })
    *   .set(skills({ paths: [{ host: './skills', sandbox: '/skills' }] }));
    *
-   * const mounts = context.getSkillMounts();
-   * // [{ host: './skills', sandbox: '/skills' }]
+   * const { mounts } = context.getSkillMounts();
+   * // mounts: [{ name: 'bi-dashboards', host: './skills/bi-dashboards/SKILL.md', sandbox: '/skills/bi-dashboards/SKILL.md' }]
+   *
+   * // Extract skills only (entries with name)
+   * const skills = mounts.filter(m => m.name);
    * ```
    */
   getSkillMounts() {
-    const mounts = [];
     for (const fragment2 of this.#fragments) {
-      if (fragment2.name === "available_skills" && fragment2.metadata && Array.isArray(fragment2.metadata.paths)) {
-        for (const mapping of fragment2.metadata.paths) {
-          if (typeof mapping === "object" && mapping !== null && typeof mapping.host === "string" && typeof mapping.sandbox === "string") {
-            mounts.push({ host: mapping.host, sandbox: mapping.sandbox });
-          }
-        }
+      if (fragment2.name === "available_skills" && fragment2.metadata?.mounts) {
+        return { mounts: fragment2.metadata.mounts };
       }
     }
-    return mounts;
+    return { mounts: [] };
   }
   /**
    * Inspect the full context state for debugging.
@@ -1715,11 +1746,14 @@ function pass(part) {
 function fail(feedback) {
   return { type: "fail", feedback };
 }
+function stop(part) {
+  return { type: "stop", part };
+}
 function runGuardrailChain(part, guardrails, context) {
   let currentPart = part;
   for (const guardrail2 of guardrails) {
     const result = guardrail2.handle(currentPart, context);
-    if (result.type === "fail") {
+    if (result.type === "fail" || result.type === "stop") {
       return result;
     }
     currentPart = result.part;
@@ -1762,6 +1796,15 @@ var errorRecoveryGuardrail = {
     if (errorText.includes("not in request.tools") || errorText.includes("tool") && errorText.includes("not found")) {
       const toolMatch = errorText.match(/tool '([^']+)'/);
       const toolName = toolMatch ? toolMatch[1] : "unknown";
+      const matchingSkill = context.availableSkills.find(
+        (skill) => skill.name === toolName
+      );
+      if (matchingSkill) {
+        return logAndFail(
+          `Skill confused as tool: ${toolName}`,
+          `"${toolName}" is a skill, not a tool. Read the skill at ${matchingSkill.sandbox} to use it.`
+        );
+      }
       if (context.availableTools.length > 0) {
         return logAndFail(
           `Unregistered tool: ${toolName}`,
@@ -1779,97 +1822,79 @@ var errorRecoveryGuardrail = {
         "I generated malformed JSON for the tool arguments. Let me format my tool call properly with valid JSON."
       );
     }
+    if (errorText.includes("validation failed") && errorText.includes("did not match schema")) {
+      const toolMatch = errorText.match(/parameters for tool (\w+)/);
+      const toolName = toolMatch ? toolMatch[1] : "unknown";
+      const schemaErrors = errorText.match(/errors: \[([^\]]+)\]/)?.[1] || "";
+      return logAndFail(
+        `Schema validation: ${toolName}`,
+        `I called "${toolName}" with invalid parameters. Schema errors: ${schemaErrors}. Let me fix the parameters and try again.`
+      );
+    }
     if (errorText.includes("Parsing failed")) {
       return logAndFail(
         "Parsing failed",
         "My response format was invalid. Let me try again with a properly formatted response."
       );
     }
-    console.dir({ part }, { depth: null });
-    return logAndFail(
-      "Unknown error",
-      `An error occurred: ${errorText}. Let me try a different approach.`
+    if (errorText.includes("Failed to call a function") || errorText.includes("failed_generation")) {
+      if (context.availableTools.length > 0) {
+        return logAndFail(
+          "Failed function call",
+          `My function call was malformed. Available tools: ${context.availableTools.join(", ")}. Let me format my tool call correctly.`
+        );
+      }
+      return logAndFail(
+        "Failed function call (no tools)",
+        "My function call was malformed. Let me respond with plain text instead."
+      );
+    }
+    console.log(
+      `${prefix} ${chalk.yellow("Unknown error - stopping without retry")}`
     );
+    return stop(part);
   }
 };
-var STORE_DDL = `
--- Chats table
--- createdAt/updatedAt: DEFAULT for insert, inline SET for updates
-CREATE TABLE IF NOT EXISTS chats (
-  id TEXT PRIMARY KEY,
-  userId TEXT NOT NULL,
-  title TEXT,
-  metadata TEXT,
-  createdAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
-  updatedAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
-);
-
-CREATE INDEX IF NOT EXISTS idx_chats_updatedAt ON chats(updatedAt);
-CREATE INDEX IF NOT EXISTS idx_chats_userId ON chats(userId);
-
--- Messages table (nodes in the DAG)
-CREATE TABLE IF NOT EXISTS messages (
-  id TEXT PRIMARY KEY,
-  chatId TEXT NOT NULL,
-  parentId TEXT,
-  name TEXT NOT NULL,
-  type TEXT,
-  data TEXT NOT NULL,
-  createdAt INTEGER NOT NULL,
-  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,
-  FOREIGN KEY (parentId) REFERENCES messages(id)
-);
-
-CREATE INDEX IF NOT EXISTS idx_messages_chatId ON messages(chatId);
-CREATE INDEX IF NOT EXISTS idx_messages_parentId ON messages(parentId);
-
--- Branches table (pointers to head messages)
-CREATE TABLE IF NOT EXISTS branches (
-  id TEXT PRIMARY KEY,
-  chatId TEXT NOT NULL,
-  name TEXT NOT NULL,
-  headMessageId TEXT,
-  isActive INTEGER NOT NULL DEFAULT 0,
-  createdAt INTEGER NOT NULL,
-  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,
-  FOREIGN KEY (headMessageId) REFERENCES messages(id),
-  UNIQUE(chatId, name)
-);
+var SKILLS_INSTRUCTIONS = dedent`A skill is a set of local instructions to follow that is stored in a \`SKILL.md\` file. Below is the list of skills that can be used. Each entry includes a name, description, and file path so you can open the source for full instructions when using a specific skill.
 
-CREATE INDEX IF NOT EXISTS idx_branches_chatId ON branches(chatId);
-
--- Checkpoints table (pointers to message nodes)
-CREATE TABLE IF NOT EXISTS checkpoints (
-  id TEXT PRIMARY KEY,
-  chatId TEXT NOT NULL,
-  name TEXT NOT NULL,
-  messageId TEXT NOT NULL,
-  createdAt INTEGER NOT NULL,
-  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,
-  FOREIGN KEY (messageId) REFERENCES messages(id),
-  UNIQUE(chatId, name)
-);
-
-CREATE INDEX IF NOT EXISTS idx_checkpoints_chatId ON checkpoints(chatId);
-
--- FTS5 virtual table for full-text search
--- messageId/chatId/name are UNINDEXED (stored but not searchable, used for filtering/joining)
--- Only 'content' is indexed for full-text search
-CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
-  messageId UNINDEXED,
-  chatId UNINDEXED,
-  name UNINDEXED,
-  content,
-  tokenize='porter unicode61'
-);
-`;
+### How to use skills
+- Discovery: The list below shows the skills available in this session (name + description + file path). Skill bodies live on disk at the listed paths.
+- Trigger rules: If the user names a skill (with \`$SkillName\` or plain text) OR the task clearly matches a skill's description shown below, you must use that skill for that turn before doing anything else. Multiple mentions mean use them all. Do not carry skills across turns unless re-mentioned.
+- Missing/blocked: If a named skill isn't in the list or the path can't be read, say so briefly and continue with the best fallback.
+- How to use a skill (progressive disclosure):
+  1) After deciding to use a skill, open its \`SKILL.md\`. Read only enough to follow the workflow.
+  2) If \`SKILL.md\` points to extra folders such as \`references/\`, load only the specific files needed for the request; don't bulk-load everything.
+  3) If \`scripts/\` exist, prefer running or patching them instead of retyping large code blocks.
+  4) If \`assets/\` or templates exist, reuse them instead of recreating from scratch.
+- Coordination and sequencing:
+  - If multiple skills apply, choose the minimal set that covers the request and state the order you'll use them.
+  - Announce which skill(s) you're using and why (one short line). If you skip an obvious skill, say why.
+- Context hygiene:
+  - Keep context small: summarize long sections instead of pasting them; only load extra files when needed.
+  - Avoid deep reference-chasing: prefer opening only files directly linked from \`SKILL.md\` unless you're blocked.
+  - When variants exist (frameworks, providers, domains), pick only the relevant reference file(s) and note that choice.
+- Safety and fallback: If a skill can't be applied cleanly (missing files, unclear instructions), state the issue, pick the next-best approach, and continue.`;
+var ddl_sqlite_default = "-- Context Store DDL for SQLite\n-- This schema implements a DAG-based message history with branching and checkpoints.\n\n-- Performance PRAGMAs (session-level, run on each connection)\nPRAGMA journal_mode = WAL;\nPRAGMA synchronous = NORMAL;\nPRAGMA cache_size = -64000;\nPRAGMA temp_store = MEMORY;\nPRAGMA mmap_size = 268435456;\n\n-- Integrity\nPRAGMA foreign_keys = ON;\n\n-- Chats table\n-- createdAt/updatedAt: DEFAULT for insert, inline SET for updates\nCREATE TABLE IF NOT EXISTS chats (\n  id TEXT PRIMARY KEY,\n  userId TEXT NOT NULL,\n  title TEXT,\n  metadata TEXT,\n  createdAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),\n  updatedAt INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)\n);\n\nCREATE INDEX IF NOT EXISTS idx_chats_updatedAt ON chats(updatedAt);\nCREATE INDEX IF NOT EXISTS idx_chats_userId ON chats(userId);\n-- Composite index for listChats(): WHERE userId = ? ORDER BY updatedAt DESC\nCREATE INDEX IF NOT EXISTS idx_chats_userId_updatedAt ON chats(userId, updatedAt DESC);\n\n-- Messages table (nodes in the DAG)\nCREATE TABLE IF NOT EXISTS messages (\n  id TEXT PRIMARY KEY,\n  chatId TEXT NOT NULL,\n  parentId TEXT,\n  name TEXT NOT NULL,\n  type TEXT,\n  data TEXT NOT NULL,\n  createdAt INTEGER NOT NULL,\n  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,\n  FOREIGN KEY (parentId) REFERENCES messages(id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_messages_chatId ON messages(chatId);\nCREATE INDEX IF NOT EXISTS idx_messages_parentId ON messages(parentId);\n-- Composite index for recursive CTE parent traversal in getMessageChain()\nCREATE INDEX IF NOT EXISTS idx_messages_chatId_parentId ON messages(chatId, parentId);\n\n-- Branches table (pointers to head messages)\nCREATE TABLE IF NOT EXISTS branches (\n  id TEXT PRIMARY KEY,\n  chatId TEXT NOT NULL,\n  name TEXT NOT NULL,\n  headMessageId TEXT,\n  isActive INTEGER NOT NULL DEFAULT 0,\n  createdAt INTEGER NOT NULL,\n  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,\n  FOREIGN KEY (headMessageId) REFERENCES messages(id),\n  UNIQUE(chatId, name)\n);\n\nCREATE INDEX IF NOT EXISTS idx_branches_chatId ON branches(chatId);\n-- Composite index for getActiveBranch(): WHERE chatId = ? AND isActive = 1\nCREATE INDEX IF NOT EXISTS idx_branches_chatId_isActive ON branches(chatId, isActive);\n\n-- Checkpoints table (pointers to message nodes)\nCREATE TABLE IF NOT EXISTS checkpoints (\n  id TEXT PRIMARY KEY,\n  chatId TEXT NOT NULL,\n  name TEXT NOT NULL,\n  messageId TEXT NOT NULL,\n  createdAt INTEGER NOT NULL,\n  FOREIGN KEY (chatId) REFERENCES chats(id) ON DELETE CASCADE,\n  FOREIGN KEY (messageId) REFERENCES messages(id),\n  UNIQUE(chatId, name)\n);\n\nCREATE INDEX IF NOT EXISTS idx_checkpoints_chatId ON checkpoints(chatId);\n\n-- FTS5 virtual table for full-text search\n-- messageId/chatId/name are UNINDEXED (stored but not searchable, used for filtering/joining)\n-- Only 'content' is indexed for full-text search\nCREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(\n  messageId UNINDEXED,\n  chatId UNINDEXED,\n  name UNINDEXED,\n  content,\n  tokenize='porter unicode61'\n);\n";
 var SqliteContextStore = class extends ContextStore {
   #db;
-  constructor(path3) {
+  #statements = /* @__PURE__ */ new Map();
+  /**
+   * Get or create a prepared statement.
+   * Statements are cached for the lifetime of the store to avoid
+   * repeated SQL parsing and compilation overhead.
+   */
+  #stmt(sql) {
+    let stmt = this.#statements.get(sql);
+    if (!stmt) {
+      stmt = this.#db.prepare(sql);
+      this.#statements.set(sql, stmt);
+    }
+    return stmt;
+  }
+  constructor(path32) {
     super();
-    this.#db = new DatabaseSync(path3);
-    this.#db.exec("PRAGMA foreign_keys = ON");
-    this.#db.exec(STORE_DDL);
+    this.#db = new DatabaseSync(path32);
+    this.#db.exec(ddl_sqlite_default);
   }
   /**
    * Execute a function within a transaction.
@@ -1890,11 +1915,12 @@ var SqliteContextStore = class extends ContextStore {
   // Chat Operations
   // ==========================================================================
   async createChat(chat) {
-    this.#useTransaction(() => {
-      this.#db.prepare(
+    return this.#useTransaction(() => {
+      const row = this.#db.prepare(
         `INSERT INTO chats (id, userId, title, metadata)
-           VALUES (?, ?, ?, ?)`
-      ).run(
+           VALUES (?, ?, ?, ?)
+           RETURNING *`
+      ).get(
         chat.id,
         chat.userId,
         chat.title ?? null,
@@ -1904,6 +1930,14 @@ var SqliteContextStore = class extends ContextStore {
         `INSERT INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
            VALUES (?, ?, 'main', NULL, 1, ?)`
       ).run(crypto.randomUUID(), chat.id, Date.now());
+      return {
+        id: row.id,
+        userId: row.userId,
+        title: row.title ?? void 0,
+        metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt
+      };
     });
   }
   async upsertChat(chat) {
@@ -2046,21 +2080,16 @@ var SqliteContextStore = class extends ContextStore {
   // Message Operations (Graph Nodes)
   // ==========================================================================
   async addMessage(message2) {
-    this.#db.prepare(
+    if (message2.parentId === message2.id) {
+      throw new Error(`Message ${message2.id} cannot be its own parent`);
+    }
+    this.#stmt(
       `INSERT INTO messages (id, chatId, parentId, name, type, data, createdAt)
-         VALUES (
-           ?1,
-           ?2,
-           CASE WHEN ?3 = ?1 THEN (SELECT parentId FROM messages WHERE id = ?1) ELSE ?3 END,
-           ?4,
-           ?5,
-           ?6,
-           ?7
-         )
-         ON CONFLICT(id) DO UPDATE SET
-           name = excluded.name,
-           type = excluded.type,
-           data = excluded.data`
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         name = excluded.name,
+         type = excluded.type,
+         data = excluded.data`
     ).run(
       message2.id,
       message2.chatId,
@@ -2071,14 +2100,16 @@ var SqliteContextStore = class extends ContextStore {
       message2.createdAt
     );
     const content = typeof message2.data === "string" ? message2.data : JSON.stringify(message2.data);
-    this.#db.prepare(`DELETE FROM messages_fts WHERE messageId = ?`).run(message2.id);
-    this.#db.prepare(
+    this.#stmt(`DELETE FROM messages_fts WHERE messageId = ?`).run(message2.id);
+    this.#stmt(
       `INSERT INTO messages_fts(messageId, chatId, name, content)
-         VALUES (?, ?, ?, ?)`
+       VALUES (?, ?, ?, ?)`
     ).run(message2.id, message2.chatId, message2.name, content);
   }
   async getMessage(messageId) {
-    const row = this.#db.prepare("SELECT * FROM messages WHERE id = ?").get(messageId);
+    const row = this.#stmt("SELECT * FROM messages WHERE id = ?").get(
+      messageId
+    );
     if (!row) {
       return void 0;
     }
@@ -2093,15 +2124,16 @@ var SqliteContextStore = class extends ContextStore {
     };
   }
   async getMessageChain(headId) {
-    const rows = this.#db.prepare(
+    const rows = this.#stmt(
       `WITH RECURSIVE chain AS (
-          SELECT *, 0 as depth FROM messages WHERE id = ?
-          UNION ALL
-          SELECT m.*, c.depth + 1 FROM messages m
-          INNER JOIN chain c ON m.id = c.parentId
-        )
-        SELECT * FROM chain
-        ORDER BY depth DESC`
+        SELECT *, 0 as depth FROM messages WHERE id = ?
+        UNION ALL
+        SELECT m.*, c.depth + 1 FROM messages m
+        INNER JOIN chain c ON m.id = c.parentId
+        WHERE c.depth < 100000
+      )
+      SELECT * FROM chain
+      ORDER BY depth DESC`
     ).all(headId);
     return rows.map((row) => ({
       id: row.id,
@@ -2114,7 +2146,7 @@ var SqliteContextStore = class extends ContextStore {
     }));
   }
   async hasChildren(messageId) {
-    const row = this.#db.prepare(
+    const row = this.#stmt(
       "SELECT EXISTS(SELECT 1 FROM messages WHERE parentId = ?) as hasChildren"
     ).get(messageId);
     return row.hasChildren === 1;
@@ -2161,7 +2193,9 @@ var SqliteContextStore = class extends ContextStore {
     };
   }
   async getActiveBranch(chatId) {
-    const row = this.#db.prepare("SELECT * FROM branches WHERE chatId = ? AND isActive = 1").get(chatId);
+    const row = this.#stmt(
+      "SELECT * FROM branches WHERE chatId = ? AND isActive = 1"
+    ).get(chatId);
     if (!row) {
       return void 0;
     }
@@ -2179,45 +2213,43 @@ var SqliteContextStore = class extends ContextStore {
     this.#db.prepare("UPDATE branches SET isActive = 1 WHERE id = ?").run(branchId);
   }
   async updateBranchHead(branchId, messageId) {
-    this.#db.prepare("UPDATE branches SET headMessageId = ? WHERE id = ?").run(messageId, branchId);
+    this.#stmt("UPDATE branches SET headMessageId = ? WHERE id = ?").run(
+      messageId,
+      branchId
+    );
   }
   async listBranches(chatId) {
-    const branches = this.#db.prepare(
+    const rows = this.#db.prepare(
       `SELECT
           b.id,
           b.name,
           b.headMessageId,
           b.isActive,
-          b.createdAt
+          b.createdAt,
+          COALESCE(
+            (
+              WITH RECURSIVE chain AS (
+                SELECT id, parentId FROM messages WHERE id = b.headMessageId
+                UNION ALL
+                SELECT m.id, m.parentId FROM messages m
+                INNER JOIN chain c ON m.id = c.parentId
+              )
+              SELECT COUNT(*) FROM chain
+            ),
+            0
+          ) as messageCount
         FROM branches b
         WHERE b.chatId = ?
         ORDER BY b.createdAt ASC`
     ).all(chatId);
-    const result = [];
-    for (const branch of branches) {
-      let messageCount = 0;
-      if (branch.headMessageId) {
-        const countRow = this.#db.prepare(
-          `WITH RECURSIVE chain AS (
-              SELECT id, parentId FROM messages WHERE id = ?
-              UNION ALL
-              SELECT m.id, m.parentId FROM messages m
-              INNER JOIN chain c ON m.id = c.parentId
-            )
-            SELECT COUNT(*) as count FROM chain`
-        ).get(branch.headMessageId);
-        messageCount = countRow.count;
-      }
-      result.push({
-        id: branch.id,
-        name: branch.name,
-        headMessageId: branch.headMessageId,
-        isActive: branch.isActive === 1,
-        messageCount,
-        createdAt: branch.createdAt
-      });
-    }
-    return result;
+    return rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      headMessageId: row.headMessageId,
+      isActive: row.isActive === 1,
+      messageCount: row.messageCount,
+      createdAt: row.createdAt
+    }));
   }
   // ==========================================================================
   // Checkpoint Operations
@@ -2485,8 +2517,10 @@ var Agent = class _Agent {
         execute: async ({ writer }) => {
           let currentResult = result;
           let attempt = 0;
+          const { mounts } = context.getSkillMounts();
           const guardrailContext = {
-            availableTools: Object.keys(this.tools)
+            availableTools: Object.keys(this.tools),
+            availableSkills: mounts
           };
           while (attempt < maxRetries) {
             if (config?.abortSignal?.aborted) {
@@ -2514,10 +2548,20 @@ var Agent = class _Agent {
                 );
                 break;
               }
+              if (checkResult.type === "stop") {
+                console.log(
+                  chalk2.red(
+                    `[${this.#options.name}] Guardrail stopped - unrecoverable error, no retry`
+                  )
+                );
+                writer.write(part);
+                writer.write({ type: "finish" });
+                return;
+              }
               if (checkResult.part.type === "text-delta") {
                 accumulatedText += checkResult.part.delta;
               }
-              writer.write(checkResult.part);
+              writer.write(part);
             }
             if (!guardrailFailed) {
               writer.write({ type: "finish" });
@@ -2625,10 +2669,10 @@ var repairToolCall = async ({
   if (NoSuchToolError.isInstance(error)) {
     return null;
   }
-  const tool4 = tools3[toolCall.toolName];
+  const tool3 = tools3[toolCall.toolName];
   const { output } = await generateText({
     model: groq("openai/gpt-oss-20b"),
-    output: Output.object({ schema: tool4.inputSchema }),
+    output: Output.object({ schema: tool3.inputSchema }),
     prompt: [
       `The model tried to call the tool "${toolCall.toolName}" with the following inputs:`,
       JSON.stringify(toolCall.input),
@@ -2730,7 +2774,7 @@ var tools = {
    * Get plain-English explanation of a SQL query.
    */
   explain_sql: tool({
-    description: dedent`
+    description: dedent2`
       Get a plain-English explanation of a SQL query.
       Use this to help the user understand what a query does.
 
@@ -2759,18 +2803,14 @@ var fragments = [
 var developer_agent_default = { tools, fragments };
 
 // packages/text2sql/src/lib/agents/result-tools.ts
-import "ai";
 import { createBashTool as createBashTool2 } from "bash-tool";
 import chalk3 from "chalk";
 import {
   Bash,
-  InMemoryFs,
   MountableFs,
   OverlayFs,
-  ReadWriteFs,
   defineCommand as defineCommand2
 } from "just-bash";
-import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { v7 } from "uuid";
 function createCommand(name, subcommands) {
@@ -2825,18 +2865,13 @@ function createSqlCommand(adapter) {
           const rowsArray = Array.isArray(rows) ? rows : [];
           const content = JSON.stringify(rowsArray, null, 2);
           const filename = `${v7()}.json`;
-          const isolatedPath = `/results/${filename}`;
-          const sharedPath = `/artifacts/${filename}`;
-          await Promise.all([
-            ctx.fs.writeFile(isolatedPath, content),
-            // Current turn's isolated copy
-            ctx.fs.writeFile(sharedPath, content)
-            // Shared copy for cross-turn access
-          ]);
+          const sqlPath = `/sql/${filename}`;
+          await ctx.fs.mkdir("/sql", { recursive: true });
+          await ctx.fs.writeFile(sqlPath, content);
           const columns = rowsArray.length > 0 ? Object.keys(rowsArray[0]) : [];
           return {
             stdout: [
-              `results stored in ${sharedPath}`,
+              `results stored in ${sqlPath}`,
               `columns: ${columns.join(", ") || "(none)"}`,
               `rows: ${rowsArray.length}`
             ].join("\n") + "\n",
@@ -2882,39 +2917,25 @@ function createSqlCommand(adapter) {
   });
 }
 async function createResultTools(options) {
-  const { adapter, chatId, messageId, skillMounts = [] } = options;
+  const { adapter, skillMounts, filesystem: baseFs } = options;
   const sqlCommand = createSqlCommand(adapter);
-  const root = process.env.TEXT2SQL_FS_ROOT || process.cwd();
-  const chatDir = path.join(root, "artifacts", chatId);
-  const resultsDir = path.join(chatDir, messageId, "results");
-  await fs.mkdir(resultsDir, { recursive: true });
   const fsMounts = skillMounts.map(({ host, sandbox: sandbox2 }) => ({
-    mountPoint: sandbox2,
+    mountPoint: path.dirname(sandbox2),
     filesystem: new OverlayFs({
-      root: host,
+      root: path.dirname(host),
       mountPoint: "/",
       readOnly: true
     })
   }));
   const filesystem = new MountableFs({
-    base: new InMemoryFs(),
-    mounts: [
-      ...fsMounts,
-      {
-        mountPoint: "/results",
-        filesystem: new ReadWriteFs({ root: resultsDir })
-      },
-      {
-        mountPoint: "/artifacts",
-        filesystem: new ReadWriteFs({ root: chatDir })
-      }
-    ]
+    base: baseFs,
+    mounts: fsMounts
   });
   const bashInstance = new Bash({
     customCommands: [sqlCommand],
     fs: filesystem
   });
-  const { bash, sandbox } = await createBashTool2({
+  const { sandbox, tools: tools3 } = await createBashTool2({
     sandbox: bashInstance,
     destination: "/",
     onBeforeBashCall: ({ command }) => {
@@ -2928,7 +2949,7 @@ async function createResultTools(options) {
       return { result };
     }
   });
-  return { bash, sandbox };
+  return { sandbox, tools: tools3 };
 }
 
 // packages/text2sql/src/lib/agents/sql.agent.ts
@@ -3103,7 +3124,7 @@ async function withRetry(computation, options = { retries: 3 }) {
 
 // packages/text2sql/src/lib/agents/suggestions.agents.ts
 import { groq as groq4 } from "@ai-sdk/groq";
-import dedent2 from "dedent";
+import dedent3 from "dedent";
 import z4 from "zod";
 import { agent as agent2, thirdPersonPrompt } from "@deepagents/agent";
 var suggestionsAgent = agent2({
@@ -3119,7 +3140,7 @@ var suggestionsAgent = agent2({
     ).min(1).max(5).describe("A set of up to two advanced question + SQL pairs.")
   }),
   prompt: (state) => {
-    return dedent2`
+    return dedent3`
       ${thirdPersonPrompt()}
 
       <identity>
@@ -3154,12 +3175,12 @@ var suggestionsAgent = agent2({
 });
 
 // packages/text2sql/src/lib/agents/text2sql.agent.ts
-import { tool as tool3 } from "ai";
+import { tool as tool2 } from "ai";
 import z5 from "zod";
 import { toState as toState2 } from "@deepagents/agent";
 import { scratchpad_tool } from "@deepagents/toolbox";
 var tools2 = {
-  validate_query: tool3({
+  validate_query: tool2({
     description: `Validate SQL query syntax before execution. Use this to check if your SQL is valid before running db_query. This helps catch errors early and allows you to correct the query if needed.`,
     inputSchema: z5.object({
       sql: z5.string().describe("The SQL query to validate.")
@@ -3173,7 +3194,7 @@ var tools2 = {
       return "Query is valid.";
     }
   }),
-  db_query: tool3({
+  db_query: tool2({
     description: `Internal tool to fetch data from the store's database. Write a SQL query to retrieve the information needed to answer the user's question. The results will be returned as data that you can then present to the user in natural language.`,
     inputSchema: z5.object({
       reasoning: z5.string().describe(
@@ -3202,9 +3223,9 @@ var Checkpoint = class _Checkpoint {
   points;
   path;
   configHash;
-  constructor(path3, configHash, points) {
+  constructor(path4, configHash, points) {
     this.points = points;
-    this.path = path3;
+    this.path = path4;
     this.configHash = configHash;
   }
   /**
@@ -3212,14 +3233,14 @@ var Checkpoint = class _Checkpoint {
    * Handles corrupted files and config changes gracefully.
    */
   static async load(options) {
-    const { path: path3, configHash } = options;
-    if (existsSync(path3)) {
+    const { path: path4, configHash } = options;
+    if (existsSync(path4)) {
       try {
-        const content = readFileSync(path3, "utf-8");
+        const content = readFileSync(path4, "utf-8");
         const file = JSON.parse(content);
         if (configHash && file.configHash && file.configHash !== configHash) {
           console.log("\u26A0 Config changed, starting fresh");
-          return new _Checkpoint(path3, configHash, {});
+          return new _Checkpoint(path4, configHash, {});
         }
         const points = file.points ?? {};
         const totalEntries = Object.values(points).reduce(
@@ -3227,14 +3248,14 @@ var Checkpoint = class _Checkpoint {
           0
         );
         console.log(`\u2713 Resuming from checkpoint (${totalEntries} entries)`);
-        return new _Checkpoint(path3, configHash, points);
+        return new _Checkpoint(path4, configHash, points);
       } catch {
         console.log("\u26A0 Checkpoint corrupted, starting fresh");
-        return new _Checkpoint(path3, configHash, {});
+        return new _Checkpoint(path4, configHash, {});
       }
     }
     console.log("Starting new checkpoint");
-    return new _Checkpoint(path3, configHash, {});
+    return new _Checkpoint(path4, configHash, {});
   }
   /**
    * Run a single computation with checkpointing.
@@ -3401,6 +3422,815 @@ var JsonCache = class extends FileCache {
   }
 };
 
+// packages/text2sql/src/lib/fs/sqlite-fs.ts
+import * as path3 from "node:path";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+
+// packages/text2sql/src/lib/fs/ddl.sqlite-fs.sql
+var ddl_sqlite_fs_default = "-- SQLite-based filesystem schema for artifact storage\n-- Tables: fs_entries (file/directory metadata), fs_chunks (file content)\n\n-- Performance PRAGMAs (session-level, run on each connection)\nPRAGMA journal_mode = WAL;\nPRAGMA synchronous = NORMAL;\nPRAGMA cache_size = -64000;\nPRAGMA temp_store = MEMORY;\nPRAGMA mmap_size = 268435456;\n\n-- Integrity\nPRAGMA foreign_keys = ON;\n\n-- Filesystem entries table (files, directories, symlinks)\nCREATE TABLE IF NOT EXISTS fs_entries (\n  path TEXT PRIMARY KEY,            -- Normalized absolute path (e.g., '/results/uuid.json')\n  type TEXT NOT NULL,               -- 'file' | 'directory' | 'symlink'\n  mode INTEGER NOT NULL,            -- Unix permissions (e.g., 0o644 = 420)\n  size INTEGER NOT NULL,            -- File size in bytes (0 for directories)\n  mtime INTEGER NOT NULL,           -- Modified time (milliseconds since epoch)\n  symlinkTarget TEXT                -- Target path for symlinks (NULL for files/dirs)\n);\n\nCREATE INDEX IF NOT EXISTS idx_fs_entries_type ON fs_entries(type);\n\n-- File content chunks table (for handling large files)\n-- Files are split into 1MB chunks to avoid SQLite BLOB performance issues\nCREATE TABLE IF NOT EXISTS fs_chunks (\n  path TEXT NOT NULL,               -- Reference to fs_entries.path\n  chunkIndex INTEGER NOT NULL,      -- 0-based chunk sequence\n  data BLOB NOT NULL,               -- Chunk content (up to 1MB default)\n  PRIMARY KEY (path, chunkIndex),\n  FOREIGN KEY (path) REFERENCES fs_entries(path) ON DELETE CASCADE ON UPDATE CASCADE\n);\n";
+
+// packages/text2sql/src/lib/fs/sqlite-fs.ts
+var SqliteFs = class {
+  #db;
+  #statements = /* @__PURE__ */ new Map();
+  #chunkSize;
+  #root;
+  constructor(options) {
+    this.#chunkSize = options.chunkSize ?? 1024 * 1024;
+    const normalizedRoot = this.#normalizeRoot(options.root);
+    this.#root = normalizedRoot === "/" ? "" : normalizedRoot;
+    this.#db = new DatabaseSync2(options.dbPath);
+    this.#db.exec(ddl_sqlite_fs_default);
+    const rootSlashExists = this.#stmt(
+      "SELECT 1 FROM fs_entries WHERE path = ?"
+    ).get("/");
+    if (!rootSlashExists) {
+      this.#stmt(
+        `INSERT INTO fs_entries (path, type, mode, size, mtime)
+         VALUES ('/', 'directory', 493, 0, ?)`
+      ).run(Date.now());
+    }
+    if (this.#root) {
+      this.#createParentDirs(this.#root);
+      const rootExists = this.#stmt(
+        "SELECT 1 FROM fs_entries WHERE path = ?"
+      ).get(this.#root);
+      if (!rootExists) {
+        this.#stmt(
+          `INSERT INTO fs_entries (path, type, mode, size, mtime)
+           VALUES (?, 'directory', 493, 0, ?)`
+        ).run(this.#root, Date.now());
+      }
+    }
+  }
+  /**
+   * Create parent directories for a path (used during initialization).
+   * Creates all segments EXCEPT the last one (the path itself).
+   */
+  #createParentDirs(p) {
+    const segments = p.split("/").filter(Boolean);
+    let currentPath = "/";
+    for (let i = 0; i < segments.length - 1; i++) {
+      currentPath = path3.posix.join(currentPath, segments[i]);
+      const exists = this.#stmt("SELECT 1 FROM fs_entries WHERE path = ?").get(
+        currentPath
+      );
+      if (!exists) {
+        this.#stmt(
+          `INSERT INTO fs_entries (path, type, mode, size, mtime)
+           VALUES (?, 'directory', 493, 0, ?)`
+        ).run(currentPath, Date.now());
+      }
+    }
+  }
+  #stmt(sql) {
+    let stmt = this.#statements.get(sql);
+    if (!stmt) {
+      stmt = this.#db.prepare(sql);
+      this.#statements.set(sql, stmt);
+    }
+    return stmt;
+  }
+  #normalizeRoot(root) {
+    return path3.posix.resolve("/", root.trim());
+  }
+  #prefixPath(p) {
+    if (!this.#root) {
+      return p;
+    }
+    if (p === "/") {
+      return this.#root;
+    }
+    return path3.posix.join(this.#root, p);
+  }
+  #useTransaction(fn) {
+    this.#db.exec("BEGIN TRANSACTION");
+    try {
+      const result = fn();
+      this.#db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.#db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  #normalizePath(p) {
+    return path3.posix.resolve("/", p);
+  }
+  #dirname(p) {
+    const dir = path3.posix.dirname(p);
+    return dir === "" ? "/" : dir;
+  }
+  #ensureParentExists(filePath) {
+    const parent = this.#dirname(filePath);
+    const rootPath = this.#root || "/";
+    if (parent === rootPath || parent === "/") return;
+    const entry = this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
+      parent
+    );
+    if (!entry) {
+      this.#ensureParentExists(parent);
+      this.#stmt(
+        `INSERT INTO fs_entries (path, type, mode, size, mtime)
+         VALUES (?, 'directory', 493, 0, ?)`
+      ).run(parent, Date.now());
+    } else if (entry.type !== "directory") {
+      throw new Error(`mkdir: parent is not a directory: ${parent}`);
+    }
+  }
+  #writeChunks(filePath, content) {
+    this.#stmt("DELETE FROM fs_chunks WHERE path = ?").run(filePath);
+    for (let i = 0; i < content.length; i += this.#chunkSize) {
+      const chunk = content.slice(
+        i,
+        Math.min(i + this.#chunkSize, content.length)
+      );
+      this.#stmt(
+        "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
+      ).run(filePath, Math.floor(i / this.#chunkSize), chunk);
+    }
+  }
+  #readChunks(filePath) {
+    const rows = this.#stmt(
+      "SELECT data FROM fs_chunks WHERE path = ? ORDER BY chunkIndex"
+    ).all(filePath);
+    if (rows.length === 0) {
+      return new Uint8Array(0);
+    }
+    const totalSize = rows.reduce((sum, row) => sum + row.data.length, 0);
+    const result = new Uint8Array(totalSize);
+    let offset = 0;
+    for (const row of rows) {
+      result.set(row.data, offset);
+      offset += row.data.length;
+    }
+    return result;
+  }
+  #resolveSymlink(p, seen = /* @__PURE__ */ new Set()) {
+    if (seen.has(p)) {
+      throw new Error(`readFile: circular symlink: ${p}`);
+    }
+    const entry = this.#stmt(
+      "SELECT type, symlinkTarget FROM fs_entries WHERE path = ?"
+    ).get(p);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${p}`);
+    }
+    if (entry.type !== "symlink") {
+      return p;
+    }
+    seen.add(p);
+    const target = this.#normalizePath(
+      path3.posix.resolve(this.#dirname(p), entry.symlinkTarget)
+    );
+    return this.#resolveSymlink(target, seen);
+  }
+  #toUint8Array(content, encoding) {
+    if (content instanceof Uint8Array) {
+      return content;
+    }
+    const enc = encoding ?? "utf8";
+    return new Uint8Array(Buffer.from(content, enc));
+  }
+  // ============================================================================
+  // IFileSystem Implementation
+  // ============================================================================
+  async readFile(filePath, options) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const resolved = this.#resolveSymlink(prefixed);
+    const entry = this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
+      resolved
+    );
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${filePath}`);
+    }
+    if (entry.type === "directory") {
+      throw new Error(`EISDIR: illegal operation on a directory: ${filePath}`);
+    }
+    const content = this.#readChunks(resolved);
+    const encoding = typeof options === "string" ? options : options?.encoding ?? "utf8";
+    return Buffer.from(content).toString(encoding);
+  }
+  async readFileBuffer(filePath) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const resolved = this.#resolveSymlink(prefixed);
+    const entry = this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
+      resolved
+    );
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${filePath}`);
+    }
+    if (entry.type === "directory") {
+      throw new Error(`EISDIR: illegal operation on a directory: ${filePath}`);
+    }
+    return this.#readChunks(resolved);
+  }
+  async writeFile(filePath, content, options) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const encoding = typeof options === "string" ? options : options?.encoding;
+    const data = this.#toUint8Array(content, encoding);
+    this.#useTransaction(() => {
+      this.#ensureParentExists(prefixed);
+      this.#stmt(
+        `INSERT INTO fs_entries (path, type, mode, size, mtime)
+         VALUES (?, 'file', 420, ?, ?)
+         ON CONFLICT(path) DO UPDATE SET
+           type = 'file',
+           size = excluded.size,
+           mtime = excluded.mtime`
+      ).run(prefixed, data.length, Date.now());
+      this.#writeChunks(prefixed, data);
+    });
+  }
+  async appendFile(filePath, content, options) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const encoding = typeof options === "string" ? options : options?.encoding;
+    const newData = this.#toUint8Array(content, encoding);
+    this.#useTransaction(() => {
+      this.#ensureParentExists(prefixed);
+      const entry = this.#stmt(
+        "SELECT type FROM fs_entries WHERE path = ?"
+      ).get(prefixed);
+      if (entry && entry.type !== "file") {
+        throw new Error(`appendFile: not a file: ${filePath}`);
+      }
+      const existing = entry ? this.#readChunks(prefixed) : new Uint8Array(0);
+      const combined = new Uint8Array(existing.length + newData.length);
+      combined.set(existing, 0);
+      combined.set(newData, existing.length);
+      this.#stmt(
+        `INSERT INTO fs_entries (path, type, mode, size, mtime)
+         VALUES (?, 'file', 420, ?, ?)
+         ON CONFLICT(path) DO UPDATE SET
+           size = excluded.size,
+           mtime = excluded.mtime`
+      ).run(prefixed, combined.length, Date.now());
+      this.#writeChunks(prefixed, combined);
+    });
+  }
+  async exists(filePath) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const row = this.#stmt("SELECT 1 FROM fs_entries WHERE path = ?").get(
+      prefixed
+    );
+    return row !== void 0;
+  }
+  async stat(filePath) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const resolved = this.#resolveSymlink(prefixed);
+    const entry = this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(
+      resolved
+    );
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${filePath}`);
+    }
+    return {
+      isFile: entry.type === "file",
+      isDirectory: entry.type === "directory",
+      isSymbolicLink: false,
+      // stat follows symlinks
+      mode: entry.mode,
+      size: entry.size,
+      mtime: new Date(entry.mtime)
+    };
+  }
+  async lstat(filePath) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const entry = this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(
+      prefixed
+    );
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${filePath}`);
+    }
+    return {
+      isFile: entry.type === "file",
+      isDirectory: entry.type === "directory",
+      isSymbolicLink: entry.type === "symlink",
+      mode: entry.mode,
+      size: entry.size,
+      mtime: new Date(entry.mtime)
+    };
+  }
+  async mkdir(dirPath, options) {
+    const normalized = this.#normalizePath(dirPath);
+    const prefixed = this.#prefixPath(normalized);
+    const existing = this.#stmt(
+      "SELECT type FROM fs_entries WHERE path = ?"
+    ).get(prefixed);
+    if (existing) {
+      if (options?.recursive) {
+        return;
+      }
+      throw new Error(`EEXIST: file already exists: ${dirPath}`);
+    }
+    this.#useTransaction(() => {
+      if (options?.recursive) {
+        const rootPath = this.#root || "/";
+        const relativePath = path3.posix.relative(rootPath, prefixed);
+        const segments = relativePath.split("/").filter(Boolean);
+        let currentPath = rootPath;
+        for (const segment of segments) {
+          currentPath = path3.posix.join(currentPath, segment);
+          const exists = this.#stmt(
+            "SELECT type FROM fs_entries WHERE path = ?"
+          ).get(currentPath);
+          if (!exists) {
+            this.#stmt(
+              `INSERT INTO fs_entries (path, type, mode, size, mtime)
+               VALUES (?, 'directory', 493, 0, ?)`
+            ).run(currentPath, Date.now());
+          } else if (exists.type !== "directory") {
+            throw new Error(`mkdir: not a directory: ${currentPath}`);
+          }
+        }
+      } else {
+        const parent = this.#dirname(prefixed);
+        const parentEntry = this.#stmt(
+          "SELECT type FROM fs_entries WHERE path = ?"
+        ).get(parent);
+        if (!parentEntry) {
+          throw new Error(`mkdir: parent does not exist: ${parent}`);
+        }
+        if (parentEntry.type !== "directory") {
+          throw new Error(`mkdir: parent is not a directory: ${parent}`);
+        }
+        this.#stmt(
+          `INSERT INTO fs_entries (path, type, mode, size, mtime)
+           VALUES (?, 'directory', 493, 0, ?)`
+        ).run(prefixed, Date.now());
+      }
+    });
+  }
+  async readdir(dirPath) {
+    const normalized = this.#normalizePath(dirPath);
+    const prefixed = this.#prefixPath(normalized);
+    const resolved = this.#resolveSymlink(prefixed);
+    const entry = this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
+      resolved
+    );
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${dirPath}`);
+    }
+    if (entry.type !== "directory") {
+      throw new Error(`ENOTDIR: not a directory: ${dirPath}`);
+    }
+    const prefix = resolved === "/" ? "/" : resolved + "/";
+    const rows = this.#stmt(
+      `SELECT path FROM fs_entries
+       WHERE path LIKE ? || '%'
+         AND path != ?
+         AND path NOT LIKE ? || '%/%'`
+    ).all(prefix, resolved, prefix);
+    return rows.map((row) => path3.posix.basename(row.path));
+  }
+  async readdirWithFileTypes(dirPath) {
+    const normalized = this.#normalizePath(dirPath);
+    const prefixed = this.#prefixPath(normalized);
+    const resolved = this.#resolveSymlink(prefixed);
+    const entry = this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
+      resolved
+    );
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${dirPath}`);
+    }
+    if (entry.type !== "directory") {
+      throw new Error(`ENOTDIR: not a directory: ${dirPath}`);
+    }
+    const prefix = resolved === "/" ? "/" : resolved + "/";
+    const rows = this.#stmt(
+      `SELECT path, type FROM fs_entries
+       WHERE path LIKE ? || '%'
+         AND path != ?
+         AND path NOT LIKE ? || '%/%'`
+    ).all(prefix, resolved, prefix);
+    return rows.map((row) => ({
+      name: path3.posix.basename(row.path),
+      isFile: row.type === "file",
+      isDirectory: row.type === "directory",
+      isSymbolicLink: row.type === "symlink"
+    }));
+  }
+  async rm(filePath, options) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const entry = this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
+      prefixed
+    );
+    if (!entry) {
+      if (options?.force) {
+        return;
+      }
+      throw new Error(`ENOENT: no such file or directory: ${filePath}`);
+    }
+    this.#useTransaction(() => {
+      if (entry.type === "directory") {
+        const children = this.#stmt(
+          `SELECT 1 FROM fs_entries WHERE path LIKE ? || '/%' LIMIT 1`
+        ).get(prefixed);
+        if (children && !options?.recursive) {
+          throw new Error(`ENOTEMPTY: directory not empty: ${filePath}`);
+        }
+        this.#stmt(
+          `DELETE FROM fs_entries WHERE path = ? OR path LIKE ? || '/%'`
+        ).run(prefixed, prefixed);
+      } else {
+        this.#stmt("DELETE FROM fs_entries WHERE path = ?").run(prefixed);
+      }
+    });
+  }
+  async cp(src, dest, options) {
+    const srcNormalized = this.#normalizePath(src);
+    const destNormalized = this.#normalizePath(dest);
+    const srcPrefixed = this.#prefixPath(srcNormalized);
+    const destPrefixed = this.#prefixPath(destNormalized);
+    const srcEntry = this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(
+      srcPrefixed
+    );
+    if (!srcEntry) {
+      throw new Error(`ENOENT: no such file or directory: ${src}`);
+    }
+    if (srcEntry.type === "directory" && !options?.recursive) {
+      throw new Error(`cp: -r not specified; omitting directory: ${src}`);
+    }
+    this.#useTransaction(() => {
+      this.#ensureParentExists(destPrefixed);
+      if (srcEntry.type === "directory") {
+        const allEntries = this.#stmt(
+          `SELECT * FROM fs_entries WHERE path = ? OR path LIKE ? || '/%'`
+        ).all(srcPrefixed, srcPrefixed);
+        for (const entry of allEntries) {
+          const relativePath = path3.posix.relative(srcPrefixed, entry.path);
+          const newPath = path3.posix.join(destPrefixed, relativePath);
+          this.#stmt(
+            `INSERT OR REPLACE INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
+             VALUES (?, ?, ?, ?, ?, ?)`
+          ).run(
+            newPath,
+            entry.type,
+            entry.mode,
+            entry.size,
+            Date.now(),
+            entry.symlinkTarget
+          );
+          if (entry.type === "file") {
+            const chunks = this.#stmt(
+              "SELECT chunkIndex, data FROM fs_chunks WHERE path = ?"
+            ).all(entry.path);
+            for (const chunk of chunks) {
+              this.#stmt(
+                "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
+              ).run(newPath, chunk.chunkIndex, chunk.data);
+            }
+          }
+        }
+      } else {
+        this.#stmt(
+          `INSERT OR REPLACE INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
+           VALUES (?, ?, ?, ?, ?, ?)`
+        ).run(
+          destPrefixed,
+          srcEntry.type,
+          srcEntry.mode,
+          srcEntry.size,
+          Date.now(),
+          srcEntry.symlinkTarget
+        );
+        if (srcEntry.type === "file") {
+          const chunks = this.#stmt(
+            "SELECT chunkIndex, data FROM fs_chunks WHERE path = ?"
+          ).all(srcPrefixed);
+          this.#stmt("DELETE FROM fs_chunks WHERE path = ?").run(destPrefixed);
+          for (const chunk of chunks) {
+            this.#stmt(
+              "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
+            ).run(destPrefixed, chunk.chunkIndex, chunk.data);
+          }
+        }
+      }
+    });
+  }
+  async mv(src, dest) {
+    const srcNormalized = this.#normalizePath(src);
+    const destNormalized = this.#normalizePath(dest);
+    const srcPrefixed = this.#prefixPath(srcNormalized);
+    const destPrefixed = this.#prefixPath(destNormalized);
+    const srcEntry = this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(
+      srcPrefixed
+    );
+    if (!srcEntry) {
+      throw new Error(`ENOENT: no such file or directory: ${src}`);
+    }
+    this.#useTransaction(() => {
+      this.#ensureParentExists(destPrefixed);
+      if (srcEntry.type === "directory") {
+        const allEntries = this.#stmt(
+          `SELECT * FROM fs_entries WHERE path = ? OR path LIKE ? || '/%' ORDER BY path DESC`
+        ).all(srcPrefixed, srcPrefixed);
+        for (const entry of [...allEntries].reverse()) {
+          const relativePath = path3.posix.relative(srcPrefixed, entry.path);
+          const newPath = path3.posix.join(destPrefixed, relativePath);
+          this.#stmt(
+            `INSERT INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
+             VALUES (?, ?, ?, ?, ?, ?)`
+          ).run(
+            newPath,
+            entry.type,
+            entry.mode,
+            entry.size,
+            Date.now(),
+            entry.symlinkTarget
+          );
+          if (entry.type === "file") {
+            const chunks = this.#stmt(
+              "SELECT chunkIndex, data FROM fs_chunks WHERE path = ?"
+            ).all(entry.path);
+            for (const chunk of chunks) {
+              this.#stmt(
+                "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
+              ).run(newPath, chunk.chunkIndex, chunk.data);
+            }
+          }
+        }
+        this.#stmt(
+          `DELETE FROM fs_entries WHERE path = ? OR path LIKE ? || '/%'`
+        ).run(srcPrefixed, srcPrefixed);
+      } else {
+        this.#stmt(
+          `INSERT INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
+           VALUES (?, ?, ?, ?, ?, ?)`
+        ).run(
+          destPrefixed,
+          srcEntry.type,
+          srcEntry.mode,
+          srcEntry.size,
+          Date.now(),
+          srcEntry.symlinkTarget
+        );
+        if (srcEntry.type === "file") {
+          const chunks = this.#stmt(
+            "SELECT chunkIndex, data FROM fs_chunks WHERE path = ?"
+          ).all(srcPrefixed);
+          for (const chunk of chunks) {
+            this.#stmt(
+              "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
+            ).run(destPrefixed, chunk.chunkIndex, chunk.data);
+          }
+        }
+        this.#stmt("DELETE FROM fs_entries WHERE path = ?").run(srcPrefixed);
+      }
+    });
+  }
+  resolvePath(base, relativePath) {
+    return path3.posix.resolve(base, relativePath);
+  }
+  getAllPaths() {
+    const rows = this.#stmt(
+      "SELECT path FROM fs_entries ORDER BY path"
+    ).all();
+    return rows.map((row) => row.path);
+  }
+  async chmod(filePath, mode) {
+    const normalized = this.#normalizePath(filePath);
+    const prefixed = this.#prefixPath(normalized);
+    const result = this.#stmt(
+      "UPDATE fs_entries SET mode = ? WHERE path = ?"
+    ).run(mode, prefixed);
+    if (result.changes === 0) {
+      throw new Error(`ENOENT: no such file or directory: ${filePath}`);
+    }
+  }
+  async symlink(target, linkPath) {
+    const normalized = this.#normalizePath(linkPath);
+    const prefixed = this.#prefixPath(normalized);
+    const existing = this.#stmt("SELECT 1 FROM fs_entries WHERE path = ?").get(
+      prefixed
+    );
+    if (existing) {
+      throw new Error(`EEXIST: file already exists: ${linkPath}`);
+    }
+    this.#useTransaction(() => {
+      this.#ensureParentExists(prefixed);
+      this.#stmt(
+        `INSERT INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
+         VALUES (?, 'symlink', 511, 0, ?, ?)`
+      ).run(prefixed, Date.now(), target);
+    });
+  }
+  async link(existingPath, newPath) {
+    const srcNormalized = this.#normalizePath(existingPath);
+    const destNormalized = this.#normalizePath(newPath);
+    const srcPrefixed = this.#prefixPath(srcNormalized);
+    const destPrefixed = this.#prefixPath(destNormalized);
+    const srcEntry = this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(
+      srcPrefixed
+    );
+    if (!srcEntry) {
+      throw new Error(`ENOENT: no such file or directory: ${existingPath}`);
+    }
+    if (srcEntry.type !== "file") {
+      throw new Error(`link: not supported for directories: ${existingPath}`);
+    }
+    const existing = this.#stmt("SELECT 1 FROM fs_entries WHERE path = ?").get(
+      destPrefixed
+    );
+    if (existing) {
+      throw new Error(`EEXIST: file already exists: ${newPath}`);
+    }
+    this.#useTransaction(() => {
+      this.#ensureParentExists(destPrefixed);
+      this.#stmt(
+        `INSERT INTO fs_entries (path, type, mode, size, mtime)
+         VALUES (?, 'file', ?, ?, ?)`
+      ).run(destPrefixed, srcEntry.mode, srcEntry.size, Date.now());
+      const chunks = this.#stmt(
+        "SELECT chunkIndex, data FROM fs_chunks WHERE path = ?"
+      ).all(srcPrefixed);
+      for (const chunk of chunks) {
+        this.#stmt(
+          "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
+        ).run(destPrefixed, chunk.chunkIndex, chunk.data);
+      }
+    });
+  }
+  async readlink(linkPath) {
+    const normalized = this.#normalizePath(linkPath);
+    const prefixed = this.#prefixPath(normalized);
+    const entry = this.#stmt(
+      "SELECT type, symlinkTarget FROM fs_entries WHERE path = ?"
+    ).get(prefixed);
+    if (!entry) {
+      throw new Error(`ENOENT: no such file or directory: ${linkPath}`);
+    }
+    if (entry.type !== "symlink") {
+      throw new Error(`readlink: not a symbolic link: ${linkPath}`);
+    }
+    return entry.symlinkTarget;
+  }
+};
+
+// packages/text2sql/src/lib/fs/scoped-fs.ts
+var ScopedFs = class {
+  #base;
+  #prefix;
+  constructor(options) {
+    this.#base = options.base;
+    this.#prefix = options.prefix.replace(/\/$/, "");
+  }
+  #scope(path4) {
+    return `${this.#prefix}${path4}`;
+  }
+  async writeFile(path4, content, options) {
+    await this.#base.writeFile(this.#scope(path4), content, options);
+  }
+  async appendFile(path4, content, options) {
+    await this.#base.appendFile(this.#scope(path4), content, options);
+  }
+  async mkdir(path4, options) {
+    return this.#base.mkdir(this.#scope(path4), options);
+  }
+  async rm(path4, options) {
+    await this.#base.rm(this.#scope(path4), options);
+  }
+  async cp(src, dest, options) {
+    await this.#base.cp(this.#scope(src), this.#scope(dest), options);
+  }
+  async mv(src, dest) {
+    await this.#base.mv(this.#scope(src), this.#scope(dest));
+  }
+  async chmod(path4, mode) {
+    return this.#base.chmod(this.#scope(path4), mode);
+  }
+  async symlink(target, linkPath) {
+    await this.#base.symlink(target, this.#scope(linkPath));
+  }
+  async link(existingPath, newPath) {
+    await this.#base.link(this.#scope(existingPath), this.#scope(newPath));
+  }
+  readFile(path4, options) {
+    return this.#base.readFile(this.#scope(path4), options);
+  }
+  readFileBuffer(path4) {
+    return this.#base.readFileBuffer(this.#scope(path4));
+  }
+  stat(path4) {
+    return this.#base.stat(this.#scope(path4));
+  }
+  lstat(path4) {
+    return this.#base.lstat(this.#scope(path4));
+  }
+  readdir(path4) {
+    return this.#base.readdir(this.#scope(path4));
+  }
+  readdirWithFileTypes(path4) {
+    return this.#base.readdirWithFileTypes(this.#scope(path4));
+  }
+  exists(path4) {
+    return this.#base.exists(this.#scope(path4));
+  }
+  readlink(path4) {
+    return this.#base.readlink(this.#scope(path4));
+  }
+  resolvePath(base, relativePath) {
+    return this.#base.resolvePath(base, relativePath);
+  }
+  getAllPaths() {
+    const allPaths = this.#base.getAllPaths?.() ?? [];
+    return allPaths.filter((p) => p.startsWith(this.#prefix)).map((p) => p.slice(this.#prefix.length) || "/");
+  }
+};
+
+// packages/text2sql/src/lib/fs/tracked-fs.ts
+var TrackedFs = class {
+  #base;
+  #createdFiles = /* @__PURE__ */ new Set();
+  constructor(base) {
+    this.#base = base;
+  }
+  getCreatedFiles() {
+    return [...this.#createdFiles];
+  }
+  async writeFile(path4, content, options) {
+    await this.#base.writeFile(path4, content, options);
+    this.#createdFiles.add(path4);
+  }
+  async appendFile(path4, content, options) {
+    await this.#base.appendFile(path4, content, options);
+    this.#createdFiles.add(path4);
+  }
+  async mkdir(path4, options) {
+    return this.#base.mkdir(path4, options);
+  }
+  async rm(path4, options) {
+    await this.#base.rm(path4, options);
+    this.#createdFiles.delete(path4);
+    if (options?.recursive) {
+      const prefix = path4.endsWith("/") ? path4 : path4 + "/";
+      for (const file of this.#createdFiles) {
+        if (file.startsWith(prefix)) {
+          this.#createdFiles.delete(file);
+        }
+      }
+    }
+  }
+  async cp(src, dest, options) {
+    await this.#base.cp(src, dest, options);
+    this.#createdFiles.add(dest);
+  }
+  async mv(src, dest) {
+    await this.#base.mv(src, dest);
+    this.#createdFiles.delete(src);
+    this.#createdFiles.add(dest);
+  }
+  async chmod(path4, mode) {
+    return this.#base.chmod(path4, mode);
+  }
+  async symlink(target, linkPath) {
+    await this.#base.symlink(target, linkPath);
+    this.#createdFiles.add(linkPath);
+  }
+  async link(existingPath, newPath) {
+    await this.#base.link(existingPath, newPath);
+    this.#createdFiles.add(newPath);
+  }
+  readFile(path4, options) {
+    return this.#base.readFile(path4, options);
+  }
+  readFileBuffer(path4) {
+    return this.#base.readFileBuffer(path4);
+  }
+  stat(path4) {
+    return this.#base.stat(path4);
+  }
+  lstat(path4) {
+    return this.#base.lstat(path4);
+  }
+  readdir(path4) {
+    return this.#base.readdir(path4);
+  }
+  readdirWithFileTypes(path4) {
+    return this.#base.readdirWithFileTypes(path4);
+  }
+  exists(path4) {
+    return this.#base.exists(path4);
+  }
+  readlink(path4) {
+    return this.#base.readlink(path4);
+  }
+  resolvePath(base, relativePath) {
+    return this.#base.resolvePath(base, relativePath);
+  }
+  getAllPaths() {
+    return this.#base.getAllPaths?.() ?? [];
+  }
+};
+
 // packages/text2sql/src/lib/instructions.ts
 function reasoningFramework() {
   return [
@@ -3779,6 +4609,7 @@ import {
   ToolCallRepairError,
   generateId as generateId3
 } from "ai";
+import "just-bash";
 import "@deepagents/agent";
 var Text2Sql = class {
   #config;
@@ -3790,6 +4621,7 @@ var Text2Sql = class {
       tools: config.tools ?? {},
       model: config.model,
       transform: config.transform,
+      filesystem: config.filesystem,
       introspection: new JsonCache(
         "introspection-" + config.version
       )
@@ -3862,6 +4694,7 @@ var Text2Sql = class {
     ];
   }
   async chat(messages) {
+    const trackedFs = new TrackedFs(this.#config.filesystem);
     const context = this.#config.context(
       ...guidelines(this.#config.teachingsOptions),
       ...await this.index(),
@@ -3872,20 +4705,18 @@ var Text2Sql = class {
       context.set(message(userMsg));
       await context.save();
     }
-    const messageId = userMsg?.id ?? generateId3();
-    const skillMounts = context.getSkillMounts();
-    const { bash } = await createResultTools({
+    const { mounts: skillMounts } = context.getSkillMounts();
+    const { tools: tools3 } = await createResultTools({
       adapter: this.#config.adapter,
-      chatId: context.chatId,
-      messageId,
-      skillMounts
+      skillMounts,
+      filesystem: trackedFs
     });
     const chatAgent = agent({
       name: "text2sql",
       model: this.#config.model,
       context,
       tools: {
-        bash,
+        ...tools3,
         ...this.#config.tools
       },
       guardrails: [errorRecoveryGuardrail],
@@ -3904,7 +4735,15 @@ var Text2Sql = class {
       originalMessages: messages,
       generateMessageId: generateId3,
       onFinish: async ({ responseMessage }) => {
-        context.set(assistant(responseMessage));
+        const createdFiles = trackedFs.getCreatedFiles();
+        const messageWithMetadata = {
+          ...responseMessage,
+          metadata: {
+            ...responseMessage.metadata ?? {},
+            createdFiles
+          }
+        };
+        context.set(assistant(messageWithMetadata));
         await context.save();
         await context.trackUsage(await result.totalUsage);
       }
@@ -3966,7 +4805,10 @@ export {
   JsonCache,
   Point,
   SQLValidationError,
+  ScopedFs,
+  SqliteFs,
   Text2Sql,
+  TrackedFs,
   UnanswerableSQLError,
   applyTablesFilter,
   column,