subagent-extension-for-codex 0.2.0 → 0.3.0

package/dist/bundle/chunks/chunk-TPCNCQM7.js

@@ -0,0 +1,970 @@
+import { createRequire as __bundleCreateRequire } from "node:module"; const require = __bundleCreateRequire(import.meta.url);
+import {
+  DefaultLogger,
+  DrizzleQueryError,
+  NoopLogger,
+  SQLiteAsyncDatabase,
+  SQLiteAsyncPreparedQuery,
+  SQLiteAsyncSession,
+  SQLiteAsyncTransaction,
+  SQLiteDialect,
+  and,
+  asc,
+  booleanFromInteger,
+  bufferFromBytes,
+  castToText,
+  count,
+  dateFromStoredMilliseconds,
+  dateFromStoredSeconds,
+  decodeEvent,
+  desc,
+  entityKind,
+  eq,
+  eventColumns,
+  events,
+  formatToMillis,
+  gt,
+  gte,
+  inArray,
+  insertEvent,
+  jitCompatCheck,
+  latestEvents,
+  logError,
+  logEvent,
+  lt,
+  lte,
+  max,
+  now,
+  packagePath,
+  readCompletedFlags,
+  readOriginalResponse,
+  readStates,
+  readTasks,
+  refineSqliteCodecs,
+  sql,
+  taskFilters,
+  taskMessages,
+  taskRead,
+  tasks,
+  withLogContext
+} from "./chunk-36LESPFG.js";
+import {
+  init_define_EXTENSION_BUILD_INFO
+} from "./chunk-FT2Y2DFZ.js";
+
+// src/service/features/tasks/storage/store.ts
+init_define_EXTENSION_BUILD_INFO();
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+
+// src/service/platform/database/database.ts
+init_define_EXTENSION_BUILD_INFO();
+import { mkdirSync as mkdirSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+
+// node_modules/drizzle-orm/node-sqlite/index.js
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/drizzle-orm/node-sqlite/codecs.js
+init_define_EXTENSION_BUILD_INFO();
+var nodeSQLiteCodecs = refineSqliteCodecs({
+  "integer:boolean": { normalize: booleanFromInteger },
+  "integer:timestamp": { normalize: dateFromStoredSeconds },
+  "integer:timestamp_ms": { normalize: dateFromStoredMilliseconds },
+  "text:json": { normalize: JSON.parse },
+  blob: { normalize: bufferFromBytes },
+  "blob:json": {
+    cast: castToText,
+    normalize: JSON.parse
+  },
+  "blob:bigint": {
+    cast: castToText,
+    normalize: BigInt
+  },
+  numeric: {
+    cast: castToText,
+    normalize: String
+  },
+  "numeric:number": { normalize: Number },
+  "numeric:bigint": {
+    cast: castToText,
+    normalize: BigInt
+  }
+});
+
+// node_modules/drizzle-orm/node-sqlite/session.js
+init_define_EXTENSION_BUILD_INFO();
+var NodeSQLiteSession = class extends SQLiteAsyncSession {
+  client;
+  relations;
+  options;
+  static [entityKind] = "SQLJsSession";
+  logger;
+  constructor(client, dialect, relations, options = {}) {
+    super(dialect, "sync");
+    this.client = client;
+    this.relations = relations;
+    this.options = options;
+    this.logger = options.logger ?? new NoopLogger();
+  }
+  prepareQuery(query, mode, _prepare, executeMethod, mapper, queryMetadata) {
+    let stmt;
+    try {
+      stmt = this.client.prepare(query.sql);
+    } catch (e) {
+      throw new DrizzleQueryError(query.sql, this.options.paramsInErrors ? query.params : void 0, e);
+    }
+    return new SQLiteAsyncPreparedQuery("sync", executeMethod, {
+      all: (params) => {
+        stmt.setReturnArrays(mode === "arrays");
+        const res = stmt.all(...params);
+        if (mode === "objects") return res.map((row) => ({ ...row }));
+        return res;
+      },
+      get: (params) => {
+        stmt.setReturnArrays(mode === "arrays");
+        const res = stmt.get(...params);
+        if (res && mode === "objects") return { ...res };
+        return res;
+      },
+      run: (params) => {
+        stmt.setReturnArrays(false);
+        return stmt.run(...params);
+      }
+    }, query, mapper, mode, this.logger, void 0, queryMetadata, void 0, this.options.paramsInErrors);
+  }
+  transaction(transaction, config = {}) {
+    if (config?.behavior === "concurrent") throw new Error("Concurrent transactions are not supported by driver");
+    const tx = new NodeSQLiteTransaction("sync", this.dialect, this, this.relations);
+    this.run(sql.raw(`begin${config.behavior ? ` ${config.behavior}` : ""}`));
+    try {
+      const result = transaction(tx);
+      this.run(sql`commit`);
+      return result;
+    } catch (err) {
+      try {
+        this.run(sql`rollback`);
+      } catch {
+      }
+      throw err;
+    }
+  }
+};
+var NodeSQLiteTransaction = class NodeSQLiteTransaction2 extends SQLiteAsyncTransaction {
+  static [entityKind] = "SQLJsTransaction";
+  transaction(transaction) {
+    const savepointName = `sp${this.nestedIndex + 1}`;
+    const tx = new NodeSQLiteTransaction2("sync", this.dialect, this.session, this._.relations, this.nestedIndex + 1);
+    tx.run(sql.raw(`savepoint ${savepointName}`));
+    try {
+      const result = transaction(tx);
+      tx.run(sql.raw(`release savepoint ${savepointName}`));
+      return result;
+    } catch (err) {
+      try {
+        tx.run(sql.raw(`rollback to savepoint ${savepointName}`));
+      } catch {
+      }
+      throw err;
+    }
+  }
+};
+
+// node_modules/drizzle-orm/node-sqlite/driver.js
+init_define_EXTENSION_BUILD_INFO();
+import { DatabaseSync } from "node:sqlite";
+var NodeSQLiteDatabase = class extends SQLiteAsyncDatabase {
+  static [entityKind] = "NodeSQLiteDatabase";
+};
+function construct(client, config = {}) {
+  const dialect = new SQLiteDialect({
+    codecs: config.codecs ?? nodeSQLiteCodecs,
+    useJitMappers: jitCompatCheck(config.jit)
+  });
+  let logger;
+  if (config.logger === true) logger = new DefaultLogger();
+  else if (config.logger !== false) logger = config.logger;
+  const relations = config.relations ?? {};
+  const db = new NodeSQLiteDatabase("sync", dialect, new NodeSQLiteSession(client, dialect, relations, {
+    logger,
+    paramsInErrors: config.paramsInErrors
+  }), relations);
+  db.$client = client;
+  return db;
+}
+function drizzle(...params) {
+  if (params[0] === void 0 || typeof params[0] === "string") return construct(params[0] === void 0 ? new DatabaseSync(":memory:") : new DatabaseSync(params[0]), params[1]);
+  const { connection, client, ...config } = params[0];
+  if (client) return construct(client, config);
+  if (typeof connection === "object") {
+    const { path, ...options } = connection;
+    return construct(new DatabaseSync(path ?? ":memory:", options), config);
+  }
+  return construct(new DatabaseSync(connection ?? ":memory:"), config);
+}
+(function(_drizzle) {
+  function mock(config) {
+    return construct({}, config);
+  }
+  _drizzle.mock = mock;
+})(drizzle || (drizzle = {}));
+
+// src/service/platform/database/migrate.ts
+init_define_EXTENSION_BUILD_INFO();
+
+// node_modules/drizzle-orm/migrator.js
+init_define_EXTENSION_BUILD_INFO();
+import crypto from "node:crypto";
+import fs, { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+function readMigrationFiles(config) {
+  if (fs.existsSync(`${config.migrationsFolder}/meta/_journal.json`)) throw Error('We detected that you have old drizzle-kit migration folders. You must upgrade drizzle-kit and run "drizzle-kit up"');
+  const migrationFolderTo = config.migrationsFolder;
+  const migrationQueries = [];
+  const migrations = readdirSync(migrationFolderTo).map((subdir) => ({
+    path: join(migrationFolderTo, subdir, "migration.sql"),
+    name: subdir
+  })).filter((it) => existsSync(it.path));
+  migrations.sort((a, b) => a.name.localeCompare(b.name));
+  for (const migration of migrations) {
+    const migrationPath = migration.path;
+    const migrationDate = migration.name.slice(0, 14);
+    const query = fs.readFileSync(migrationPath).toString();
+    const result = query.split("--> statement-breakpoint").map((it) => {
+      return it;
+    });
+    const millis = formatToMillis(migrationDate);
+    migrationQueries.push({
+      sql: result,
+      bps: true,
+      folderMillis: millis,
+      hash: crypto.createHash("sha256").update(query).digest("hex"),
+      name: migration.name
+    });
+  }
+  return migrationQueries;
+}
+
+// src/service/platform/database/backup.ts
+init_define_EXTENSION_BUILD_INFO();
+import { mkdirSync, readdirSync as readdirSync2, rmSync } from "node:fs";
+import { basename, dirname, extname, join as join2 } from "node:path";
+var KEEP = 3;
+function backUpDatabase(client, path, lastMigration) {
+  const directory = join2(dirname(path), "backups");
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  const name = basename(path, extname(path));
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backup = join2(directory, `${name}-${lastMigration}-${stamp}.sqlite`);
+  client.prepare("VACUUM INTO ?").run(backup);
+  const stamped = new RegExp(`^${name}-.+-(\\d{4}-[\\dT-]+Z)\\.sqlite$`);
+  const backups = readdirSync2(directory).flatMap((file) => {
+    const time = file.match(stamped)?.[1];
+    return time ? [{ file, time }] : [];
+  }).sort(
+    (a, b) => b.time.localeCompare(a.time) || b.file.localeCompare(a.file)
+  );
+  for (const { file } of backups.slice(KEEP)) {
+    rmSync(join2(directory, file), { force: true });
+  }
+  return backup;
+}
+
+// src/service/platform/database/migrate.ts
+var LEDGER = "__drizzle_migrations";
+function migrate(client, folder, path) {
+  const migrations = readMigrationFiles({ migrationsFolder: folder });
+  if (!migrations.length) throw new Error(`No migrations found in ${folder}`);
+  const before = ledger(client);
+  if (before.length && path !== ":memory:" && migrations.some((m) => !before.includes(m.name))) {
+    backUpDatabase(client, path, before.at(-1));
+  }
+  client.exec("BEGIN IMMEDIATE");
+  try {
+    const versioned = client.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(LEDGER);
+    if (!versioned) {
+      const tables = client.prepare(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+      ).all();
+      if (tables.length) {
+        throw new Error(
+          `${path} was created by an unsupported earlier version. Delete its data directory to start over.`
+        );
+      }
+      client.exec(
+        `CREATE TABLE ${LEDGER}(id INTEGER PRIMARY KEY, hash TEXT NOT NULL, created_at NUMERIC, name TEXT, applied_at TEXT)`
+      );
+    }
+    const applied = new Set(ledger(client));
+    const known = new Set(migrations.map((m) => m.name));
+    const unknown = [...applied].filter((name) => !known.has(name));
+    if (unknown.length) {
+      throw new Error(
+        `${path} has migration history this build does not recognize (${unknown.join(", ")}). Use a build that includes those migrations, or delete its data directory to start over.`
+      );
+    }
+    const record = client.prepare(
+      `INSERT INTO ${LEDGER}(hash, created_at, name, applied_at) VALUES(?,?,?,?)`
+    );
+    for (const migration of migrations) {
+      if (applied.has(migration.name)) continue;
+      for (const statement of migration.sql) {
+        if (statement.trim()) client.exec(statement);
+      }
+      record.run(
+        migration.hash,
+        migration.folderMillis,
+        migration.name,
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+    }
+    client.exec("COMMIT");
+  } catch (error) {
+    client.exec("ROLLBACK");
+    throw error;
+  }
+}
+function ledger(client) {
+  const exists = client.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(LEDGER);
+  if (!exists) return [];
+  return client.prepare(`SELECT name FROM ${LEDGER} ORDER BY id`).all().map((row) => String(row.name));
+}
+
+// src/service/platform/database/database.ts
+var migrationsFolder = packagePath("migrations");
+for (const method of ["run", "all", "get", "values"]) {
+  const prototype = SQLiteAsyncPreparedQuery.prototype;
+  const execute = prototype[method];
+  if (!execute) {
+    throw new Error(
+      `Drizzle's prepared queries have no ${method} method to wrap; check the drizzle-orm upgrade.`
+    );
+  }
+  prototype[method] = function(...args) {
+    try {
+      return execute.apply(this, args);
+    } catch (error) {
+      throw error instanceof DrizzleQueryError && error.cause instanceof Error ? error.cause : error;
+    }
+  };
+}
+var BUSY_TIMEOUT_MS = 5e3;
+var SQLITE_BUSY = 5;
+function busy(error) {
+  return (error.errcode ?? 0) % 256 === SQLITE_BUSY;
+}
+function useWal(client) {
+  const deadline = Date.now() + BUSY_TIMEOUT_MS;
+  for (; ; ) {
+    try {
+      if (client.prepare("PRAGMA journal_mode").get()?.journal_mode === "wal") {
+        return;
+      }
+      client.exec("PRAGMA journal_mode=WAL");
+      return;
+    } catch (error) {
+      if (!busy(error) || Date.now() > deadline) throw error;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+    }
+  }
+}
+function thenable(value) {
+  return typeof value?.then === "function";
+}
+function transactions(client) {
+  let queued;
+  return {
+    transaction(fn) {
+      if (queued) {
+        throw new Error(
+          "A transaction is already open; run this work inside it"
+        );
+      }
+      const notifications = [];
+      queued = notifications;
+      let result;
+      client.exec("BEGIN IMMEDIATE");
+      try {
+        result = fn();
+        if (thenable(result)) {
+          throw new Error("Database transactions must be synchronous");
+        }
+        client.exec("COMMIT");
+      } catch (error) {
+        client.exec("ROLLBACK");
+        throw error;
+      } finally {
+        queued = void 0;
+      }
+      for (const notify of notifications) notify();
+      return result;
+    },
+    afterCommit(notify) {
+      if (queued) queued.push(notify);
+      else notify();
+    }
+  };
+}
+function openDatabase(path, migrations = migrationsFolder) {
+  mkdirSync2(dirname2(path), { recursive: true, mode: 448 });
+  const client = new DatabaseSync2(path, { timeout: BUSY_TIMEOUT_MS });
+  try {
+    useWal(client);
+    client.exec("PRAGMA foreign_keys=ON");
+    migrate(client, migrations, path);
+    client.exec("PRAGMA optimize=0x10002");
+  } catch (error) {
+    client.close();
+    throw error;
+  }
+  return {
+    client,
+    orm: drizzle({ client }),
+    ...transactions(client),
+    close: () => client.close()
+  };
+}
+var INCREMENTAL = 2;
+function useIncrementalVacuum(database) {
+  const { client } = database;
+  const mode = client.prepare("PRAGMA auto_vacuum").get()?.auto_vacuum;
+  if (mode === INCREMENTAL) return;
+  const started = performance.now();
+  logEvent("info", "database.vacuum_started");
+  client.exec("PRAGMA auto_vacuum=INCREMENTAL");
+  client.exec("VACUUM");
+  logEvent("info", "database.vacuum_completed", {
+    duration_ms: Math.round(performance.now() - started)
+  });
+}
+
+// src/service/features/tasks/storage/chat-events.ts
+init_define_EXTENSION_BUILD_INFO();
+function chatEvents(orm, id, after = 0, types) {
+  const chat = and(eq(events.task_id, id), eq(events.chat, true));
+  if (after > 0) {
+    const newest2 = orm.select({ id: max(events.id) }).from(events).where(chat).get();
+    if ((newest2?.id ?? 0) <= after) return [];
+  }
+  return orm.select(eventColumns).from(events).where(chat).orderBy(events.id).all().filter((row) => !types || types.includes(row.type)).map(decodeEvent);
+}
+
+// src/service/features/tasks/storage/event-storage-metrics.ts
+init_define_EXTENSION_BUILD_INFO();
+var EventStorageMetrics = class {
+  active = /* @__PURE__ */ new Map();
+  begin(taskId, turn) {
+    const counters = {
+      event_count: 0,
+      json_bytes: 0,
+      original_response_event_count: 0
+    };
+    this.active.set(taskId, counters);
+    return (status) => {
+      if (this.active.get(taskId) !== counters) return;
+      this.active.delete(taskId);
+      try {
+        logEvent("info", "task.event_storage", {
+          task_id: taskId,
+          turn,
+          status,
+          ...counters
+        });
+      } catch {
+      }
+    };
+  }
+  committed(database, taskId, serialized, originalResponse) {
+    const counters = this.active.get(taskId);
+    if (!counters) return;
+    const bytes = Buffer.byteLength(serialized, "utf8") + (originalResponse ? Buffer.byteLength(originalResponse, "utf8") : 0);
+    database.afterCommit(() => {
+      if (this.active.get(taskId) !== counters) return;
+      counters.event_count++;
+      counters.json_bytes += bytes;
+      counters.original_response_event_count += Number(
+        originalResponse !== void 0
+      );
+    });
+  }
+};
+
+// src/service/features/tasks/storage/message-store.ts
+init_define_EXTENSION_BUILD_INFO();
+var MessageStore = class {
+  constructor(database) {
+    this.database = database;
+  }
+  database;
+  get orm() {
+    return this.database.orm;
+  }
+  /** Adds messages after a task's others. */
+  add(taskId, ...messages) {
+    if (!messages.length) return;
+    const next = this.count(taskId);
+    this.orm.insert(taskMessages).values(
+      messages.map((m, index) => ({
+        task_id: taskId,
+        seq: next + index,
+        message_id: m.id,
+        message: m.message,
+        sender: m.from
+      }))
+    ).run();
+  }
+  /** How many messages a task has. */
+  count(taskId) {
+    return this.orm.select({ count: count() }).from(taskMessages).where(eq(taskMessages.task_id, taskId)).get()?.count ?? 0;
+  }
+  /** A task's messages from position `from`, and before `to` when given. */
+  list(taskId, from = 0, to) {
+    return this.orm.select({
+      id: taskMessages.message_id,
+      message: taskMessages.message,
+      from: taskMessages.sender
+    }).from(taskMessages).where(
+      and(
+        eq(taskMessages.task_id, taskId),
+        gte(taskMessages.seq, from),
+        to === void 0 ? void 0 : lt(taskMessages.seq, to)
+      )
+    ).orderBy(taskMessages.seq).all();
+  }
+  /** Which of `ids` name a task's messages. */
+  existing(taskId, ids) {
+    const rows = this.orm.select({ id: taskMessages.message_id }).from(taskMessages).where(
+      and(
+        eq(taskMessages.task_id, taskId),
+        inArray(taskMessages.message_id, ids)
+      )
+    ).all();
+    return new Set(rows.map((row) => row.id));
+  }
+};
+
+// src/service/features/tasks/storage/publish-listeners.ts
+init_define_EXTENSION_BUILD_INFO();
+function publishListeners(bus, name, args) {
+  for (const listener of bus.listeners(name)) {
+    try {
+      listener(...args);
+    } catch (error) {
+      logError("store.listener_failed", error, { listener: name });
+    }
+  }
+}
+
+// src/service/features/tasks/storage/read-metrics.ts
+init_define_EXTENSION_BUILD_INFO();
+var WINDOW_MS = 6e4;
+var SLOW_MS = 50;
+var ReadMetrics = class {
+  summaries = /* @__PURE__ */ new Map();
+  timer;
+  started = 0;
+  measure(operation, run) {
+    const started = performance.now();
+    const work = { rows: 0, tally_rows: 0 };
+    let outcome = "error";
+    try {
+      const result = run(work);
+      outcome = "success";
+      return result;
+    } finally {
+      const duration = performance.now() - started;
+      try {
+        logEvent("debug", "storage.read", {
+          operation,
+          duration_ms: duration,
+          outcome,
+          ...work
+        });
+      } catch {
+      }
+      const summary = this.summaries.get(operation) ?? {
+        count: 0,
+        total_ms: 0,
+        max_ms: 0,
+        rows: 0,
+        tally_rows: 0,
+        slow_count: 0,
+        error_count: 0
+      };
+      summary.count++;
+      summary.total_ms += duration;
+      summary.max_ms = Math.max(summary.max_ms, duration);
+      summary.rows += work.rows;
+      summary.tally_rows += work.tally_rows;
+      summary.slow_count += Number(duration >= SLOW_MS);
+      summary.error_count += Number(outcome === "error");
+      this.summaries.set(operation, summary);
+      if (!this.timer) {
+        this.started = performance.now();
+        this.timer = setTimeout(() => this.flush(), WINDOW_MS);
+        this.timer.unref();
+      }
+    }
+  }
+  rows(operation, run) {
+    return this.measure(operation, (work) => {
+      const rows = run();
+      work.rows = rows.length;
+      return rows;
+    });
+  }
+  flush() {
+    clearTimeout(this.timer);
+    this.timer = void 0;
+    try {
+      withLogContext(
+        {},
+        () => {
+          for (const [operation, summary] of this.summaries) {
+            logEvent("info", "storage.read_summary", {
+              operation,
+              ...summary,
+              window_ms: performance.now() - this.started,
+              slow_threshold_ms: SLOW_MS
+            });
+          }
+        },
+        { inherit: false }
+      );
+    } catch {
+    } finally {
+      this.summaries.clear();
+    }
+  }
+};
+
+// src/service/features/tasks/storage/store.ts
+var newest = desc(tasks.created_at);
+var PAGE = 1e3;
+var Store = class {
+  /** The shared connection, which other features' storage also uses. */
+  database;
+  messages;
+  reads = new ReadMetrics();
+  eventStorage = new EventStorageMetrics();
+  /** The tasks saved in the open transaction, with the `updated_at` to restore on rollback. */
+  saved;
+  /** The owners whose tasks the open transaction changed. */
+  changed;
+  /** Distinguishes this process's revisions from a restarted service's. */
+  bootId = randomUUID();
+  revisions = /* @__PURE__ */ new Map();
+  projectRevision = 0;
+  // Long-poll reads each listen while they wait, so there can be many.
+  bus = new EventEmitter().setMaxListeners(0);
+  constructor(path) {
+    this.database = openDatabase(path);
+    this.messages = new MessageStore(this.database);
+  }
+  beginEventStorage(taskId, turn) {
+    return this.eventStorage.begin(taskId, turn);
+  }
+  get orm() {
+    return this.database.orm;
+  }
+  /**
+   * Runs `fn` in one transaction, so the task state and events it writes
+   * commit together. Listeners hear its events only after the commit; on a
+   * rollback they hear nothing, and saved tasks get back their `updated_at`.
+   */
+  transaction(fn) {
+    if (this.saved) {
+      throw new Error("A transaction is already open; run this work inside it");
+    }
+    const saved = [];
+    this.saved = saved;
+    this.changed = /* @__PURE__ */ new Set();
+    try {
+      return this.database.transaction(() => {
+        try {
+          return fn();
+        } finally {
+          this.saved = void 0;
+          this.changed = void 0;
+        }
+      });
+    } catch (error) {
+      for (const [t, updated] of saved.reverse()) t.updated_at = updated;
+      throw error;
+    }
+  }
+  save(t) {
+    const updated = t.updated_at;
+    t.updated_at = now();
+    const body = JSON.stringify(t);
+    try {
+      this.orm.insert(tasks).values({ id: t.id, owner: t.owner, body }).onConflictDoUpdate({ target: tasks.id, set: { body } }).run();
+    } catch (error) {
+      t.updated_at = updated;
+      throw error;
+    }
+    this.saved?.push([t, updated]);
+    this.markChanged(t.owner);
+  }
+  /**
+   * Deletes a task. Its events and pending forms
+   * reference it and are deleted with it, and the service's database returns
+   * their space to the file system.
+   */
+  delete(id, owner) {
+    this.get(id, owner);
+    this.orm.delete(tasks).where(and(eq(tasks.id, id), eq(tasks.owner, owner))).run();
+    this.database.client.exec("PRAGMA incremental_vacuum");
+    this.markChanged(owner);
+  }
+  /**
+   * Announces `change` for an owner once the open transaction commits, once
+   * per transaction however many writes it holds; at once outside one.
+   * Other task storage built on this connection announces its writes here.
+   */
+  markChanged(owner) {
+    const changed = this.changed;
+    if (!changed) {
+      this.announce([owner]);
+      return;
+    }
+    if (!changed.size) this.database.afterCommit(() => this.announce(changed));
+    changed.add(owner);
+  }
+  announce(owners) {
+    for (const owner of owners) {
+      this.revisions.set(owner, (this.revisions.get(owner) ?? 0) + 1);
+      this.publish("change", owner);
+    }
+  }
+  /** Announces a change to the project list, which every owner shares. */
+  projectsChanged() {
+    this.projectRevision++;
+    this.publish("change", void 0);
+  }
+  /**
+   * A token for the state of an owner's tasks and the project list,
+   * `bootId:count`. It differs whenever either has changed, including across
+   * a restart, and the count only grows within a boot.
+   */
+  revision(owner) {
+    const count2 = (this.revisions.get(owner) ?? 0) + this.projectRevision;
+    return `${this.bootId}:${count2}`;
+  }
+  /**
+   * An owner's tasks, newest first, in a conversation or repository when
+   * given.
+   */
+  list(owner, filters) {
+    return this.reads.rows(
+      "task_list",
+      () => readTasks(this.orm, taskFilters(owner, filters), newest)
+    );
+  }
+  /**
+   * An owner's tasks matching `filters`, newest first, with their repository
+   * and whether each is a completed task the owner has read.
+   */
+  readCompletedFlags(owner, filters) {
+    return readCompletedFlags(this.orm, taskFilters(owner, filters), newest);
+  }
+  /** Every owner's tasks, newest first. */
+  all() {
+    return readTasks(this.orm, void 0, newest);
+  }
+  /** An owner's newest task in a conversation. */
+  latestInConversation(owner, conversation) {
+    return readTasks(
+      this.orm,
+      taskFilters(owner, { conversation }),
+      newest,
+      1
+    )[0];
+  }
+  /** Every owner's tasks with one of `statuses`, oldest first. */
+  withStatus(statuses) {
+    return readTasks(
+      this.orm,
+      inArray(tasks.status, statuses),
+      asc(tasks.created_at)
+    );
+  }
+  get(id, owner) {
+    const task = this.find(id, owner);
+    if (!task) throw new Error("Task not found");
+    return task;
+  }
+  /** An owner's task, or undefined when it has none with this id. */
+  find(id, owner) {
+    return readTasks(
+      this.orm,
+      and(eq(tasks.id, id), eq(tasks.owner, owner))
+    )[0];
+  }
+  event(t, type, ...args) {
+    const data = args[0] ?? {};
+    return this.writeEvent(t, type, data);
+  }
+  /** Records a provider-owned event through the explicit opaque extension path. */
+  eventOpaque(t, type, data = {}) {
+    return this.writeEvent(t, type, data);
+  }
+  writeEvent(t, type, data) {
+    const event = insertEvent(
+      this.database,
+      this.eventStorage,
+      t.id,
+      type,
+      data
+    );
+    this.database.afterCommit(() => this.publish("event", event, t.owner));
+    this.markChanged(t.owner);
+    return event;
+  }
+  /** Isolate listener failures after commit so consumers can still catch up. */
+  publish(name, ...args) {
+    publishListeners(this.bus, name, args);
+  }
+  events(id, owner, after = 0) {
+    this.get(id, owner);
+    return this.orm.select(eventColumns).from(events).where(and(eq(events.task_id, id), gt(events.id, after))).orderBy(events.id).limit(PAGE).all().map(decodeEvent);
+  }
+  /** Resolves an original response after checking task ownership. */
+  originalResponse(id, owner, responseRef) {
+    this.get(id, owner);
+    return readOriginalResponse(this.database, id, responseRef);
+  }
+  /**
+   * The id of a task's event `depth` places from its newest, so the newest
+   * `depth` events are those from it on; 0 when there are fewer than that.
+   * `depth` is at least 1: the query offsets by `depth - 1`.
+   */
+  eventWindowStart(id, depth) {
+    return this.orm.select({ id: events.id }).from(events).where(eq(events.task_id, id)).orderBy(desc(events.id)).limit(1).offset(depth - 1).get()?.id ?? 0;
+  }
+  /**
+   * The id of the `depth`th newest of a task's events after `after` and
+   * through `through`, so those events from it on are the newest `depth`;
+   * `after + 1` when there are fewer than that.
+   */
+  rangeWindowStart(id, after, through, depth) {
+    return this.orm.select({ id: events.id }).from(events).where(
+      and(
+        eq(events.task_id, id),
+        gt(events.id, after),
+        lte(events.id, through)
+      )
+    ).orderBy(desc(events.id)).limit(1).offset(depth - 1).get()?.id ?? after + 1;
+  }
+  /**
+   * What the owner has read of a task: whether it has a reply, outcome or
+   * request they haven't read, and the newest event they had read.
+   */
+  readState(id) {
+    return readStates(this.orm, eq(tasks.id, id)).get(id);
+  }
+  /** The read state of each of an owner's tasks matching `filters`, by id. */
+  readStates(owner, filters) {
+    return readStates(this.orm, taskFilters(owner, filters));
+  }
+  /**
+   * Records that the owner has read a task through event `through`, or its
+   * newest event without one. It never moves back, never passes the newest
+   * event and clears the task's unread mark.
+   */
+  markRead(t, through) {
+    const newest2 = this.lastEventId(t.id);
+    const read = Math.min(through ?? newest2, newest2);
+    this.orm.insert(taskRead).values({ task_id: t.id, through: read, unread: false }).onConflictDoUpdate({
+      target: taskRead.task_id,
+      set: { through: sql`max(${taskRead.through}, ${read})`, unread: false }
+    }).run();
+    this.markChanged(t.owner);
+  }
+  /** Marks a task unread from event `from` on; unlike `markRead`, it can move the read point back. */
+  markUnreadFrom(t, from) {
+    const through = Math.min(from - 1, this.lastEventId(t.id));
+    const mark = { through, unread: false };
+    this.orm.insert(taskRead).values({ task_id: t.id, ...mark }).onConflictDoUpdate({ target: taskRead.task_id, set: mark }).run();
+    this.markChanged(t.owner);
+  }
+  /** Marks a task unread until the owner next sees it. */
+  markUnread(t) {
+    this.orm.insert(taskRead).values({ task_id: t.id, through: 0, unread: true }).onConflictDoUpdate({ target: taskRead.task_id, set: { unread: true } }).run();
+    this.markChanged(t.owner);
+  }
+  /** The id of a task's `task.turn_ended` event for a turn; absent until it ends. */
+  turnEnded(id, turn) {
+    return this.orm.select({ id: events.id }).from(events).where(
+      and(
+        eq(events.task_id, id),
+        eq(events.type, "task.turn_ended"),
+        eq(sql`json_extract(${events.data}, '$.turn')`, turn)
+      )
+    ).orderBy(events.id).limit(1).get()?.id;
+  }
+  /** A task's first event after `after` with one of `types`. */
+  nextEventOfType(id, after, types) {
+    return this.orm.select({ id: events.id, type: events.type }).from(events).where(
+      and(
+        eq(events.task_id, id),
+        gt(events.id, after),
+        inArray(events.type, types)
+      )
+    ).orderBy(events.id).limit(1).get();
+  }
+  /**
+   * A task's events after `after`, and before `before` when given, a page at a
+   * time. Internal: callers check the task's owner first.
+   */
+  taskEvents(id, after, before) {
+    return this.orm.select(eventColumns).from(events).where(
+      and(
+        eq(events.task_id, id),
+        gt(events.id, after),
+        before === void 0 ? void 0 : lt(events.id, before)
+      )
+    ).orderBy(events.id).limit(PAGE).all().map(decodeEvent);
+  }
+  recentEvents(id, owner) {
+    this.get(id, owner);
+    return this.orm.select(eventColumns).from(events).where(eq(events.task_id, id)).orderBy(desc(events.id)).limit(200).all().reverse().map(decodeEvent);
+  }
+  /** The id of the latest event, or of a task's latest one; 0 before any. */
+  lastEventId(id) {
+    const row = this.orm.select({ id: max(events.id) }).from(events).where(id === void 0 ? void 0 : eq(events.task_id, id)).get();
+    return row?.id ?? 0;
+  }
+  /** A task's latest event of a type, such as its latest `agent.reply`. */
+  latestEvent(id, type) {
+    const row = this.orm.select(eventColumns).from(events).where(and(eq(events.task_id, id), eq(events.type, type))).orderBy(desc(events.id)).limit(1).get();
+    return row && decodeEvent(row);
+  }
+  /** The latest event of `type` in each of an owner's tasks matching `filters`. */
+  latestEvents(owner, type, filters) {
+    return latestEvents(this.orm, taskFilters(owner, filters), type);
+  }
+  /** Every event of the given types for a task, in order, with no page limit. */
+  eventsOfTypes(id, types) {
+    return this.orm.select(eventColumns).from(events).where(and(eq(events.task_id, id), inArray(events.type, types))).orderBy(events.id).all().map(decodeEvent);
+  }
+  /** The events Chat shows, in order, or none when none is newer than `after`. */
+  chatEvents(id, after = 0) {
+    return this.reads.rows("chat", () => chatEvents(this.orm, id, after));
+  }
+  /** A task's Chat events of `types`, in order, for its conversation. */
+  conversationEvents(id, types) {
+    return chatEvents(this.orm, id, 0, types);
+  }
+  close() {
+    this.reads.flush();
+    this.database.close();
+  }
+};
+
+export {
+  useIncrementalVacuum,
+  Store
+};
+//# sourceMappingURL=chunk-TPCNCQM7.js.map