noumen 0.4.0 → 0.6.0

package/dist/{chunk-4HW6LN6D.js → chunk-6MMYCGJQ.js}

@@ -1,6 +1,13 @@
 import {
   applySnipRemovals
 } from "./chunk-42PHHZUA.js";
+import {
+  ToolRegistry,
+  createToolSearchTool,
+  isPathInWorkingDirectories,
+  resolvePermission,
+  resolveToolFlag
+} from "./chunk-XZN4QZLK.js";
 import {
   getAutoCompactThreshold,
   getEffectiveContextWindow,
@@ -8,17 +15,10 @@ import {
 } from "./chunk-HEQQQGK5.js";
 import {
   ChatStreamError
-} from "./chunk-L3L3FG5T.js";
+} from "./chunk-CCM2AXZG.js";
 import {
   generateUUID
 } from "./chunk-3HEYCV26.js";
-import {
-  ToolRegistry,
-  createToolSearchTool,
-  isPathInWorkingDirectories,
-  resolvePermission,
-  resolveToolFlag
-} from "./chunk-HL6JCRZJ.js";
 import {
   contentToString,
   hasImageContent,
@@ -178,7 +178,7 @@ var LocalComputer = class {
     this.defaultTimeout = opts?.defaultTimeout ?? 3e4;
   }
   executeCommand(command, opts) {
-    return new Promise((resolve7) => {
+    return new Promise((resolve3) => {
       const child = execCb(
         command,
         {
@@ -189,7 +189,7 @@ var LocalComputer = class {
           shell: process.env.SHELL || "/bin/sh"
         },
         (error, stdout, stderr) => {
-          resolve7({
+          resolve3({
             exitCode: error && "code" in error ? typeof error.code === "number" ? error.code : 1 : child.exitCode ?? 0,
             stdout: stdout ?? "",
             stderr: stderr ?? ""
@@ -250,7 +250,7 @@ var SandboxedLocalComputer = class {
   async executeCommand(command, opts) {
     await this.ensureInitialized();
     const wrappedCommand = await SandboxManager.wrapWithSandbox(command);
-    return new Promise((resolve7) => {
+    return new Promise((resolve3) => {
       const child = execCb2(
         wrappedCommand,
         {
@@ -266,7 +266,7 @@ var SandboxedLocalComputer = class {
             stdout: stdout ?? "",
             stderr: stderr ?? ""
           };
-          Promise.resolve(SandboxManager.cleanupAfterCommand()).then(() => resolve7(result)).catch(() => resolve7(result));
+          Promise.resolve(SandboxManager.cleanupAfterCommand()).then(() => resolve3(result)).catch(() => resolve3(result));
         }
       );
     });
@@ -283,813 +283,7 @@ var SandboxedLocalComputer = class {
   }
 };
 
-// src/virtual/sprites-fs.ts
-import * as path2 from "path";
-var SpritesFs = class {
-  token;
-  spriteName;
-  baseURL;
-  workingDir;
-  constructor(opts) {
-    this.token = opts.token;
-    this.spriteName = opts.spriteName;
-    this.baseURL = (opts.baseURL ?? "https://api.sprites.dev").replace(
-      /\/$/,
-      ""
-    );
-    this.workingDir = opts.workingDir ?? "/home/sprite";
-  }
-  fsUrl(endpoint, params) {
-    const url = new URL(
-      `${this.baseURL}/v1/sprites/${this.spriteName}/fs${endpoint}`
-    );
-    if (params) {
-      for (const [k, v] of Object.entries(params)) {
-        url.searchParams.set(k, v);
-      }
-    }
-    return url.toString();
-  }
-  resolvePath(p) {
-    const normalizedBase = this.workingDir.endsWith("/") ? this.workingDir : this.workingDir + "/";
-    if (p.startsWith("/")) {
-      if (p !== this.workingDir && !p.startsWith(normalizedBase)) {
-        throw new Error(`Absolute path "${p}" is outside working directory "${this.workingDir}"`);
-      }
-      return p;
-    }
-    const resolved = path2.resolve(this.workingDir, p);
-    if (resolved !== this.workingDir && !resolved.startsWith(normalizedBase)) {
-      throw new Error(`Path "${p}" escapes working directory "${this.workingDir}"`);
-    }
-    return resolved;
-  }
-  headers() {
-    return {
-      Authorization: `Bearer ${this.token}`
-    };
-  }
-  async readFile(filePath, _opts) {
-    const url = this.fsUrl("/read", { path: this.resolvePath(filePath) });
-    const res = await fetch(url, { headers: this.headers() });
-    if (!res.ok) {
-      throw new Error(
-        `SpritesFs readFile failed (${res.status}): ${await res.text()}`
-      );
-    }
-    return res.text();
-  }
-  async readFileBytes(filePath, maxBytes) {
-    const url = this.fsUrl("/read", {
-      path: this.resolvePath(filePath),
-      binary: "true"
-    });
-    const res = await fetch(url, { headers: this.headers() });
-    if (!res.ok) {
-      throw new Error(
-        `SpritesFs readFileBytes failed (${res.status}): ${await res.text()}`
-      );
-    }
-    const arrayBuf = await res.arrayBuffer();
-    const buf = Buffer.from(arrayBuf);
-    if (maxBytes !== void 0 && buf.length > maxBytes) {
-      return buf.subarray(0, maxBytes);
-    }
-    return buf;
-  }
-  async writeFile(filePath, content) {
-    const url = this.fsUrl("/write");
-    const res = await fetch(url, {
-      method: "POST",
-      headers: {
-        ...this.headers(),
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        path: this.resolvePath(filePath),
-        content
-      })
-    });
-    if (!res.ok) {
-      throw new Error(
-        `SpritesFs writeFile failed (${res.status}): ${await res.text()}`
-      );
-    }
-  }
-  /**
-   * @warning Not atomic. Concurrent appends may lose data due to
-   * read-then-write TOCTOU. The Sprites API does not expose an append primitive.
-   */
-  async appendFile(filePath, content) {
-    let existing = "";
-    try {
-      existing = await this.readFile(filePath);
-    } catch {
-    }
-    await this.writeFile(filePath, existing + content);
-  }
-  async deleteFile(filePath, opts) {
-    const url = this.fsUrl("/remove");
-    const res = await fetch(url, {
-      method: "POST",
-      headers: {
-        ...this.headers(),
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        path: this.resolvePath(filePath),
-        recursive: opts?.recursive ?? false
-      })
-    });
-    if (!res.ok) {
-      throw new Error(
-        `SpritesFs deleteFile failed (${res.status}): ${await res.text()}`
-      );
-    }
-  }
-  async mkdir(dirPath, opts) {
-    const url = this.fsUrl("/mkdir");
-    const res = await fetch(url, {
-      method: "POST",
-      headers: {
-        ...this.headers(),
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        path: this.resolvePath(dirPath),
-        recursive: opts?.recursive ?? false
-      })
-    });
-    if (!res.ok) {
-      throw new Error(
-        `SpritesFs mkdir failed (${res.status}): ${await res.text()}`
-      );
-    }
-  }
-  async readdir(dirPath, _opts) {
-    const url = this.fsUrl("/readdir", { path: this.resolvePath(dirPath) });
-    const res = await fetch(url, { headers: this.headers() });
-    if (!res.ok) {
-      throw new Error(
-        `SpritesFs readdir failed (${res.status}): ${await res.text()}`
-      );
-    }
-    const data = await res.json();
-    return data.map((entry) => ({
-      name: entry.name,
-      path: entry.path,
-      isDirectory: entry.is_dir,
-      isFile: !entry.is_dir,
-      size: entry.size
-    }));
-  }
-  async exists(filePath) {
-    try {
-      await this.stat(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async stat(filePath) {
-    const url = this.fsUrl("/stat", { path: this.resolvePath(filePath) });
-    const res = await fetch(url, { headers: this.headers() });
-    if (!res.ok) {
-      throw new Error(
-        `SpritesFs stat failed (${res.status}): ${await res.text()}`
-      );
-    }
-    const data = await res.json();
-    return {
-      size: data.size,
-      isDirectory: data.is_dir,
-      isFile: !data.is_dir,
-      createdAt: data.created_at ? new Date(data.created_at) : void 0,
-      modifiedAt: data.modified_at ? new Date(data.modified_at) : void 0
-    };
-  }
-};
-
-// src/virtual/sprites-computer.ts
-var SpritesComputer = class {
-  token;
-  spriteName;
-  baseURL;
-  workingDir;
-  constructor(opts) {
-    this.token = opts.token;
-    this.spriteName = opts.spriteName;
-    this.baseURL = (opts.baseURL ?? "https://api.sprites.dev").replace(
-      /\/$/,
-      ""
-    );
-    this.workingDir = opts.workingDir ?? "/home/sprite";
-  }
-  headers() {
-    return {
-      Authorization: `Bearer ${this.token}`,
-      "Content-Type": "application/json"
-    };
-  }
-  async executeCommand(command, opts) {
-    const cwd = opts?.cwd ?? this.workingDir;
-    const wrappedCommand = `cd ${this.shellEscape(cwd)} && ${command}`;
-    const url = `${this.baseURL}/v1/sprites/${this.spriteName}/exec`;
-    const res = await fetch(url, {
-      method: "POST",
-      headers: this.headers(),
-      body: JSON.stringify({
-        command: ["bash", "-c", wrappedCommand],
-        timeout: opts?.timeout ?? 3e4,
-        env: opts?.env
-      })
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      return {
-        exitCode: 1,
-        stdout: "",
-        stderr: `Sprites exec failed (${res.status}): ${text}`
-      };
-    }
-    const data = await res.json();
-    return {
-      exitCode: data.exit_code,
-      stdout: data.stdout ?? "",
-      stderr: data.stderr ?? ""
-    };
-  }
-  shellEscape(s) {
-    return `'${s.replace(/'/g, "'\\''")}'`;
-  }
-};
-
-// src/virtual/docker-fs.ts
-import * as path3 from "path";
-var DockerFs = class {
-  container;
-  workingDir;
-  constructor(opts) {
-    this.container = opts.container;
-    this.workingDir = opts.workingDir ?? "/";
-  }
-  resolvePath(p) {
-    if (p.includes("\0")) {
-      throw new Error("Path contains null bytes");
-    }
-    const normalizedBase = this.workingDir.endsWith("/") ? this.workingDir : this.workingDir + "/";
-    if (p.startsWith("/")) {
-      const normalized = path3.normalize(p);
-      if (normalized !== this.workingDir && !normalized.startsWith(normalizedBase)) {
-        throw new Error(`Absolute path "${p}" is outside working directory "${this.workingDir}"`);
-      }
-      return normalized;
-    }
-    const resolved = path3.resolve(this.workingDir, p);
-    if (resolved !== this.workingDir && !resolved.startsWith(normalizedBase)) {
-      throw new Error(`Path "${p}" escapes working directory "${this.workingDir}"`);
-    }
-    return resolved;
-  }
-  async exec(cmd) {
-    const execInstance = await this.container.exec({
-      Cmd: cmd,
-      AttachStdout: true,
-      AttachStderr: true,
-      Tty: false
-    });
-    const stream = await execInstance.start({ hijack: true, stdin: false });
-    const result = await collectExecStream(stream);
-    const inspection = await execInstance.inspect();
-    return { exitCode: inspection.ExitCode, ...result };
-  }
-  async readFile(path6, _opts) {
-    const resolved = this.resolvePath(path6);
-    const { exitCode, stdout, stderr } = await this.exec([
-      "cat",
-      resolved
-    ]);
-    if (exitCode !== 0) {
-      throw new Error(`DockerFs readFile failed: ${stderr.trim() || `exit code ${exitCode}`}`);
-    }
-    return stdout;
-  }
-  async readFileBytes(path6, maxBytes) {
-    const resolved = this.resolvePath(path6);
-    const cmd = maxBytes !== void 0 ? ["head", "-c", String(maxBytes), resolved] : ["cat", resolved];
-    const { exitCode, stdout, stderr } = await this.exec([
-      "bash",
-      "-c",
-      `${cmd.map(shellEscape).join(" ")} | base64`
-    ]);
-    if (exitCode !== 0) {
-      throw new Error(`DockerFs readFileBytes failed: ${stderr.trim() || `exit code ${exitCode}`}`);
-    }
-    return Buffer.from(stdout.trim(), "base64");
-  }
-  async writeFile(path6, content) {
-    const resolved = this.resolvePath(path6);
-    const dir = resolved.substring(0, resolved.lastIndexOf("/"));
-    if (dir) {
-      await this.exec(["mkdir", "-p", dir]);
-    }
-    const encoded = Buffer.from(content, "utf-8").toString("base64");
-    const MAX_INLINE_LEN = 1e5;
-    if (encoded.length <= MAX_INLINE_LEN) {
-      const { exitCode, stderr } = await this.exec([
-        "bash",
-        "-c",
-        `echo ${shellEscape(encoded)} | base64 -d > ${shellEscape(resolved)}`
-      ]);
-      if (exitCode !== 0) {
-        throw new Error(`DockerFs writeFile failed: ${stderr.trim()}`);
-      }
-    } else {
-      const execInstance = await this.container.exec({
-        Cmd: ["bash", "-c", `base64 -d > ${shellEscape(resolved)}`],
-        AttachStdout: true,
-        AttachStderr: true,
-        AttachStdin: true,
-        Tty: false
-      });
-      const stream = await execInstance.start({ hijack: true, stdin: true });
-      const writable = stream;
-      writable.write(encoded);
-      writable.end();
-      const result = await collectExecStream(stream);
-      const inspection = await execInstance.inspect();
-      if (inspection.ExitCode !== 0) {
-        throw new Error(`DockerFs writeFile failed: ${result.stderr.trim()}`);
-      }
-    }
-  }
-  async appendFile(path6, content) {
-    const resolved = this.resolvePath(path6);
-    const dir = resolved.substring(0, resolved.lastIndexOf("/"));
-    if (dir) {
-      await this.exec(["mkdir", "-p", dir]);
-    }
-    const encoded = Buffer.from(content, "utf-8").toString("base64");
-    const { exitCode, stderr } = await this.exec([
-      "bash",
-      "-c",
-      `echo ${shellEscape(encoded)} | base64 -d >> ${shellEscape(resolved)}`
-    ]);
-    if (exitCode !== 0) {
-      throw new Error(`DockerFs appendFile failed: ${stderr.trim()}`);
-    }
-  }
-  async deleteFile(path6, opts) {
-    const resolved = this.resolvePath(path6);
-    const args = opts?.recursive ? ["rm", "-rf", resolved] : ["rm", "-f", resolved];
-    await this.exec(args);
-  }
-  async mkdir(path6, opts) {
-    const resolved = this.resolvePath(path6);
-    const args = opts?.recursive ? ["mkdir", "-p", resolved] : ["mkdir", resolved];
-    await this.exec(args);
-  }
-  async readdir(path6, _opts) {
-    const resolved = this.resolvePath(path6);
-    const { exitCode, stdout, stderr } = await this.exec([
-      "bash",
-      "-c",
-      `find ${shellEscape(resolved)} -maxdepth 1 -mindepth 1 -printf '%y %p\\n' 2>/dev/null`
-    ]);
-    if (exitCode !== 0 && stderr.trim()) {
-      throw new Error(`DockerFs readdir failed: ${stderr.trim()}`);
-    }
-    const entries = [];
-    for (const line of stdout.trim().split("\n")) {
-      if (!line) continue;
-      const spaceIdx = line.indexOf(" ");
-      const type = line.substring(0, spaceIdx);
-      const fullPath = line.substring(spaceIdx + 1);
-      const name = fullPath.substring(fullPath.lastIndexOf("/") + 1);
-      entries.push({
-        name,
-        path: fullPath,
-        isDirectory: type === "d",
-        isFile: type === "f"
-      });
-    }
-    return entries;
-  }
-  async exists(path6) {
-    const resolved = this.resolvePath(path6);
-    const { exitCode } = await this.exec(["test", "-e", resolved]);
-    return exitCode === 0;
-  }
-  async stat(path6) {
-    const resolved = this.resolvePath(path6);
-    const { exitCode, stdout, stderr } = await this.exec([
-      "stat",
-      "-c",
-      "%s	%F	%W	%Y",
-      resolved
-    ]);
-    if (exitCode !== 0) {
-      throw new Error(`DockerFs stat failed: ${stderr.trim() || `exit code ${exitCode}`}`);
-    }
-    const parts = stdout.trim().split("	");
-    const size = parseInt(parts[0], 10);
-    const fileType = parts[1];
-    const createdEpoch = parseInt(parts[2], 10);
-    const modifiedEpoch = parseInt(parts[3], 10);
-    return {
-      size,
-      isDirectory: fileType === "directory",
-      isFile: fileType.startsWith("regular"),
-      createdAt: createdEpoch > 0 ? new Date(createdEpoch * 1e3) : void 0,
-      modifiedAt: modifiedEpoch > 0 ? new Date(modifiedEpoch * 1e3) : void 0
-    };
-  }
-};
-function shellEscape(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
-function collectExecStream(stream) {
-  return new Promise((resolve7, reject) => {
-    const stdoutBufs = [];
-    const stderrBufs = [];
-    let pending = Buffer.alloc(0);
-    stream.on("data", (chunk) => {
-      let buf = pending.length > 0 ? Buffer.concat([pending, chunk]) : chunk;
-      let offset = 0;
-      while (offset + 8 <= buf.length) {
-        const payloadLen = buf.readUInt32BE(offset + 4);
-        if (offset + 8 + payloadLen > buf.length) break;
-        const streamType = buf[offset];
-        const payload = buf.subarray(offset + 8, offset + 8 + payloadLen);
-        if (streamType === 2) {
-          stderrBufs.push(payload);
-        } else {
-          stdoutBufs.push(payload);
-        }
-        offset += 8 + payloadLen;
-      }
-      pending = offset < buf.length ? buf.subarray(offset) : Buffer.alloc(0);
-    });
-    stream.on("end", () => {
-      resolve7({
-        stdout: Buffer.concat(stdoutBufs).toString("utf-8"),
-        stderr: Buffer.concat(stderrBufs).toString("utf-8")
-      });
-    });
-    stream.on("error", (err) => reject(err));
-  });
-}
-
-// src/virtual/docker-computer.ts
-var DockerComputer = class {
-  container;
-  defaultCwd;
-  defaultTimeout;
-  constructor(opts) {
-    this.container = opts.container;
-    this.defaultCwd = opts.defaultCwd ?? "/";
-    this.defaultTimeout = opts.defaultTimeout ?? 3e4;
-  }
-  async executeCommand(command, opts) {
-    const cwd = opts?.cwd ?? this.defaultCwd;
-    const timeout = opts?.timeout ?? this.defaultTimeout;
-    const execOpts = {
-      Cmd: ["bash", "-c", `cd ${shellEscape2(cwd)} && ${command}`],
-      AttachStdout: true,
-      AttachStderr: true,
-      Tty: false
-    };
-    if (opts?.env) {
-      execOpts.Env = Object.entries(opts.env).map(
-        ([k, v]) => `${k}=${v}`
-      );
-    }
-    const exec = await this.container.exec(execOpts);
-    const stream = await exec.start({ hijack: true, stdin: false });
-    const { stdout, stderr } = await collectStream(stream, timeout);
-    const inspection = await exec.inspect();
-    return {
-      exitCode: inspection.ExitCode,
-      stdout,
-      stderr
-    };
-  }
-};
-function shellEscape2(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
-function collectStream(stream, timeout) {
-  return new Promise((resolve7, reject) => {
-    const stdoutBufs = [];
-    const stderrBufs = [];
-    let pending = Buffer.alloc(0);
-    const timer = setTimeout(() => {
-      stream.destroy?.();
-      resolve7({
-        stdout: Buffer.concat(stdoutBufs).toString("utf-8"),
-        stderr: Buffer.concat(stderrBufs).toString("utf-8") + "\n[timeout after " + timeout + "ms]"
-      });
-    }, timeout);
-    stream.on("data", (chunk) => {
-      let buf = pending.length > 0 ? Buffer.concat([pending, chunk]) : chunk;
-      let offset = 0;
-      while (offset + 8 <= buf.length) {
-        const payloadLen = buf.readUInt32BE(offset + 4);
-        if (offset + 8 + payloadLen > buf.length) break;
-        const streamType = buf[offset];
-        const payload = buf.subarray(offset + 8, offset + 8 + payloadLen);
-        if (streamType === 2) {
-          stderrBufs.push(payload);
-        } else {
-          stdoutBufs.push(payload);
-        }
-        offset += 8 + payloadLen;
-      }
-      pending = offset < buf.length ? buf.subarray(offset) : Buffer.alloc(0);
-    });
-    stream.on("end", () => {
-      clearTimeout(timer);
-      resolve7({
-        stdout: Buffer.concat(stdoutBufs).toString("utf-8"),
-        stderr: Buffer.concat(stderrBufs).toString("utf-8")
-      });
-    });
-    stream.on("error", (err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-  });
-}
-
-// src/virtual/e2b-fs.ts
-import * as path4 from "path";
-var E2BFs = class {
-  sandbox;
-  workingDir;
-  constructor(opts) {
-    this.sandbox = opts.sandbox;
-    this.workingDir = opts.workingDir;
-  }
-  resolvePath(p) {
-    if (!this.workingDir) return p;
-    const normalizedBase = this.workingDir.endsWith("/") ? this.workingDir : this.workingDir + "/";
-    if (p.startsWith("/")) {
-      if (p !== this.workingDir && !p.startsWith(normalizedBase)) {
-        throw new Error(`Absolute path "${p}" is outside working directory "${this.workingDir}"`);
-      }
-      return p;
-    }
-    const resolved = path4.resolve(this.workingDir, p);
-    if (resolved !== this.workingDir && !resolved.startsWith(normalizedBase)) {
-      throw new Error(`Path "${p}" escapes working directory "${this.workingDir}"`);
-    }
-    return resolved;
-  }
-  async readFile(path6, _opts) {
-    return this.sandbox.files.read(this.resolvePath(path6), {
-      format: "text"
-    });
-  }
-  async readFileBytes(path6, maxBytes) {
-    const data = await this.sandbox.files.read(this.resolvePath(path6), {
-      format: "bytes"
-    });
-    const buf = Buffer.from(data);
-    if (maxBytes !== void 0 && buf.length > maxBytes) {
-      return buf.subarray(0, maxBytes);
-    }
-    return buf;
-  }
-  async writeFile(path6, content) {
-    await this.sandbox.files.write(this.resolvePath(path6), content);
-  }
-  /**
-   * @warning Not atomic. Concurrent appends may lose data due to
-   * read-then-write TOCTOU. The E2B SDK does not expose an append primitive.
-   */
-  async appendFile(path6, content) {
-    let existing = "";
-    try {
-      existing = await this.readFile(path6);
-    } catch {
-    }
-    await this.writeFile(path6, existing + content);
-  }
-  async deleteFile(path6, _opts) {
-    await this.sandbox.files.remove(this.resolvePath(path6));
-  }
-  async mkdir(path6, _opts) {
-    await this.sandbox.files.makeDir(this.resolvePath(path6));
-  }
-  async readdir(path6, _opts) {
-    const entries = await this.sandbox.files.list(this.resolvePath(path6));
-    return entries.map((entry) => ({
-      name: entry.name,
-      path: entry.path,
-      isDirectory: entry.type === "dir",
-      isFile: entry.type === "file",
-      size: entry.size
-    }));
-  }
-  async exists(path6) {
-    return this.sandbox.files.exists(this.resolvePath(path6));
-  }
-  async stat(path6) {
-    const info = await this.sandbox.files.getInfo(this.resolvePath(path6));
-    return {
-      size: info.size ?? 0,
-      isDirectory: info.type === "dir",
-      isFile: info.type === "file",
-      modifiedAt: info.modifiedTime
-    };
-  }
-};
-
-// src/virtual/e2b-computer.ts
-var E2BComputer = class {
-  sandbox;
-  defaultCwd;
-  defaultTimeout;
-  constructor(opts) {
-    this.sandbox = opts.sandbox;
-    this.defaultCwd = opts.defaultCwd;
-    this.defaultTimeout = opts.defaultTimeout ?? 3e4;
-  }
-  async executeCommand(command, opts) {
-    const result = await this.sandbox.commands.run(command, {
-      cwd: opts?.cwd ?? this.defaultCwd,
-      timeout: opts?.timeout ?? this.defaultTimeout,
-      envs: opts?.env
-    });
-    return {
-      exitCode: result.exitCode,
-      stdout: result.stdout ?? "",
-      stderr: result.stderr ?? ""
-    };
-  }
-};
-
-// src/virtual/freestyle-fs.ts
-import * as path5 from "path";
-var FreestyleFs = class {
-  vm;
-  workingDir;
-  constructor(opts) {
-    this.vm = opts.vm;
-    this.workingDir = opts.workingDir;
-  }
-  resolvePath(p) {
-    if (p.includes("\0")) {
-      throw new Error("Path contains null bytes");
-    }
-    if (!this.workingDir) return p;
-    const normalizedBase = this.workingDir.endsWith("/") ? this.workingDir : this.workingDir + "/";
-    if (p.startsWith("/")) {
-      const normalized = path5.normalize(p);
-      if (normalized !== this.workingDir && !normalized.startsWith(normalizedBase)) {
-        throw new Error(`Absolute path "${p}" is outside working directory "${this.workingDir}"`);
-      }
-      return normalized;
-    }
-    const resolved = path5.resolve(this.workingDir, p);
-    if (resolved !== this.workingDir && !resolved.startsWith(normalizedBase)) {
-      throw new Error(`Path "${p}" escapes working directory "${this.workingDir}"`);
-    }
-    return resolved;
-  }
-  async readFile(filePath, _opts) {
-    return this.vm.fs.readTextFile(this.resolvePath(filePath));
-  }
-  async readFileBytes(filePath, maxBytes) {
-    const resolved = this.resolvePath(filePath);
-    const cmd = maxBytes !== void 0 ? `head -c ${maxBytes} ${shellEscape3(resolved)} | base64` : `base64 ${shellEscape3(resolved)}`;
-    const { statusCode, stdout, stderr } = await this.vm.exec(cmd);
-    if (statusCode !== 0) {
-      throw new Error(`FreestyleFs readFileBytes failed: ${stderr?.trim() || `exit code ${statusCode}`}`);
-    }
-    return Buffer.from((stdout ?? "").trim(), "base64");
-  }
-  async writeFile(filePath, content) {
-    await this.vm.fs.writeTextFile(this.resolvePath(filePath), content);
-  }
-  async appendFile(filePath, content) {
-    const resolved = this.resolvePath(filePath);
-    const encoded = Buffer.from(content, "utf-8").toString("base64");
-    const { statusCode, stderr } = await this.vm.exec(
-      `echo ${shellEscape3(encoded)} | base64 -d >> ${shellEscape3(resolved)}`
-    );
-    if (statusCode !== 0) {
-      throw new Error(`FreestyleFs appendFile failed: ${stderr?.trim() || `exit code ${statusCode}`}`);
-    }
-  }
-  async deleteFile(filePath, opts) {
-    const resolved = this.resolvePath(filePath);
-    const flag = opts?.recursive ? "-rf" : "-f";
-    await this.vm.exec(`rm ${flag} ${shellEscape3(resolved)}`);
-  }
-  async mkdir(filePath, opts) {
-    const resolved = this.resolvePath(filePath);
-    const flag = opts?.recursive ? "-p " : "";
-    await this.vm.exec(`mkdir ${flag}${shellEscape3(resolved)}`);
-  }
-  async readdir(dirPath, _opts) {
-    const resolved = this.resolvePath(dirPath);
-    const items = await this.vm.fs.readDir(resolved);
-    return items.map((entry) => ({
-      name: entry.name,
-      path: resolved === "/" ? `/${entry.name}` : `${resolved}/${entry.name}`,
-      isDirectory: entry.kind === "dir" || entry.kind === "directory",
-      isFile: entry.kind === "file"
-    }));
-  }
-  async exists(filePath) {
-    const resolved = this.resolvePath(filePath);
-    const { statusCode } = await this.vm.exec(`test -e ${shellEscape3(resolved)}`);
-    return statusCode === 0;
-  }
-  async stat(filePath) {
-    const resolved = this.resolvePath(filePath);
-    const { statusCode, stdout, stderr } = await this.vm.exec(
-      `stat -c '%s	%F	%W	%Y' ${shellEscape3(resolved)}`
-    );
-    if (statusCode !== 0) {
-      throw new Error(`FreestyleFs stat failed: ${stderr?.trim() || `exit code ${statusCode}`}`);
-    }
-    const parts = (stdout ?? "").trim().split("	");
-    const size = parseInt(parts[0], 10);
-    const fileType = parts[1];
-    const createdEpoch = parseInt(parts[2], 10);
-    const modifiedEpoch = parseInt(parts[3], 10);
-    return {
-      size,
-      isDirectory: fileType === "directory",
-      isFile: fileType.startsWith("regular"),
-      createdAt: createdEpoch > 0 ? new Date(createdEpoch * 1e3) : void 0,
-      modifiedAt: modifiedEpoch > 0 ? new Date(modifiedEpoch * 1e3) : void 0
-    };
-  }
-};
-function shellEscape3(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
-
-// src/virtual/freestyle-computer.ts
-var FreestyleComputer = class {
-  vm;
-  defaultCwd;
-  defaultTimeout;
-  constructor(opts) {
-    this.vm = opts.vm;
-    this.defaultCwd = opts.defaultCwd;
-    this.defaultTimeout = opts.defaultTimeout ?? 3e4;
-  }
-  async executeCommand(command, opts) {
-    const result = await this.vm.exec(command, {
-      cwd: opts?.cwd ?? this.defaultCwd,
-      timeout: opts?.timeout ?? this.defaultTimeout
-    });
-    return {
-      exitCode: result.statusCode ?? 1,
-      stdout: result.stdout ?? "",
-      stderr: result.stderr ?? ""
-    };
-  }
-};
-
 // src/virtual/sandbox.ts
-function uninitError() {
-  throw new Error(
-    "Sandbox not initialized \u2014 call init() or pass a pre-created resource"
-  );
-}
-function createFsProxy() {
-  let inner = null;
-  const get = () => inner ?? uninitError();
-  return {
-    setTarget(target) {
-      inner = target;
-    },
-    readFile: (...args) => get().readFile(...args),
-    readFileBytes: (...args) => get().readFileBytes?.(...args),
-    writeFile: (...args) => get().writeFile(...args),
-    appendFile: (...args) => get().appendFile(...args),
-    deleteFile: (...args) => get().deleteFile(...args),
-    mkdir: (...args) => get().mkdir(...args),
-    readdir: (...args) => get().readdir(...args),
-    exists: (...args) => get().exists(...args),
-    stat: (...args) => get().stat(...args)
-  };
-}
-function createComputerProxy() {
-  let inner = null;
-  const get = () => inner ?? uninitError();
-  return {
-    setTarget(target) {
-      inner = target;
-    },
-    executeCommand: (...args) => get().executeCommand(...args)
-  };
-}
 function UnsandboxedLocal(opts) {
   const cwd = opts?.cwd;
   return {
@@ -1121,357 +315,126 @@ function LocalSandbox(opts) {
     dispose: () => computer.dispose()
   };
 }
-function SpritesSandbox(opts) {
-  const baseURL = (opts.baseURL ?? "https://api.sprites.dev").replace(/\/$/, "");
-  const userProvidedName = opts.spriteName;
-  if (userProvidedName) {
-    const fsOpts = { ...opts, spriteName: userProvidedName };
-    return {
-      fs: new SpritesFs(fsOpts),
-      computer: new SpritesComputer(fsOpts),
-      sandboxId: () => userProvidedName
-    };
-  }
-  const fsProxy = createFsProxy();
-  const computerProxy = createComputerProxy();
-  let resolvedName;
-  let autoCreated = false;
-  let initPromise = null;
-  async function doInit(reconnectId) {
-    let name = reconnectId ?? `${opts.namePrefix ?? "noumen-"}${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    let needsCreate = !reconnectId;
-    if (reconnectId) {
-      const check = await fetch(`${baseURL}/v1/sprites/${reconnectId}`, {
-        method: "GET",
-        headers: { Authorization: `Bearer ${opts.token}` }
-      });
-      if (!check.ok) {
-        name = `${opts.namePrefix ?? "noumen-"}${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        needsCreate = true;
-      }
-    }
-    if (needsCreate) {
-      const res = await fetch(`${baseURL}/v1/sprites`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${opts.token}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ name })
-      });
-      if (!res.ok) {
-        throw new Error(`Sprites auto-create failed (${res.status}): ${await res.text()}`);
-      }
-      autoCreated = true;
+
+// src/session/auto-title.ts
+var DEFAULT_AUTO_TITLE_MAX_INPUT_CHARS = 2e3;
+var DEFAULT_AUTO_TITLE_SYSTEM_PROMPT = `Generate a concise, sentence-case title (3-7 words) that captures the main topic or goal of this coding session. The title should be clear enough that the user recognizes the session in a list. Use sentence case: capitalize only the first word and proper nouns.
+
+Return JSON with a single "title" field.
+
+Good examples:
+{"title": "Fix login button on mobile"}
+{"title": "Add OAuth authentication"}
+{"title": "Debug failing CI tests"}
+{"title": "Refactor API client error handling"}
+
+Bad (too vague): {"title": "Code changes"}
+Bad (too long): {"title": "Investigate and fix the issue where the login button does not respond on mobile devices"}
+Bad (wrong case): {"title": "Fix Login Button On Mobile"}`;
+function extractTitleSeedText(messages, maxChars = DEFAULT_AUTO_TITLE_MAX_INPUT_CHARS) {
+  const parts = [];
+  for (const msg of messages) {
+    if (msg.role !== "user" && msg.role !== "assistant") continue;
+    const content = msg.content;
+    if (content === null || content === void 0) continue;
+    if (typeof content === "string") {
+      if (content.trim()) parts.push(content);
+      continue;
     }
-    resolvedName = name;
-    const childOpts = { ...opts, spriteName: name };
-    fsProxy.setTarget(new SpritesFs(childOpts));
-    computerProxy.setTarget(new SpritesComputer(childOpts));
-  }
-  return {
-    fs: fsProxy,
-    computer: computerProxy,
-    sandboxId: () => resolvedName,
-    init(sandboxId) {
-      if (!initPromise) {
-        initPromise = doInit(sandboxId).catch((err) => {
-          initPromise = null;
-          throw err;
-        });
-      }
-      return initPromise;
-    },
-    async dispose() {
-      if (initPromise) {
-        await initPromise.catch(() => {
-        });
-      }
-      if (!autoCreated || !resolvedName) return;
-      try {
-        const res = await fetch(`${baseURL}/v1/sprites/${resolvedName}`, {
-          method: "DELETE",
-          headers: { Authorization: `Bearer ${opts.token}` }
-        });
-        if (!res.ok && res.status !== 404) {
-          throw new Error(`Sprites dispose failed (${res.status}): ${await res.text()}`);
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block.type === "text" && typeof block.text === "string") {
+          if (block.text.trim()) parts.push(block.text);
         }
-      } catch {
       }
     }
-  };
-}
-function DockerSandbox(opts) {
-  if (opts.container) {
-    const c = opts.container;
-    return {
-      fs: new DockerFs({ container: c, workingDir: opts.cwd }),
-      computer: new DockerComputer({
-        container: c,
-        defaultCwd: opts.cwd,
-        defaultTimeout: opts.defaultTimeout
-      }),
-      sandboxId: () => c.id
-    };
   }
-  if (!opts.image) {
-    throw new Error("DockerSandbox requires either `container` or `image`");
-  }
-  const fsProxy = createFsProxy();
-  const computerProxy = createComputerProxy();
-  let containerId;
-  let containerRef;
-  let autoCreated = false;
-  let initPromise = null;
-  async function doInit(reconnectId) {
-    const Docker = (await import("dockerode")).default;
-    const docker = new Docker();
-    let container;
-    if (reconnectId) {
-      container = docker.getContainer(reconnectId);
-      try {
-        await container.inspect();
-      } catch {
-        container = await docker.createContainer({
-          Image: opts.image,
-          Cmd: opts.cmd ?? ["sleep", "infinity"],
-          Env: opts.env,
-          Tty: false,
-          ...opts.dockerOptions
-        });
-        await container.start();
-        autoCreated = true;
-      }
-    } else {
-      container = await docker.createContainer({
-        Image: opts.image,
-        Cmd: opts.cmd ?? ["sleep", "infinity"],
-        Env: opts.env,
-        Tty: false,
-        ...opts.dockerOptions
-      });
-      await container.start();
-      autoCreated = true;
-    }
-    containerRef = container;
-    containerId = container.id;
-    fsProxy.setTarget(new DockerFs({ container, workingDir: opts.cwd }));
-    computerProxy.setTarget(new DockerComputer({
-      container,
-      defaultCwd: opts.cwd,
-      defaultTimeout: opts.defaultTimeout
-    }));
-  }
-  return {
-    fs: fsProxy,
-    computer: computerProxy,
-    sandboxId: () => containerId,
-    init(sandboxId) {
-      if (!initPromise) {
-        initPromise = doInit(sandboxId).catch((err) => {
-          initPromise = null;
-          throw err;
-        });
-      }
-      return initPromise;
-    },
-    async dispose() {
-      if (initPromise) {
-        await initPromise.catch(() => {
-        });
-      }
-      if (!autoCreated || !containerRef) return;
-      try {
-        await containerRef.stop();
-      } catch {
-      }
-      try {
-        await containerRef.remove();
-      } catch {
+  const text = parts.join("\n").trim();
+  if (text.length <= maxChars) return text;
+  return text.slice(-maxChars);
+}
+function extractTitleFromResponse(raw) {
+  if (!raw) return null;
+  const trimmed = raw.trim();
+  const parseTitle = (s) => {
+    let obj;
+    try {
+      obj = JSON.parse(s);
+    } catch {
+      return { kind: "none" };
+    }
+    if (obj && typeof obj === "object" && "title" in obj) {
+      const v = obj.title;
+      if (typeof v === "string") {
+        const t = v.trim();
+        if (t) return { kind: "ok", title: t };
       }
     }
+    return { kind: "empty" };
   };
+  const whole = parseTitle(trimmed);
+  if (whole.kind === "ok") return whole.title;
+  if (whole.kind === "empty") return null;
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    const sliced = parseTitle(trimmed.slice(start, end + 1));
+    if (sliced.kind === "ok") return sliced.title;
+    if (sliced.kind === "empty") return null;
+  }
+  const quoteMatch = trimmed.match(/"([^"\\]{2,120})"/);
+  if (quoteMatch?.[1]) return quoteMatch[1].trim();
+  return null;
 }
-function E2BSandbox(opts) {
-  if (opts.sandbox) {
-    const s = opts.sandbox;
-    return {
-      fs: new E2BFs({ sandbox: s, workingDir: opts.cwd }),
-      computer: new E2BComputer({
-        sandbox: s,
-        defaultCwd: opts.cwd,
-        defaultTimeout: opts.defaultTimeout
-      }),
-      sandboxId: () => s.sandboxId
-    };
-  }
-  const fsProxy = createFsProxy();
-  const computerProxy = createComputerProxy();
-  let resolvedId;
-  let sandboxRef;
-  let autoCreated = false;
-  let initPromise = null;
-  async function doInit(reconnectId) {
-    const e2b = await import("e2b");
-    const SandboxClass = e2b.Sandbox ?? e2b.default?.Sandbox;
-    if (!SandboxClass) {
-      throw new Error("Could not resolve Sandbox class from 'e2b' package");
-    }
-    let sandbox;
-    if (reconnectId) {
-      try {
-        sandbox = await SandboxClass.connect(reconnectId, {
-          apiKey: opts.apiKey
-        });
-      } catch {
-        sandbox = await SandboxClass.create({
-          template: opts.template ?? "base",
-          apiKey: opts.apiKey,
-          timeoutMs: opts.timeoutMs
-        });
-        autoCreated = true;
-      }
-    } else {
-      sandbox = await SandboxClass.create({
-        template: opts.template ?? "base",
-        apiKey: opts.apiKey,
-        timeoutMs: opts.timeoutMs
-      });
-      autoCreated = true;
-    }
-    sandboxRef = sandbox;
-    resolvedId = sandbox.sandboxId ?? reconnectId;
-    fsProxy.setTarget(new E2BFs({ sandbox, workingDir: opts.cwd }));
-    computerProxy.setTarget(new E2BComputer({
-      sandbox,
-      defaultCwd: opts.cwd,
-      defaultTimeout: opts.defaultTimeout
-    }));
-  }
-  return {
-    fs: fsProxy,
-    computer: computerProxy,
-    sandboxId: () => resolvedId,
-    init(sandboxId) {
-      if (!initPromise) {
-        initPromise = doInit(sandboxId).catch((err) => {
-          initPromise = null;
-          throw err;
-        });
-      }
-      return initPromise;
+async function generateAutoTitle(messages, opts) {
+  const seed = extractTitleSeedText(messages, opts.maxInputChars);
+  if (!seed) return null;
+  const model = opts.model ?? opts.provider.defaultModel;
+  if (!model) return null;
+  const system = opts.systemPrompt ?? DEFAULT_AUTO_TITLE_SYSTEM_PROMPT;
+  const params = {
+    model,
+    system,
+    messages: [{ role: "user", content: seed }],
+    max_tokens: 60,
+    outputFormat: {
+      type: "json_schema",
+      schema: {
+        type: "object",
+        properties: { title: { type: "string" } },
+        required: ["title"],
+        additionalProperties: false
+      },
+      name: "session_title",
+      strict: true
     },
-    async dispose() {
-      if (initPromise) {
-        await initPromise.catch(() => {
-        });
-      }
-      if (!autoCreated || !sandboxRef) return;
-      if (typeof sandboxRef.kill === "function") {
-        await sandboxRef.kill();
+    signal: opts.signal
+  };
+  let text = "";
+  try {
+    for await (const chunk of opts.provider.chat(params)) {
+      for (const choice of chunk.choices) {
+        const delta = choice.delta.content;
+        if (typeof delta === "string") text += delta;
       }
     }
-  };
-}
-function FreestyleSandbox(opts) {
-  if (opts.vm) {
-    const v = opts.vm;
-    return {
-      fs: new FreestyleFs({ vm: v, workingDir: opts.cwd }),
-      computer: new FreestyleComputer({
-        vm: v,
-        defaultCwd: opts.cwd,
-        defaultTimeout: opts.defaultTimeout
-      }),
-      sandboxId: () => v.vmId
-    };
+  } catch {
+    return null;
   }
-  const fsProxy = createFsProxy();
-  const computerProxy = createComputerProxy();
-  let resolvedId;
-  let vmRef = null;
-  let autoCreated = false;
-  let initPromise = null;
-  async function doInit(reconnectId) {
-    const mod = await import("freestyle-sandboxes");
-    const freestyle = mod.freestyle ?? mod.default?.freestyle;
-    if (!freestyle?.vms) {
-      throw new Error("Could not resolve freestyle client from 'freestyle-sandboxes' package");
-    }
-    let vm;
-    if (reconnectId) {
-      try {
-        const result = await freestyle.vms.get({ vmId: reconnectId });
-        vm = result.vm;
-        resolvedId = reconnectId;
-      } catch {
-        const result = await freestyle.vms.create({
-          ...opts.spec ? { spec: opts.spec } : {},
-          snapshotId: opts.snapshotId,
-          workdir: opts.cwd,
-          idleTimeoutSeconds: opts.idleTimeoutSeconds ?? 600,
-          additionalFiles: opts.additionalFiles,
-          gitRepos: opts.gitRepos
-        });
-        vm = result.vm;
-        resolvedId = result.vmId ?? result.id;
-        autoCreated = true;
-      }
-    } else {
-      const result = await freestyle.vms.create({
-        ...opts.spec ? { spec: opts.spec } : {},
-        snapshotId: opts.snapshotId,
-        workdir: opts.cwd,
-        idleTimeoutSeconds: opts.idleTimeoutSeconds ?? 600,
-        additionalFiles: opts.additionalFiles,
-        gitRepos: opts.gitRepos
-      });
-      vm = result.vm;
-      resolvedId = result.vmId ?? result.id;
-      autoCreated = true;
-    }
-    vmRef = vm;
-    fsProxy.setTarget(new FreestyleFs({ vm, workingDir: opts.cwd }));
-    computerProxy.setTarget(new FreestyleComputer({
-      vm,
-      defaultCwd: opts.cwd,
-      defaultTimeout: opts.defaultTimeout
-    }));
+  if (!text) return null;
+  const extracted = extractTitleFromResponse(text) ?? text.trim();
+  return normalizeTitle(extracted);
+}
+function normalizeTitle(raw) {
+  if (!raw) return null;
+  let t = raw.replace(/\s+/g, " ").trim();
+  if (t.length >= 2 && (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'"))) {
+    t = t.slice(1, -1).trim();
   }
-  return {
-    fs: fsProxy,
-    computer: computerProxy,
-    sandboxId: () => resolvedId,
-    init(sandboxId) {
-      if (!initPromise) {
-        initPromise = doInit(sandboxId).catch((err) => {
-          initPromise = null;
-          throw err;
-        });
-      }
-      return initPromise;
-    },
-    async dispose() {
-      if (initPromise) {
-        await initPromise.catch(() => {
-        });
-      }
-      if (!autoCreated || !vmRef || !resolvedId) return;
-      try {
-        const strategy = opts.disposeStrategy ?? "suspend";
-        if (strategy === "suspend") {
-          await vmRef.suspend();
-        } else {
-          const mod = await import("freestyle-sandboxes");
-          const freestyle = mod.freestyle ?? mod.default?.freestyle;
-          if (freestyle?.vms) {
-            await freestyle.vms.delete({ vmId: resolvedId });
-          }
-        }
-      } catch {
-      }
-    }
-  };
+  t = t.replace(/\.+$/, "").trim();
+  if (!t) return null;
+  if (t.length > 120) t = t.slice(0, 120).trim();
+  return t;
 }
 
 // src/checkpoint/manager.ts
@@ -1704,8 +667,8 @@ var FileCheckpointManager = class {
   restoreStateFromEntries(snapshots) {
     const trackedFiles = /* @__PURE__ */ new Set();
     for (const snap of snapshots) {
-      for (const path6 of Object.keys(snap.trackedFileBackups)) {
-        trackedFiles.add(path6);
+      for (const path2 of Object.keys(snap.trackedFileBackups)) {
+        trackedFiles.add(path2);
       }
     }
     this.state = {
@@ -1719,7 +682,7 @@ var FileCheckpointManager = class {
 // src/hooks/runner.ts
 var DEFAULT_HOOK_TIMEOUT_MS = 3e4;
 function withTimeout(promise, timeoutMs, label) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve3, reject) => {
     const timer = setTimeout(
       () => reject(new Error(`Hook "${label}" timed out after ${timeoutMs}ms`)),
       timeoutMs
@@ -1727,7 +690,7 @@ function withTimeout(promise, timeoutMs, label) {
     promise.then(
       (v) => {
         clearTimeout(timer);
-        resolve7(v);
+        resolve3(v);
       },
       (e) => {
         clearTimeout(timer);
@@ -2963,38 +1926,90 @@ var SessionStorage = class {
     await this.appendEntry(sessionId, entry);
   }
   /**
-   * Re-append custom-title and key metadata entries after a compact boundary
-   * so they remain discoverable in the active-entries window.
+   * Append a user-set session title. Wins over any `ai-title` when read.
+   * Idempotent-ish: callers may append as many as they like; the last one
+   * wins according to file order.
+   */
+  async appendCustomTitle(sessionId, title) {
+    const entry = {
+      type: "custom-title",
+      sessionId,
+      title,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.appendEntry(sessionId, entry);
+  }
+  /**
+   * Append an AI-generated session title. A `custom-title` (if present)
+   * always takes precedence on read.
+   */
+  async appendAiTitle(sessionId, title) {
+    const entry = {
+      type: "ai-title",
+      sessionId,
+      title,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.appendEntry(sessionId, entry);
+  }
+  /**
+   * Re-append custom-title, ai-title, and key metadata entries after a
+   * compact boundary so they remain discoverable in the active-entries
+   * window. Written as a single batched append so a crash mid-write can't
+   * leave the transcript with only a subset of the re-emitted entries.
    */
   async reAppendMetadataAfterCompact(sessionId) {
     const entries = await this.loadAllEntries(sessionId);
     let customTitle;
+    let aiTitle;
     const metadataByKey = /* @__PURE__ */ new Map();
     for (const entry of entries) {
       if (entry.type === "custom-title") {
         customTitle = entry.title;
       }
+      if (entry.type === "ai-title") {
+        aiTitle = entry.title;
+      }
       if (entry.type === "metadata") {
         metadataByKey.set(entry.key, entry.value);
       }
     }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const batch = [];
     if (customTitle) {
-      await this.appendEntry(sessionId, {
+      batch.push({
         type: "custom-title",
         sessionId,
         title: customTitle,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        timestamp
+      });
+    }
+    if (aiTitle) {
+      batch.push({
+        type: "ai-title",
+        sessionId,
+        title: aiTitle,
+        timestamp
       });
     }
     for (const [key, value] of metadataByKey) {
-      await this.appendMetadata(sessionId, key, value);
+      batch.push({
+        type: "metadata",
+        sessionId,
+        timestamp,
+        key,
+        value
+      });
+    }
+    if (batch.length > 0) {
+      await this.appendEntriesBatch(sessionId, batch);
     }
   }
   async loadMessages(sessionId) {
-    const path6 = this.getTranscriptPath(sessionId);
-    const exists = await this.fs.exists(path6);
+    const path2 = this.getTranscriptPath(sessionId);
+    const exists = await this.fs.exists(path2);
     if (!exists) return [];
-    const content = await this.fs.readFile(path6);
+    const content = await this.fs.readFile(path2);
     const entries = parseJSONL(content);
     let lastBoundaryIdx = -1;
     for (let i = entries.length - 1; i >= 0; i--) {
@@ -3029,15 +2044,30 @@ var SessionStorage = class {
     return messages;
   }
   async loadAllEntries(sessionId) {
-    const path6 = this.getTranscriptPath(sessionId);
-    const exists = await this.fs.exists(path6);
+    const path2 = this.getTranscriptPath(sessionId);
+    const exists = await this.fs.exists(path2);
     if (!exists) return [];
-    const content = await this.fs.readFile(path6);
+    const content = await this.fs.readFile(path2);
     return parseJSONL(content);
   }
   async sessionExists(sessionId) {
     return this.fs.exists(this.getTranscriptPath(sessionId));
   }
+  /**
+   * Return the currently persisted titles for a session. `title` reflects
+   * the display preference (custom > ai). Returns all-undefined if the
+   * session file doesn't exist.
+   */
+  async getSessionTitles(sessionId) {
+    const entries = await this.loadAllEntries(sessionId);
+    let customTitle;
+    let aiTitle;
+    for (const entry of entries) {
+      if (entry.type === "custom-title") customTitle = entry.title;
+      if (entry.type === "ai-title") aiTitle = entry.title;
+    }
+    return { title: customTitle ?? aiTitle, customTitle, aiTitle };
+  }
   async deleteSession(sessionId) {
     const filePath = this.getTranscriptPath(sessionId);
     const exists = await this.fs.exists(filePath);
@@ -3076,8 +2106,8 @@ var SessionStorage = class {
           tailSlice = content;
         }
         const headEntries = parseJSONL(headSlice);
-        const tailEntries = isSplit ? parseJSONL(tailSlice) : headEntries;
-        let title;
+        let customTitle;
+        let aiTitle;
         let firstTimestamp;
         let lastTimestamp;
         let messageCount = 0;
@@ -3087,22 +2117,27 @@ var SessionStorage = class {
             if (!firstTimestamp) firstTimestamp = e.timestamp;
             lastTimestamp = e.timestamp;
           }
-          if (e.type === "custom-title") title = e.title;
+          if (e.type === "custom-title") customTitle = e.title;
+          if (e.type === "ai-title") aiTitle = e.title;
         }
         if (isSplit) {
+          const tailEntries = parseJSONL(tailSlice);
           for (const e of tailEntries) {
             if (e.type === "message" || e.type === "summary") {
               messageCount++;
               if (e.timestamp) lastTimestamp = e.timestamp;
             }
-            if (e.type === "custom-title") title = e.title;
+            if (e.type === "custom-title") customTitle = e.title;
+            if (e.type === "ai-title") aiTitle = e.title;
           }
         }
         sessions.push({
           sessionId,
           createdAt: firstTimestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
           lastMessageAt: lastTimestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
-          title,
+          title: customTitle ?? aiTitle,
+          customTitle,
+          aiTitle,
           messageCount
         });
       } catch {
@@ -3402,17 +2437,17 @@ function walkAncestors(cwd) {
   }
   return dirs;
 }
-async function tryLoadFile(fs2, path6, scope, out, maxDepth, excludes) {
-  if (isExcluded(path6, excludes)) return;
-  const file = await loadContextFile(fs2, path6, scope, /* @__PURE__ */ new Set(), 0, maxDepth);
+async function tryLoadFile(fs2, path2, scope, out, maxDepth, excludes) {
+  if (isExcluded(path2, excludes)) return;
+  const file = await loadContextFile(fs2, path2, scope, /* @__PURE__ */ new Set(), 0, maxDepth);
   if (file) out.push(file);
 }
-async function loadContextFile(fs2, path6, scope, visited, depth, maxDepth) {
-  const normalized = normalizePath(path6);
+async function loadContextFile(fs2, path2, scope, visited, depth, maxDepth) {
+  const normalized = normalizePath(path2);
   if (visited.has(normalized)) return null;
   let raw;
   try {
-    raw = await fs2.readFile(path6);
+    raw = await fs2.readFile(path2);
   } catch {
     return null;
   }
@@ -3421,9 +2456,9 @@ async function loadContextFile(fs2, path6, scope, visited, depth, maxDepth) {
   const { frontmatter, body } = parseFrontmatter(raw);
   const globs = parsePaths(frontmatter.paths);
   const content = stripHtmlComments(body);
-  const includes = await resolveIncludes(fs2, content, path6, visited, depth, maxDepth);
+  const includes = await resolveIncludes(fs2, content, path2, visited, depth, maxDepth);
   return {
-    path: path6,
+    path: path2,
     scope,
     content,
     ...globs.length > 0 ? { globs } : {},
@@ -3489,15 +2524,15 @@ function stripHtmlComments(content) {
   if (!content.includes("<!--")) return content;
   return content.replace(/<!--[\s\S]*?-->/g, "");
 }
-function isExcluded(path6, excludes) {
+function isExcluded(path2, excludes) {
   if (excludes.length === 0) return false;
   return excludes.some((pattern) => {
-    if (path6 === pattern) return true;
+    if (path2 === pattern) return true;
     if (pattern.includes("*")) {
       const regex = simpleGlobToRegex(pattern);
-      return regex.test(path6);
+      return regex.test(path2);
     }
-    return path6.includes(pattern);
+    return path2.includes(pattern);
   });
 }
 function simpleGlobToRegex(glob) {
@@ -6231,7 +5266,7 @@ async function executeToolsStep(toolCalls, streamingExec, streamingResults, exec
 }
 
 // src/file-state/cache.ts
-import { normalize as normalize4 } from "path";
+import { normalize as normalize2 } from "path";
 var DEFAULT_MAX_ENTRIES = 100;
 var DEFAULT_MAX_BYTES = 25 * 1024 * 1024;
 var FileStateCache = class {
@@ -6243,14 +5278,14 @@ var FileStateCache = class {
     this.maxEntries = config?.maxEntries ?? DEFAULT_MAX_ENTRIES;
     this.maxBytes = config?.maxBytes ?? DEFAULT_MAX_BYTES;
   }
-  key(path6) {
-    return normalize4(path6);
+  key(path2) {
+    return normalize2(path2);
   }
   byteSize(state) {
     return Math.max(1, Buffer.byteLength(state.content, "utf8"));
   }
-  set(path6, state) {
-    const k = this.key(path6);
+  set(path2, state) {
+    const k = this.key(path2);
     const existing = this.entries.get(k);
     if (existing) {
       this.currentBytes -= this.byteSize(existing);
@@ -6266,19 +5301,19 @@ var FileStateCache = class {
     this.entries.set(k, state);
     this.currentBytes += size;
   }
-  get(path6) {
-    const k = this.key(path6);
+  get(path2) {
+    const k = this.key(path2);
     const state = this.entries.get(k);
     if (!state) return void 0;
     this.entries.delete(k);
     this.entries.set(k, state);
     return state;
   }
-  has(path6) {
-    return this.entries.has(this.key(path6));
+  has(path2) {
+    return this.entries.has(this.key(path2));
   }
-  delete(path6) {
-    const k = this.key(path6);
+  delete(path2) {
+    const k = this.key(path2);
     const existing = this.entries.get(k);
     if (existing) {
       this.currentBytes -= this.byteSize(existing);
@@ -6320,8 +5355,8 @@ function getActiveSkills(allSkills, activatedNames) {
     return activatedNames.has(skill.name);
   });
 }
-function matchesAnyGlob(path6, patterns) {
-  return patterns.some((pattern) => globMatch(pattern, path6));
+function matchesAnyGlob(path2, patterns) {
+  return patterns.some((pattern) => globMatch(pattern, path2));
 }
 function globMatch(pattern, str) {
   const regex = globToRegex(pattern);
@@ -6803,8 +5838,8 @@ var StreamingToolExecutor = class {
       }
       if (this.hasExecuting() && !this.hasCompleted()) {
         const executingPromises = this.tools.filter((t) => t.status === "executing" && t.promise).map((t) => t.promise);
-        const progressPromise = new Promise((resolve7) => {
-          this.progressResolve = resolve7;
+        const progressPromise = new Promise((resolve3) => {
+          this.progressResolve = resolve3;
         });
         if (executingPromises.length > 0) {
           await Promise.race([...executingPromises, progressPromise]);
@@ -6847,7 +5882,7 @@ function getRetryDelay(attempt, retryAfterHeader, maxDelayMs = 32e3, baseDelayMs
   return baseDelay + jitter;
 }
 function sleep(ms, signal) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve3, reject) => {
     if (signal?.aborted) {
       reject(new DOMException("Aborted", "AbortError"));
       return;
@@ -6858,7 +5893,7 @@ function sleep(ms, signal) {
     };
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve7();
+      resolve3();
     }, ms);
     signal?.addEventListener("abort", onAbort, { once: true });
   });
@@ -8210,7 +7245,13 @@ var Thread = class {
     this.config = config;
     this.sessionId = opts?.sessionId ?? generateUUID();
     this.cwd = opts?.cwd ?? "/";
-    this.model = opts?.model ?? config.model ?? "gpt-5.4";
+    const resolvedModel = opts?.model ?? config.model ?? config.provider.defaultModel;
+    if (!resolvedModel) {
+      throw new Error(
+        "Thread: no model resolved. Pass `model` to Thread / Agent / preset options, set `config.model`, or provide a provider with a `defaultModel` (built-in providers expose one automatically)."
+      );
+    }
+    this.model = resolvedModel;
     this.storage = new SessionStorage(config.fs, config.sessionDir);
     if (config.permissions) {
       this.permissionContext = {
@@ -9135,6 +8176,14 @@ var Agent = class {
   historySnipConfig;
   outputFormat;
   structuredOutputMode;
+  autoTitleConfig;
+  /**
+   * Keyed by `${sessionId}:${force ? "force" : "normal"}`. Parallel calls
+   * that pass the same `force` mode coalesce to one in-flight request; a
+   * `force: true` call arriving during a normal in-flight request runs its
+   * own pass so the caller's intent isn't silently dropped.
+   */
+  autoTitleInFlight = /* @__PURE__ */ new Map();
   providerPromise = null;
   initPromise = null;
   constructor(opts) {
@@ -9205,6 +8254,12 @@ var Agent = class {
     this.historySnipConfig = opts.options?.historySnip;
     this.outputFormat = opts.options?.outputFormat;
     this.structuredOutputMode = opts.options?.structuredOutputMode;
+    const autoTitleOpt = opts.options?.autoTitle;
+    if (autoTitleOpt === true) {
+      this.autoTitleConfig = { enabled: true };
+    } else if (autoTitleOpt && typeof autoTitleOpt === "object") {
+      this.autoTitleConfig = { enabled: true, ...autoTitleOpt };
+    }
     if (opts.options?.checkpoint?.enabled) {
       this.checkpointManager = new FileCheckpointManager(
         this.fs,
@@ -9216,7 +8271,7 @@ var Agent = class {
     if (this.resolvedProvider) return this.resolvedProvider;
     if (!this.providerPromise) {
       this.providerPromise = (async () => {
-        const { resolveProvider: resolveProvider2 } = await import("./resolve-4JA2BBDA.js");
+        const { resolveProvider: resolveProvider2 } = await import("./resolve-6KUZNEYW.js");
         return resolveProvider2(this.providerInput, { model: this.model });
       })();
     }
@@ -9374,6 +8429,92 @@ var Agent = class {
   async listSessions() {
     return this.storage.listSessions();
   }
+  /**
+   * Load the message history for a stored session, respecting compact
+   * boundaries and history snips. Returns `[]` when the session does
+   * not exist. Use this to rehydrate a UI — resuming a Thread for
+   * further execution should go through `resumeThread()` instead.
+   */
+  async getMessages(sessionId) {
+    return this.storage.loadMessages(sessionId);
+  }
+  /**
+   * Persist a user-set title for a session. Takes precedence over any
+   * AI-generated title on read. No-op on empty / whitespace-only input.
+   */
+  async setCustomTitle(sessionId, title) {
+    const trimmed = title.trim();
+    if (!trimmed) return;
+    await this.storage.appendCustomTitle(sessionId, trimmed);
+  }
+  /**
+   * Persist an AI-generated title for a session. A user-set title
+   * (see `setCustomTitle`) always wins on read, so writing this after a
+   * user has renamed the session is harmless.
+   */
+  async setAiTitle(sessionId, title) {
+    const trimmed = title.trim();
+    if (!trimmed) return;
+    await this.storage.appendAiTitle(sessionId, trimmed);
+  }
+  /**
+   * Delete a session's persisted transcript. Does not affect any
+   * currently-running `Thread` reading from the same session id.
+   */
+  async deleteSession(sessionId) {
+    await this.storage.deleteSession(sessionId);
+  }
+  /**
+   * Return the currently persisted titles for a session.
+   * `title` reflects the display preference (custom > ai).
+   */
+  async getSessionTitles(sessionId) {
+    return this.storage.getSessionTitles(sessionId);
+  }
+  /**
+   * When `autoTitle` is enabled and the session has no title yet,
+   * generate one via the configured provider + model and persist it
+   * as an `ai-title` entry. Returns the new title on success, or `null`
+   * when skipped (feature disabled, title already present, empty seed,
+   * or provider error).
+   *
+   * Concurrency-safe: parallel calls for the same session coalesce to
+   * a single in-flight request.
+   */
+  async autoTitleIfMissing(sessionId, opts) {
+    const cfg = this.autoTitleConfig;
+    if (!cfg?.enabled) return null;
+    const force = opts?.force === true;
+    const key = `${sessionId}:${force ? "force" : "normal"}`;
+    const existing = this.autoTitleInFlight.get(key);
+    if (existing) return existing;
+    const task = (async () => {
+      try {
+        if (!force) {
+          const titles = await this.storage.getSessionTitles(sessionId);
+          if (titles.customTitle || titles.aiTitle) return null;
+        }
+        await this.ensureProvider();
+        const provider = cfg.provider ?? this.getProvider();
+        const messages = await this.storage.loadMessages(sessionId);
+        if (messages.length === 0) return null;
+        const title = await generateAutoTitle(messages, {
+          provider,
+          model: cfg.model ?? provider.defaultModel ?? this.model,
+          systemPrompt: cfg.systemPrompt ?? DEFAULT_AUTO_TITLE_SYSTEM_PROMPT,
+          maxInputChars: cfg.maxInputChars ?? DEFAULT_AUTO_TITLE_MAX_INPUT_CHARS,
+          signal: opts?.signal
+        });
+        if (!title) return null;
+        await this.storage.appendAiTitle(sessionId, title);
+        return title;
+      } finally {
+        this.autoTitleInFlight.delete(key);
+      }
+    })();
+    this.autoTitleInFlight.set(key, task);
+    return task;
+  }
   getCostSummary() {
     return this.costTracker?.getSummary() ?? null;
   }
@@ -9619,7 +8760,8 @@ function codingAgent(opts) {
       costTracking: { enabled: true },
       retry: true,
       hooks: opts.hooks,
-      mcpServers: opts.mcpServers
+      mcpServers: opts.mcpServers,
+      autoTitle: opts.autoTitle
     }
   });
 }
@@ -9641,7 +8783,8 @@ function planningAgent(opts) {
       costTracking: { enabled: true },
       retry: true,
       hooks: opts.hooks,
-      mcpServers: opts.mcpServers
+      mcpServers: opts.mcpServers,
+      autoTitle: opts.autoTitle
     }
   });
 }
@@ -9664,6 +8807,7 @@ function reviewAgent(opts) {
       retry: true,
       hooks: opts.hooks,
       mcpServers: opts.mcpServers,
+      autoTitle: opts.autoTitle,
       webSearch: {
         search: async (query) => {
           try {
@@ -10161,18 +9305,18 @@ var FileMemoryProvider = class {
       return "";
     }
   }
-  async loadEntry(path6) {
-    const fullPath = path6.startsWith(this.dir) ? path6 : this.dir + path6;
+  async loadEntry(path2) {
+    const fullPath = path2.startsWith(this.dir) ? path2 : this.dir + path2;
     try {
       const raw = await this.fs.readFile(fullPath);
       const fm = parseFrontmatter2(raw);
       const stat2 = await this.fs.stat(fullPath).catch(() => null);
       return {
-        name: fm.name ?? pathToName(path6),
+        name: fm.name ?? pathToName(path2),
         description: fm.description ?? "",
         type: fm.type ?? "project",
         content: fm.rest,
-        path: path6.startsWith(this.dir) ? path6.slice(this.dir.length) : path6,
+        path: path2.startsWith(this.dir) ? path2.slice(this.dir.length) : path2,
         updatedAt: stat2?.modifiedAt?.toISOString()
       };
     } catch {
@@ -10187,8 +9331,8 @@ var FileMemoryProvider = class {
     await this.fs.writeFile(fullPath, content);
     await this.rebuildIndex();
   }
-  async removeEntry(path6) {
-    const fullPath = path6.startsWith(this.dir) ? path6 : this.dir + path6;
+  async removeEntry(path2) {
+    const fullPath = path2.startsWith(this.dir) ? path2 : this.dir + path2;
     try {
       await this.fs.deleteFile(fullPath);
     } catch {
@@ -10237,20 +9381,14 @@ export {
   LocalFs,
   LocalComputer,
   SandboxedLocalComputer,
-  SpritesFs,
-  SpritesComputer,
-  DockerFs,
-  DockerComputer,
-  E2BFs,
-  E2BComputer,
-  FreestyleFs,
-  FreestyleComputer,
   UnsandboxedLocal,
   LocalSandbox,
-  SpritesSandbox,
-  DockerSandbox,
-  E2BSandbox,
-  FreestyleSandbox,
+  DEFAULT_AUTO_TITLE_MAX_INPUT_CHARS,
+  DEFAULT_AUTO_TITLE_SYSTEM_PROMPT,
+  extractTitleSeedText,
+  extractTitleFromResponse,
+  generateAutoTitle,
+  normalizeTitle,
   createCheckpointState,
   FileCheckpointManager,
   runPreToolUseHooks,
@@ -10278,6 +9416,7 @@ export {
   findModelPricing,
   calculateCost,
   CostTracker,
+  SessionStorage,
   TaskStore,
   buildProjectContextSection,
   parseFrontmatter,
@@ -10362,4 +9501,4 @@ export {
   truncateIndex,
   FileMemoryProvider
 };
-//# sourceMappingURL=chunk-4HW6LN6D.js.map
+//# sourceMappingURL=chunk-6MMYCGJQ.js.map