octoflow-core 1.0.0

package/dist/subpath-stores.cjs

@@ -0,0 +1,2288 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/subpath-stores.ts
+var subpath_stores_exports = {};
+__export(subpath_stores_exports, {
+  InMemoryMemoryStore: () => InMemoryMemoryStore,
+  InMemorySessionStore: () => InMemorySessionStore,
+  InMemoryTaskStore: () => InMemoryTaskStore,
+  SqliteMemoryStore: () => SqliteMemoryStore,
+  SqliteSessionStore: () => SqliteSessionStore,
+  SqliteTaskStore: () => SqliteTaskStore,
+  createMemoryStore: () => createMemoryStore,
+  createSessionStore: () => createSessionStore,
+  createTaskStore: () => createTaskStore
+});
+module.exports = __toCommonJS(subpath_stores_exports);
+
+// src/utils/octoflow-home.ts
+var import_node_os = require("node:os");
+var import_node_path = __toESM(require("node:path"), 1);
+var OCTOFLOW_HOME_ENV = "OCTOFLOW_HOME";
+var DB_FILES = {
+  approvals: "approvals.sqlite",
+  brain: "brain.sqlite",
+  memory: "memory.sqlite",
+  "session-memory": "session-memory.sqlite",
+  sessions: "sessions.sqlite",
+  tasks: "tasks.sqlite"
+};
+function expandUserPath(value, options = {}) {
+  const home = options.home ?? (0, import_node_os.homedir)();
+  if (value === "~") return home;
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return import_node_path.default.join(home, value.slice(2));
+  }
+  return value;
+}
+function resolveUserPath(value, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  return import_node_path.default.resolve(cwd, expandUserPath(value, options));
+}
+function getOctoFlowHome(options = {}) {
+  const configured = (options.env ?? process.env)[OCTOFLOW_HOME_ENV];
+  if (configured && configured.trim().length > 0) {
+    return resolveUserPath(configured, options);
+  }
+  return import_node_path.default.join(options.home ?? (0, import_node_os.homedir)(), ".octoflow");
+}
+function getOctoFlowPath(segments = [], options = {}) {
+  return import_node_path.default.join(getOctoFlowHome(options), ...segments);
+}
+function getOctoFlowDbDir(options = {}) {
+  return getOctoFlowPath(["db"], options);
+}
+function getOctoFlowDbPath(name, options = {}) {
+  return import_node_path.default.join(getOctoFlowDbDir(options), DB_FILES[name]);
+}
+
+// src/utils/sync-promise.ts
+function syncPromise(fn) {
+  try {
+    return Promise.resolve(fn());
+  } catch (err) {
+    return Promise.reject(err instanceof Error ? err : new Error(String(err)));
+  }
+}
+
+// src/utils/time.ts
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/adapters/data/memory/shared.ts
+var VALID_SCOPES = /* @__PURE__ */ new Set(["global", "context", "tenant"]);
+function toCompositeKey(scope, scopeId, key) {
+  return `${scope}\0${scopeId}\0${key}`;
+}
+function normalizeReadScope(options = {}) {
+  const scope = options.scope ?? "global";
+  if (!VALID_SCOPES.has(scope)) {
+    throw new Error(`[octoflow] invalid memory scope: '${scope}'`);
+  }
+  return { scope, scopeId: options.scopeId ?? "" };
+}
+function normalizeListScope(options = {}) {
+  if (options.scope === void 0) {
+    return {
+      offset: Math.max(0, options.offset ?? 0),
+      prefix: options.prefix,
+      limit: options.limit
+    };
+  }
+  const { scope, scopeId } = normalizeReadScope(options);
+  return {
+    scope,
+    scopeId,
+    offset: Math.max(0, options.offset ?? 0),
+    prefix: options.prefix,
+    limit: options.limit
+  };
+}
+function normalizeWriteScope(options = {}) {
+  const { scope, scopeId } = normalizeReadScope(options);
+  const expiresAt = resolveExpiry(options.ttlMs);
+  return {
+    scope,
+    scopeId,
+    metadata: options.metadata,
+    expiresAt
+  };
+}
+function resolveExpiry(ttlMs) {
+  if (ttlMs === void 0) return void 0;
+  if (!Number.isFinite(ttlMs)) {
+    throw new Error(
+      `[octoflow] memory ttlMs must be finite; received '${String(ttlMs)}'`
+    );
+  }
+  const clamped = Math.max(0, Math.floor(ttlMs));
+  return new Date(Date.now() + clamped).toISOString();
+}
+function isExpired(expiresAt, now = nowIso()) {
+  return expiresAt !== void 0 && expiresAt <= now;
+}
+function serializeValue(value) {
+  const serialized = JSON.stringify(value);
+  if (serialized === void 0) {
+    throw new Error("[octoflow] memory value must be JSON-serializable");
+  }
+  return serialized;
+}
+function deserializeValue(valueJson) {
+  return JSON.parse(valueJson);
+}
+function serializeMetadata(metadata) {
+  if (metadata === void 0) return null;
+  return serializeValue(metadata);
+}
+function deserializeMetadata(metadataJson) {
+  if (!metadataJson) return void 0;
+  return JSON.parse(metadataJson);
+}
+
+// src/adapters/data/memory/in-memory.ts
+var InMemoryMemoryStore = class {
+  entries = /* @__PURE__ */ new Map();
+  get(key, options = {}) {
+    const { scope, scopeId } = normalizeReadScope(options);
+    const id = toCompositeKey(scope, scopeId, key);
+    const entry = this.entries.get(id);
+    if (!entry) return Promise.resolve(null);
+    const now = nowIso();
+    if (isExpired(entry.expiresAt, now)) {
+      this.entries.delete(id);
+      return Promise.resolve(null);
+    }
+    return Promise.resolve(deserializeValue(entry.valueJson));
+  }
+  set(key, value, options = {}) {
+    return syncPromise(() => {
+      const { scope, scopeId, metadata, expiresAt } = normalizeWriteScope(options);
+      const id = toCompositeKey(scope, scopeId, key);
+      const existing = this.entries.get(id);
+      const timestamp = nowIso();
+      this.entries.set(id, {
+        key,
+        scope,
+        scopeId,
+        valueJson: serializeValue(value),
+        metadataJson: metadata === void 0 ? null : JSON.stringify(metadata),
+        createdAt: existing?.createdAt ?? timestamp,
+        updatedAt: timestamp,
+        expiresAt
+      });
+    });
+  }
+  delete(key, options = {}) {
+    return syncPromise(() => {
+      const { scope, scopeId } = normalizeReadScope(options);
+      return this.entries.delete(toCompositeKey(scope, scopeId, key));
+    });
+  }
+  list(options = {}) {
+    const normalized = normalizeListScope(options);
+    const now = nowIso();
+    const prefix = normalized.prefix;
+    const all = [];
+    for (const [id, entry] of this.entries) {
+      if (isExpired(entry.expiresAt, now)) {
+        this.entries.delete(id);
+        continue;
+      }
+      if (normalized.scope && (entry.scope !== normalized.scope || entry.scopeId !== normalized.scopeId)) {
+        continue;
+      }
+      if (prefix && !entry.key.startsWith(prefix)) continue;
+      all.push({
+        key: entry.key,
+        scope: entry.scope,
+        scopeId: entry.scopeId || void 0,
+        value: deserializeValue(entry.valueJson),
+        metadata: deserializeMetadata(entry.metadataJson),
+        createdAt: entry.createdAt,
+        updatedAt: entry.updatedAt,
+        expiresAt: entry.expiresAt
+      });
+    }
+    all.sort((a, b) => {
+      if (a.scope !== b.scope) return a.scope.localeCompare(b.scope);
+      if ((a.scopeId ?? "") !== (b.scopeId ?? "")) {
+        return (a.scopeId ?? "").localeCompare(b.scopeId ?? "");
+      }
+      return a.key.localeCompare(b.key);
+    });
+    const sliced = all.slice(normalized.offset);
+    if (normalized.limit === void 0) return Promise.resolve(sliced);
+    return Promise.resolve(sliced.slice(0, Math.max(0, normalized.limit)));
+  }
+  async has(key, options = {}) {
+    return await this.get(key, options) !== null;
+  }
+};
+
+// src/adapters/data/sqlite-helpers.ts
+var import_node_fs = require("node:fs");
+var import_node_path2 = require("node:path");
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+function createSqliteDb(options = {}) {
+  const dbPath = options.path ?? ":memory:";
+  let db;
+  if (dbPath !== ":memory:") {
+    const absolutePath = (0, import_node_path2.isAbsolute)(dbPath) ? dbPath : (0, import_node_path2.join)(process.cwd(), dbPath);
+    const dir = (0, import_node_path2.dirname)(absolutePath);
+    if (!(0, import_node_fs.existsSync)(dir)) {
+      (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+    }
+    db = new import_better_sqlite3.default(absolutePath);
+  } else {
+    db = new import_better_sqlite3.default(":memory:");
+  }
+  db.pragma(`busy_timeout = ${options.busyTimeoutMs ?? 5e3}`);
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  return db;
+}
+
+// src/adapters/data/memory/sqlite.ts
+var SqliteMemoryStore = class {
+  db;
+  constructor(options = {}) {
+    this.db = createSqliteDb(options);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memory (
+        key        TEXT NOT NULL,
+        scope      TEXT NOT NULL DEFAULT 'global',
+        scope_id   TEXT NOT NULL DEFAULT '',
+        value      TEXT NOT NULL,
+        metadata   TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        expires_at TEXT,
+        PRIMARY KEY (key, scope, scope_id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_memory_scope
+        ON memory (scope, scope_id);
+
+      CREATE INDEX IF NOT EXISTS idx_memory_expires
+        ON memory (expires_at) WHERE expires_at IS NOT NULL;
+    `);
+  }
+  get(key, options = {}) {
+    return syncPromise(() => {
+      const { scope, scopeId } = normalizeReadScope(options);
+      const now = nowIso();
+      this.db.prepare(
+        "DELETE FROM memory WHERE key = ? AND scope = ? AND scope_id = ? AND expires_at IS NOT NULL AND expires_at <= ?"
+      ).run(key, scope, scopeId, now);
+      const row = this.db.prepare(
+        "SELECT value FROM memory WHERE key = ? AND scope = ? AND scope_id = ?"
+      ).get(key, scope, scopeId);
+      return row ? deserializeValue(row.value) : null;
+    });
+  }
+  set(key, value, options = {}) {
+    return syncPromise(() => {
+      const { scope, scopeId, metadata, expiresAt } = normalizeWriteScope(options);
+      const timestamp = nowIso();
+      this.db.prepare(
+        `
+        INSERT INTO memory (key, scope, scope_id, value, metadata, created_at, updated_at, expires_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT (key, scope, scope_id) DO UPDATE SET
+          value = excluded.value,
+          metadata = excluded.metadata,
+          updated_at = excluded.updated_at,
+          expires_at = excluded.expires_at
+      `
+      ).run(
+        key,
+        scope,
+        scopeId,
+        serializeValue(value),
+        serializeMetadata(metadata),
+        timestamp,
+        timestamp,
+        expiresAt ?? null
+      );
+    });
+  }
+  delete(key, options = {}) {
+    return syncPromise(() => {
+      const { scope, scopeId } = normalizeReadScope(options);
+      const result = this.db.prepare(
+        "DELETE FROM memory WHERE key = ? AND scope = ? AND scope_id = ?"
+      ).run(key, scope, scopeId);
+      return result.changes > 0;
+    });
+  }
+  list(options = {}) {
+    return syncPromise(() => {
+      const normalized = normalizeListScope(options);
+      const clauses = ["(expires_at IS NULL OR expires_at > ?)"];
+      const params = [nowIso()];
+      if (normalized.scope) {
+        clauses.push("scope = ?");
+        params.push(normalized.scope);
+        clauses.push("scope_id = ?");
+        params.push(normalized.scopeId ?? "");
+      }
+      if (normalized.prefix) {
+        clauses.push("key LIKE ?");
+        params.push(`${normalized.prefix}%`);
+      }
+      let sql = `
+        SELECT key, scope, scope_id, value, metadata, created_at, updated_at, expires_at
+        FROM memory
+        WHERE ${clauses.join(" AND ")}
+        ORDER BY scope, scope_id, key
+      `;
+      if (normalized.limit !== void 0) {
+        sql += " LIMIT ?";
+        params.push(Math.max(0, normalized.limit));
+        sql += " OFFSET ?";
+        params.push(normalized.offset);
+      } else if (normalized.offset > 0) {
+        sql += " LIMIT -1 OFFSET ?";
+        params.push(normalized.offset);
+      }
+      const rows = this.db.prepare(sql).all(...params);
+      return rows.map((row) => ({
+        key: row.key,
+        scope: row.scope,
+        scopeId: row.scope_id || void 0,
+        value: deserializeValue(row.value),
+        metadata: deserializeMetadata(row.metadata),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        expiresAt: row.expires_at ?? void 0
+      }));
+    });
+  }
+  async has(key, options = {}) {
+    return await this.get(key, options) !== null;
+  }
+  close() {
+    return syncPromise(() => {
+      this.db.close();
+    });
+  }
+};
+
+// src/adapters/data/memory/factory.ts
+function createMemoryStore(options = {}) {
+  if (options.type === "memory") {
+    return new InMemoryMemoryStore();
+  }
+  const path2 = options.path ?? getOctoFlowDbPath("memory");
+  return new SqliteMemoryStore({ path: path2, busyTimeoutMs: options.busyTimeoutMs });
+}
+
+// src/adapters/data/session-store/in-memory.ts
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+var InMemorySessionStore = class {
+  sessions = /* @__PURE__ */ new Map();
+  contextIndex = /* @__PURE__ */ new Map();
+  gcTimer;
+  contextKey(contextId, tenant) {
+    return `${tenant ?? ""}\0${contextId}`;
+  }
+  createSession(input) {
+    return syncPromise(() => {
+      const key = this.contextKey(input.contextId, input.tenant);
+      if (this.contextIndex.has(key)) {
+        const existing = this.sessions.get(this.contextIndex.get(key));
+        if (existing) {
+          return { ...existing };
+        }
+      }
+      const now = nowIso();
+      const record = {
+        sessionId: import_node_crypto.default.randomUUID(),
+        contextId: input.contextId,
+        tenant: input.tenant,
+        currentBackend: input.currentBackend,
+        cliSessionId: input.cliSessionId,
+        switchCount: 0,
+        backendHistory: [
+          {
+            backend: input.currentBackend,
+            cliSessionId: input.cliSessionId,
+            switchedAt: now,
+            reason: "initial"
+          }
+        ],
+        policySnapshot: input.policySnapshot,
+        priority: input.priority,
+        model: input.model,
+        systemPrompt: input.systemPrompt,
+        createdAt: now,
+        lastModified: now
+      };
+      this.sessions.set(record.sessionId, record);
+      this.contextIndex.set(key, record.sessionId);
+      return { ...record };
+    });
+  }
+  getSession(sessionId) {
+    return syncPromise(() => {
+      const record = this.sessions.get(sessionId);
+      return record ? { ...record } : void 0;
+    });
+  }
+  getSessionByContext(contextId, tenant) {
+    return syncPromise(() => {
+      const key = this.contextKey(contextId, tenant);
+      const sessionId = this.contextIndex.get(key);
+      if (!sessionId) {
+        return void 0;
+      }
+      const record = this.sessions.get(sessionId);
+      return record ? { ...record } : void 0;
+    });
+  }
+  updateSession(sessionId, update) {
+    return syncPromise(() => {
+      const existing = this.sessions.get(sessionId);
+      if (!existing) {
+        throw new Error(`Session not found: ${sessionId}`);
+      }
+      const updated = {
+        ...existing,
+        ...update,
+        sessionId: existing.sessionId,
+        contextId: existing.contextId,
+        createdAt: existing.createdAt,
+        lastModified: nowIso()
+      };
+      this.sessions.set(sessionId, updated);
+      return { ...updated };
+    });
+  }
+  listSessions(options = {}) {
+    return syncPromise(() => {
+      const limit = Math.max(1, options.limit ?? 50);
+      const offset = Math.max(
+        0,
+        Number.parseInt(options.cursor ?? "0", 10) || 0
+      );
+      let all = [...this.sessions.values()];
+      if (options.tenant !== void 0) {
+        all = all.filter((s) => s.tenant === options.tenant);
+      }
+      all.sort((a, b) => b.lastModified.localeCompare(a.lastModified));
+      const page = all.slice(offset, offset + limit);
+      return {
+        sessions: page.map((s) => ({ ...s })),
+        nextCursor: offset + limit < all.length ? String(offset + limit) : null,
+        pageSize: limit,
+        totalSize: all.length
+      };
+    });
+  }
+  deleteSession(sessionId) {
+    return syncPromise(() => {
+      const existing = this.sessions.get(sessionId);
+      if (!existing) {
+        return false;
+      }
+      this.sessions.delete(sessionId);
+      this.contextIndex.delete(
+        this.contextKey(existing.contextId, existing.tenant)
+      );
+      return true;
+    });
+  }
+  deleteExpired(cutoffIso) {
+    return syncPromise(() => {
+      let count = 0;
+      for (const [sessionId, record] of this.sessions) {
+        if (record.lastModified < cutoffIso) {
+          this.sessions.delete(sessionId);
+          this.contextIndex.delete(
+            this.contextKey(record.contextId, record.tenant)
+          );
+          count++;
+        }
+      }
+      return count;
+    });
+  }
+  startGc(ttlMs, intervalMs) {
+    this.stopGc();
+    this.gcTimer = setInterval(() => {
+      const cutoff = new Date(Date.now() - ttlMs).toISOString();
+      this.deleteExpired(cutoff).catch((err) => {
+        process.stderr.write(
+          `[octoflow] session GC error: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      });
+    }, intervalMs);
+    if (this.gcTimer && typeof this.gcTimer === "object" && "unref" in this.gcTimer) {
+      this.gcTimer.unref();
+    }
+  }
+  stopGc() {
+    if (this.gcTimer !== void 0) {
+      clearInterval(this.gcTimer);
+      this.gcTimer = void 0;
+    }
+  }
+  close() {
+    return syncPromise(() => {
+      this.stopGc();
+    });
+  }
+};
+
+// src/adapters/data/session-store/sqlite.ts
+var import_node_crypto2 = __toESM(require("node:crypto"), 1);
+var import_node_fs2 = require("node:fs");
+var import_node_path3 = require("node:path");
+var import_better_sqlite32 = __toESM(require("better-sqlite3"), 1);
+var SqliteSessionStore = class {
+  db;
+  gcTimer;
+  constructor(options = {}) {
+    const dbPath = options.path ?? ":memory:";
+    if (dbPath !== ":memory:") {
+      const absolutePath = (0, import_node_path3.isAbsolute)(dbPath) ? dbPath : (0, import_node_path3.join)(process.cwd(), dbPath);
+      const dir = (0, import_node_path3.dirname)(absolutePath);
+      if (!(0, import_node_fs2.existsSync)(dir)) {
+        (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+      }
+      this.db = new import_better_sqlite32.default(absolutePath);
+    } else {
+      this.db = new import_better_sqlite32.default(":memory:");
+    }
+    this.db.pragma(`busy_timeout = ${options.busyTimeoutMs ?? 5e3}`);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.pragma("foreign_keys = ON");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        session_id TEXT PRIMARY KEY,
+        context_id TEXT NOT NULL,
+        tenant TEXT,
+        current_backend TEXT NOT NULL,
+        cli_session_id TEXT,
+        switch_count INTEGER NOT NULL DEFAULT 0,
+        backend_history_json TEXT NOT NULL DEFAULT '[]',
+        policy_snapshot_json TEXT NOT NULL DEFAULT '{}',
+        priority_json TEXT NOT NULL DEFAULT '[]',
+        model TEXT,
+        system_prompt TEXT,
+        created_at TEXT NOT NULL,
+        last_modified TEXT NOT NULL
+      );
+
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_context
+        ON sessions (context_id, COALESCE(tenant, ''));
+      CREATE INDEX IF NOT EXISTS idx_sessions_tenant
+        ON sessions (tenant);
+      CREATE INDEX IF NOT EXISTS idx_sessions_last_modified
+        ON sessions (last_modified DESC);
+    `);
+  }
+  createSession(input) {
+    return syncPromise(() => {
+      const existing = this.getSessionByContextSync(
+        input.contextId,
+        input.tenant
+      );
+      if (existing) {
+        return existing;
+      }
+      const now = nowIso();
+      const record = {
+        sessionId: import_node_crypto2.default.randomUUID(),
+        contextId: input.contextId,
+        tenant: input.tenant,
+        currentBackend: input.currentBackend,
+        cliSessionId: input.cliSessionId,
+        switchCount: 0,
+        backendHistory: [
+          {
+            backend: input.currentBackend,
+            cliSessionId: input.cliSessionId,
+            switchedAt: now,
+            reason: "initial"
+          }
+        ],
+        policySnapshot: input.policySnapshot,
+        priority: input.priority,
+        model: input.model,
+        systemPrompt: input.systemPrompt,
+        createdAt: now,
+        lastModified: now
+      };
+      this.db.prepare(
+        `
+        INSERT INTO sessions (
+          session_id, context_id, tenant, current_backend, cli_session_id,
+          switch_count, backend_history_json, policy_snapshot_json, priority_json,
+          model, system_prompt, created_at, last_modified
+        ) VALUES (
+          @session_id, @context_id, @tenant, @current_backend, @cli_session_id,
+          @switch_count, @backend_history_json, @policy_snapshot_json, @priority_json,
+          @model, @system_prompt, @created_at, @last_modified
+        )
+      `
+      ).run(this.toRow(record));
+      return record;
+    });
+  }
+  getSessionSync(sessionId) {
+    const row = this.db.prepare("SELECT * FROM sessions WHERE session_id = ?").get(sessionId);
+    return row ? this.fromRow(row) : void 0;
+  }
+  getSessionByContextSync(contextId, tenant) {
+    const sql = tenant === void 0 ? `SELECT * FROM sessions WHERE context_id = ? AND (tenant IS NULL OR tenant = '')` : "SELECT * FROM sessions WHERE context_id = ? AND tenant = ?";
+    const params = [contextId];
+    if (tenant !== void 0) {
+      params.push(tenant);
+    }
+    const row = this.db.prepare(sql).get(...params);
+    return row ? this.fromRow(row) : void 0;
+  }
+  getSession(sessionId) {
+    return syncPromise(() => this.getSessionSync(sessionId));
+  }
+  getSessionByContext(contextId, tenant) {
+    return syncPromise(() => this.getSessionByContextSync(contextId, tenant));
+  }
+  updateSession(sessionId, update) {
+    return syncPromise(() => {
+      const existing = this.getSessionSync(sessionId);
+      if (!existing) {
+        throw new Error(`Session not found: ${sessionId}`);
+      }
+      const updated = {
+        ...existing,
+        ...update,
+        sessionId: existing.sessionId,
+        contextId: existing.contextId,
+        createdAt: existing.createdAt,
+        lastModified: nowIso()
+      };
+      this.db.prepare(
+        `
+        UPDATE sessions SET
+          current_backend = @current_backend,
+          cli_session_id = @cli_session_id,
+          switch_count = @switch_count,
+          backend_history_json = @backend_history_json,
+          policy_snapshot_json = @policy_snapshot_json,
+          priority_json = @priority_json,
+          model = @model,
+          system_prompt = @system_prompt,
+          last_modified = @last_modified
+        WHERE session_id = @session_id
+      `
+      ).run(this.toRow(updated));
+      return updated;
+    });
+  }
+  listSessions(options = {}) {
+    return syncPromise(() => {
+      const limit = Math.max(1, options.limit ?? 50);
+      const offset = Math.max(
+        0,
+        Number.parseInt(options.cursor ?? "0", 10) || 0
+      );
+      const whereParts = [];
+      const params = { limit, offset };
+      if (options.tenant !== void 0) {
+        whereParts.push("tenant = @tenant");
+        params.tenant = options.tenant;
+      }
+      const whereSql = whereParts.length > 0 ? `WHERE ${whereParts.join(" AND ")}` : "";
+      const countRow = this.db.prepare(`SELECT COUNT(*) AS count FROM sessions ${whereSql}`).get(params);
+      const rows = this.db.prepare(
+        `
+        SELECT * FROM sessions ${whereSql}
+        ORDER BY last_modified DESC
+        LIMIT @limit OFFSET @offset
+      `
+      ).all(params);
+      return {
+        sessions: rows.map((row) => this.fromRow(row)),
+        nextCursor: offset + limit < countRow.count ? String(offset + limit) : null,
+        pageSize: limit,
+        totalSize: countRow.count
+      };
+    });
+  }
+  deleteSession(sessionId) {
+    return syncPromise(() => {
+      const result = this.db.prepare("DELETE FROM sessions WHERE session_id = ?").run(sessionId);
+      return result.changes > 0;
+    });
+  }
+  deleteExpired(cutoffIso) {
+    return syncPromise(() => {
+      const result = this.db.prepare("DELETE FROM sessions WHERE last_modified < ?").run(cutoffIso);
+      return result.changes;
+    });
+  }
+  startGc(ttlMs, intervalMs) {
+    this.stopGc();
+    this.gcTimer = setInterval(() => {
+      const cutoff = new Date(Date.now() - ttlMs).toISOString();
+      void this.deleteExpired(cutoff).catch((err) => {
+        process.stderr.write(
+          `[octoflow] session GC error: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      });
+    }, intervalMs);
+    if (this.gcTimer && typeof this.gcTimer === "object" && "unref" in this.gcTimer) {
+      this.gcTimer.unref();
+    }
+  }
+  stopGc() {
+    if (this.gcTimer !== void 0) {
+      clearInterval(this.gcTimer);
+      this.gcTimer = void 0;
+    }
+  }
+  close() {
+    return syncPromise(() => {
+      this.stopGc();
+      this.db.close();
+    });
+  }
+  toRow(record) {
+    return {
+      session_id: record.sessionId,
+      context_id: record.contextId,
+      tenant: record.tenant ?? null,
+      current_backend: record.currentBackend,
+      cli_session_id: record.cliSessionId ?? null,
+      switch_count: record.switchCount,
+      backend_history_json: JSON.stringify(record.backendHistory),
+      policy_snapshot_json: JSON.stringify(record.policySnapshot),
+      priority_json: JSON.stringify(record.priority),
+      model: record.model ?? null,
+      system_prompt: record.systemPrompt ?? null,
+      created_at: record.createdAt,
+      last_modified: record.lastModified
+    };
+  }
+  fromRow(row) {
+    return {
+      sessionId: row.session_id,
+      contextId: row.context_id,
+      tenant: row.tenant ?? void 0,
+      currentBackend: row.current_backend,
+      cliSessionId: row.cli_session_id ?? void 0,
+      switchCount: row.switch_count,
+      backendHistory: JSON.parse(
+        row.backend_history_json
+      ),
+      policySnapshot: JSON.parse(
+        row.policy_snapshot_json
+      ),
+      priority: JSON.parse(row.priority_json),
+      model: row.model ?? void 0,
+      systemPrompt: row.system_prompt ?? void 0,
+      createdAt: row.created_at,
+      lastModified: row.last_modified
+    };
+  }
+};
+
+// src/adapters/data/session-store/factory.ts
+function createSessionStore(options = {}) {
+  if (options.type === "memory") {
+    const store = new InMemorySessionStore();
+    const gc = options.gc ?? {};
+    if (gc.enabled !== false) {
+      store.startGc(gc.ttlMs ?? 864e5, gc.intervalMs ?? 3e5);
+    }
+    return store;
+  }
+  const path2 = options.path ?? getOctoFlowDbPath("sessions");
+  return new SqliteSessionStore({ path: path2, busyTimeoutMs: options.busyTimeoutMs });
+}
+
+// src/domain/errors/base.ts
+var ERROR_CLASS_BY_CODE = /* @__PURE__ */ new Map();
+function registerErrorClass(code, factory) {
+  ERROR_CLASS_BY_CODE.set(code, factory);
+}
+var exposeStackConfig = false;
+function shouldExposeStack() {
+  return exposeStackConfig;
+}
+function ctxString(ctx, key, fallback = "") {
+  const value = ctx?.[key];
+  return typeof value === "string" ? value : fallback;
+}
+function ctxNumber(ctx, key, fallback = 0) {
+  const value = ctx?.[key];
+  return typeof value === "number" ? value : fallback;
+}
+function serializeCause(cause) {
+  if (!cause) return void 0;
+  if (cause instanceof OctoFlowError) {
+    return { name: cause.name, message: cause.message, code: cause.code };
+  }
+  if (cause instanceof Error) {
+    return { name: cause.name, message: cause.message };
+  }
+  if (typeof cause === "string") {
+    return { message: cause };
+  }
+  try {
+    return { message: JSON.stringify(cause) };
+  } catch {
+    return { message: Object.prototype.toString.call(cause) };
+  }
+}
+var OctoFlowError = class extends Error {
+  code;
+  context;
+  constructor(code, message, context = {}) {
+    super(message);
+    this.name = "OctoFlowError";
+    this.code = code;
+    this.context = Object.freeze({ ...context });
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  toJSON() {
+    const payload = {
+      name: this.name,
+      code: this.code,
+      message: this.message
+    };
+    if (Object.keys(this.context).length > 0) payload.context = this.context;
+    const cause = serializeCause(this.cause);
+    if (cause) payload.cause = cause;
+    if (shouldExposeStack() && this.stack) payload.stack = this.stack;
+    return payload;
+  }
+};
+
+// src/domain/errors/task.ts
+var TaskNotFoundError = class extends OctoFlowError {
+  constructor(taskId, reason) {
+    super(
+      "TASK_NOT_FOUND",
+      reason ? `Task not found: "${taskId}" \u2014 ${reason}` : `Task not found: "${taskId}"`,
+      { taskId, ...reason ? { reason } : {} }
+    );
+    this.name = "TaskNotFoundError";
+  }
+};
+registerErrorClass(
+  "TASK_NOT_FOUND",
+  (p) => new TaskNotFoundError(
+    ctxString(p.context, "taskId"),
+    ctxString(p.context, "reason") || void 0
+  )
+);
+var TaskTerminalError = class extends OctoFlowError {
+  constructor(taskId, state) {
+    super(
+      "TASK_TERMINAL",
+      `Task "${taskId}" is already terminal (state: ${state}).`,
+      { taskId, state }
+    );
+    this.name = "TaskTerminalError";
+  }
+};
+registerErrorClass(
+  "TASK_TERMINAL",
+  (p) => new TaskTerminalError(
+    ctxString(p.context, "taskId"),
+    ctxString(p.context, "state")
+  )
+);
+var QueueFullError = class extends OctoFlowError {
+  constructor(contextId, depth) {
+    super(
+      "QUEUE_FULL",
+      `Context "${contextId}" queue is full (depth: ${depth}). Apply backpressure.`,
+      { contextId, depth }
+    );
+    this.name = "QueueFullError";
+  }
+};
+registerErrorClass(
+  "QUEUE_FULL",
+  (p) => new QueueFullError(
+    ctxString(p.context, "contextId"),
+    ctxNumber(p.context, "depth")
+  )
+);
+var SessionNotFoundError = class extends OctoFlowError {
+  constructor(sessionId) {
+    super("SESSION_NOT_FOUND", `Session not found: "${sessionId}"`, {
+      sessionId
+    });
+    this.name = "SessionNotFoundError";
+  }
+};
+registerErrorClass(
+  "SESSION_NOT_FOUND",
+  (p) => new SessionNotFoundError(ctxString(p.context, "sessionId"))
+);
+var BudgetExhaustedError = class extends OctoFlowError {
+  contextId;
+  spentUsd;
+  limitUsd;
+  constructor(contextId, spentUsd, limitUsd) {
+    super(
+      "BUDGET_EXHAUSTED",
+      `Context "${contextId}" budget exhausted: $${spentUsd.toFixed(4)} spent of $${limitUsd.toFixed(4)} limit.`,
+      { contextId, spentUsd, limitUsd }
+    );
+    this.name = "BudgetExhaustedError";
+    this.contextId = contextId;
+    this.spentUsd = spentUsd;
+    this.limitUsd = limitUsd;
+  }
+};
+registerErrorClass(
+  "BUDGET_EXHAUSTED",
+  (p) => new BudgetExhaustedError(
+    ctxString(p.context, "contextId"),
+    ctxNumber(p.context, "spentUsd"),
+    ctxNumber(p.context, "limitUsd")
+  )
+);
+
+// src/adapters/data/task-store/async-event-queue.ts
+var AsyncEventQueue = class {
+  closed = false;
+  items = [];
+  waiters = [];
+  push(value) {
+    if (this.closed) return;
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter({ value, done: false });
+      return;
+    }
+    this.items.push(value);
+  }
+  next() {
+    if (this.items.length > 0) {
+      return Promise.resolve({ value: this.items.shift(), done: false });
+    }
+    if (this.closed) {
+      return Promise.resolve({ value: void 0, done: true });
+    }
+    return new Promise((resolve) => {
+      this.waiters.push(resolve);
+    });
+  }
+  return() {
+    this.close();
+    return Promise.resolve({ value: void 0, done: true });
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    while (this.waiters.length > 0) {
+      this.waiters.shift()({ value: void 0, done: true });
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
+
+// src/adapters/data/task-store/shared.ts
+var import_node_crypto3 = __toESM(require("node:crypto"), 1);
+
+// src/utils/clone.ts
+function cloneValue(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/utils/metadata.ts
+function mergeMetadata(left, right) {
+  if (!left && !right) return void 0;
+  const merged = { ...left ?? {}, ...right ?? {} };
+  if (left?.bridge && right?.bridge) {
+    merged.bridge = { ...left.bridge, ...right.bridge };
+  }
+  return merged;
+}
+
+// src/adapters/data/task-store/shared.ts
+function coalesceArtifactParts(parts) {
+  const merged = [];
+  for (const part of parts) {
+    const nextPart = cloneValue(part);
+    const current = merged[merged.length - 1];
+    if (current?.kind === "text" && nextPart.kind === "text" && current.metadata === void 0 && nextPart.metadata === void 0) {
+      current.text += nextPart.text;
+      continue;
+    }
+    merged.push(nextPart);
+  }
+  return merged;
+}
+function isTerminalTaskState(state) {
+  return state === "completed" || state === "failed" || state === "canceled" || state === "rejected";
+}
+function createTaskRecord(input) {
+  const taskId = input.taskId ?? import_node_crypto3.default.randomUUID();
+  const createdAt = input.createdAt ?? nowIso();
+  const task = {
+    id: taskId,
+    kind: "task",
+    contextId: input.contextId,
+    createdAt,
+    lastModified: createdAt,
+    history: limitHistory([input.message], input.historyLength),
+    artifacts: [],
+    metadata: withBridgeMetadata(input.metadata, input.bridgeMetadata),
+    status: {
+      state: "submitted",
+      timestamp: createdAt
+    },
+    tenant: input.tenant
+  };
+  return {
+    task,
+    updatedAt: Date.now()
+  };
+}
+function resumeTaskRecord(record, input) {
+  const nextTask = cloneValue(record.task);
+  if (input.tenant !== void 0 && nextTask.tenant !== input.tenant) {
+    throw new TaskNotFoundError(
+      input.taskId,
+      `does not belong to tenant ${input.tenant}`
+    );
+  }
+  const timestamp = nowIso();
+  nextTask.history = limitHistory(
+    [...nextTask.history ?? [], cloneValue(input.message)],
+    input.historyLength
+  );
+  nextTask.metadata = withBridgeMetadata(
+    mergeMetadata(nextTask.metadata, input.metadata),
+    input.bridgeMetadata
+  );
+  nextTask.status = {
+    state: "submitted",
+    timestamp
+  };
+  nextTask.lastModified = timestamp;
+  return {
+    task: nextTask,
+    updatedAt: Date.now()
+  };
+}
+function updateBridgeMetadataRecord(record, bridgeMetadata) {
+  const nextTask = cloneValue(record.task);
+  nextTask.metadata = withBridgeMetadata(nextTask.metadata, bridgeMetadata);
+  nextTask.lastModified = nowIso();
+  return {
+    task: nextTask,
+    updatedAt: Date.now()
+  };
+}
+function updateStatusRecord(record, input) {
+  const nextTask = cloneValue(record.task);
+  nextTask.status = cloneValue(input.status);
+  nextTask.metadata = mergeMetadata(nextTask.metadata, input.metadata);
+  nextTask.lastModified = input.status.timestamp ?? nowIso();
+  const nextRecord = {
+    task: nextTask,
+    updatedAt: Date.now()
+  };
+  const event = {
+    kind: "status-update",
+    taskId: nextTask.id,
+    contextId: nextTask.contextId,
+    status: cloneValue(input.status),
+    final: input.final ?? isTerminalTaskState(input.status.state),
+    metadata: input.metadata
+  };
+  return {
+    record: nextRecord,
+    event
+  };
+}
+function appendArtifactRecord(record, input) {
+  const nextTask = cloneValue(record.task);
+  const artifacts = nextTask.artifacts ?? [];
+  const index = artifacts.findIndex(
+    (artifact) => artifact.artifactId === input.artifact.artifactId
+  );
+  const incomingArtifact = {
+    ...cloneValue(input.artifact),
+    parts: coalesceArtifactParts(input.artifact.parts)
+  };
+  if (index >= 0 && input.append) {
+    const existing = artifacts[index];
+    artifacts[index] = {
+      ...existing,
+      ...incomingArtifact,
+      parts: coalesceArtifactParts([
+        ...existing.parts,
+        ...incomingArtifact.parts
+      ]),
+      metadata: mergeMetadata(existing.metadata, incomingArtifact.metadata)
+    };
+  } else if (index >= 0) {
+    artifacts[index] = incomingArtifact;
+  } else {
+    artifacts.push(incomingArtifact);
+  }
+  const timestamp = nowIso();
+  nextTask.artifacts = artifacts;
+  nextTask.metadata = mergeMetadata(nextTask.metadata, input.metadata);
+  nextTask.lastModified = timestamp;
+  const nextRecord = {
+    task: nextTask,
+    updatedAt: Date.now()
+  };
+  const resultArtifact = index >= 0 ? artifacts[index] : artifacts[artifacts.length - 1];
+  const event = {
+    kind: "artifact-update",
+    taskId: nextTask.id,
+    contextId: nextTask.contextId,
+    artifact: cloneValue(resultArtifact),
+    append: input.append,
+    lastChunk: input.lastChunk,
+    metadata: input.metadata
+  };
+  return {
+    record: nextRecord,
+    event
+  };
+}
+function appendHistoryRecord(record, message, historyLength) {
+  const nextTask = cloneValue(record.task);
+  nextTask.history = limitHistory(
+    [...nextTask.history ?? [], cloneValue(message)],
+    historyLength
+  );
+  nextTask.lastModified = nowIso();
+  return {
+    task: nextTask,
+    updatedAt: Date.now()
+  };
+}
+function projectTask(task, options) {
+  const projected = cloneValue(task);
+  if (options.historyLength != null) {
+    projected.history = limitHistory(
+      projected.history ?? [],
+      options.historyLength
+    );
+  }
+  if (options.includeArtifacts === false) {
+    delete projected.artifacts;
+  }
+  return projected;
+}
+function cloneTaskResult(task) {
+  return cloneValue(task);
+}
+function cloneEventResult(event) {
+  return cloneValue(event);
+}
+var TASK_EVENT_CURSOR_PREFIX = "e:";
+var TASK_EVENT_CURSOR_RE = /^e:(\d+)$/;
+function encodeTaskEventCursor(sequence) {
+  return `${TASK_EVENT_CURSOR_PREFIX}${Math.max(0, Math.trunc(sequence))}`;
+}
+function decodeTaskEventCursor(cursor) {
+  if (cursor == null) return void 0;
+  if (/^\d+$/.test(cursor)) {
+    return Number.parseInt(cursor, 10);
+  }
+  const match = TASK_EVENT_CURSOR_RE.exec(cursor);
+  if (!match?.[1]) {
+    throw new Error(`Invalid task event cursor: ${cursor}`);
+  }
+  return Number.parseInt(match[1], 10);
+}
+function createListConversationsResult(input) {
+  return cloneValue(input);
+}
+function buildConversationFromTasks(tasks, options = {}) {
+  if (tasks.length === 0) {
+    throw new Error("Cannot build a conversation without tasks");
+  }
+  const sortedTasks = [...tasks].sort(compareTasksByCreatedAt);
+  const projectedTasks = sortedTasks.map((task) => projectTask(task, options));
+  const latestTask = projectedTasks[projectedTasks.length - 1];
+  const history = options.includeHistory === false ? void 0 : limitHistory(
+    collectConversationMessages(sortedTasks),
+    options.historyLength
+  );
+  const firstTask = sortedTasks[0];
+  return {
+    id: firstTask.contextId,
+    kind: "conversation",
+    contextId: firstTask.contextId,
+    tenant: firstTask.tenant,
+    createdAt: firstTask.createdAt,
+    lastModified: latestTask?.lastModified,
+    latestTask,
+    metadata: latestTask?.metadata,
+    taskCount: projectedTasks.length,
+    backends: collectConversationBackends(sortedTasks),
+    ...history !== void 0 ? { history } : {},
+    ...options.includeTasks === false ? {} : { tasks: projectedTasks }
+  };
+}
+function withBridgeMetadata(metadata, bridgeMetadata) {
+  if (!metadata && !bridgeMetadata) return void 0;
+  const existing = metadata?.bridge;
+  return {
+    ...metadata ?? {},
+    ...bridgeMetadata ? {
+      bridge: existing != null && typeof existing === "object" ? { ...existing, ...bridgeMetadata } : bridgeMetadata
+    } : {}
+  };
+}
+function limitHistory(history, historyLength) {
+  if (historyLength == null || historyLength < 0) {
+    return cloneValue(history);
+  }
+  return cloneValue(history.slice(-historyLength));
+}
+function compareTasksByCreatedAt(left, right) {
+  const leftTime = Date.parse(left.createdAt ?? left.lastModified ?? "");
+  const rightTime = Date.parse(right.createdAt ?? right.lastModified ?? "");
+  if (Number.isNaN(leftTime) && Number.isNaN(rightTime)) {
+    return 0;
+  }
+  if (Number.isNaN(leftTime)) return -1;
+  if (Number.isNaN(rightTime)) return 1;
+  return leftTime - rightTime;
+}
+function collectConversationMessages(tasks) {
+  const seen = /* @__PURE__ */ new Set();
+  const messages = [];
+  for (const task of tasks) {
+    for (const message of task.history ?? []) {
+      pushUniqueMessage(messages, seen, message);
+    }
+    if (task.status.message) {
+      pushUniqueMessage(messages, seen, task.status.message);
+    }
+  }
+  return messages;
+}
+function collectConversationBackends(tasks) {
+  const seen = /* @__PURE__ */ new Set();
+  const backends = [];
+  for (const task of tasks) {
+    const backend = readTaskBackend(task);
+    if (!backend || seen.has(backend)) continue;
+    seen.add(backend);
+    backends.push(backend);
+  }
+  return backends;
+}
+function pushUniqueMessage(messages, seen, message) {
+  if (message.messageId && seen.has(message.messageId)) {
+    return;
+  }
+  if (message.messageId) {
+    seen.add(message.messageId);
+  }
+  messages.push(cloneValue(message));
+}
+function readTaskBackend(task) {
+  const bridge = task.metadata?.bridge;
+  if (!bridge || typeof bridge !== "object") {
+    return null;
+  }
+  const backend = bridge.backend;
+  return typeof backend === "string" ? backend : null;
+}
+
+// src/adapters/data/task-store/in-memory-listing.ts
+function listInMemoryTasks(recordsInput, input = {}) {
+  const states = input.state == null ? null : new Set(Array.isArray(input.state) ? input.state : [input.state]);
+  const limit = Math.max(1, input.limit ?? 50);
+  const offset = Math.max(0, Number.parseInt(input.cursor ?? "0", 10) || 0);
+  const statusTimestampAfter = input.statusTimestampAfter == null ? Number.NaN : Date.parse(input.statusTimestampAfter);
+  const records = [...recordsInput].filter(
+    (record) => !input.contextId || record.task.contextId === input.contextId
+  ).filter(
+    (record) => input.tenant === void 0 || record.task.tenant === input.tenant
+  ).filter((record) => !states || states.has(record.task.status.state)).filter(
+    (record) => Number.isNaN(statusTimestampAfter) || typeof record.task.status.timestamp === "string" && Date.parse(record.task.status.timestamp) >= statusTimestampAfter
+  ).filter(
+    (record) => !input.packId || record.task.metadata?.bridge?.packId === input.packId
+  ).filter(
+    (record) => !input.parentTaskId || record.task.metadata?.bridge?.parentTaskId === input.parentTaskId
+  ).sort((left, right) => right.updatedAt - left.updatedAt);
+  return {
+    tasks: records.slice(offset, offset + limit).map((record) => projectTask(record.task, input)),
+    nextCursor: offset + limit < records.length ? String(offset + limit) : null,
+    pageSize: limit,
+    totalSize: records.length
+  };
+}
+function listInMemoryConversations(recordsInput, input = {}) {
+  const limit = Math.max(1, input.limit ?? 50);
+  const offset = Math.max(0, Number.parseInt(input.cursor ?? "0", 10) || 0);
+  const statusTimestampAfter = input.statusTimestampAfter == null ? Number.NaN : Date.parse(input.statusTimestampAfter);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const record of recordsInput) {
+    if (input.tenant !== void 0 && record.task.tenant !== input.tenant) {
+      continue;
+    }
+    if (!Number.isNaN(statusTimestampAfter)) {
+      const taskTimestamp = record.task.status.timestamp;
+      if (typeof taskTimestamp !== "string" || Date.parse(taskTimestamp) < statusTimestampAfter) {
+        continue;
+      }
+    }
+    const key = `${record.task.tenant ?? ""}\0${record.task.contextId}`;
+    const existing = grouped.get(key);
+    if (existing) existing.push(record);
+    else grouped.set(key, [record]);
+  }
+  const maxUpdatedAt = (records) => records.reduce((m, r) => r.updatedAt > m ? r.updatedAt : m, 0);
+  const ordered = [...grouped.values()].map((records) => ({ records, max: maxUpdatedAt(records) })).sort((a, b) => b.max - a.max).map(({ records }) => records);
+  const conversations = ordered.slice(offset, offset + limit).map(
+    (records) => buildConversationFromTasks(
+      records.map((record) => record.task),
+      {
+        ...input,
+        includeHistory: input.includeHistory ?? false,
+        includeTasks: input.includeTasks ?? false
+      }
+    )
+  );
+  return createListConversationsResult({
+    conversations,
+    nextCursor: offset + limit < ordered.length ? String(offset + limit) : null,
+    pageSize: limit,
+    totalSize: ordered.length
+  });
+}
+
+// src/adapters/data/task-store/in-memory.ts
+var InMemoryTaskStore = class {
+  checkpointKV = /* @__PURE__ */ new Map();
+  eventHistory = /* @__PURE__ */ new Map();
+  eventSequences = /* @__PURE__ */ new Map();
+  tasks = /* @__PURE__ */ new Map();
+  subscribers = /* @__PURE__ */ new Map();
+  tickClaims = /* @__PURE__ */ new Map();
+  maxTasks;
+  constructor(opts = {}) {
+    this.maxTasks = opts.maxTasks;
+  }
+  createTask(input) {
+    const record = createTaskRecord(input);
+    this.tasks.set(record.task.id, record);
+    this.ensureEventState(record.task.id);
+    this.evictTerminalIfOverCap();
+    return Promise.resolve(cloneTaskResult(record.task));
+  }
+  evictTerminalIfOverCap() {
+    if (this.maxTasks == null || this.tasks.size <= this.maxTasks) return;
+    for (const [id, rec] of this.tasks) {
+      if (this.tasks.size <= this.maxTasks) break;
+      if (isTerminalTaskState(rec.task.status.state)) {
+        this.tasks.delete(id);
+        this.eventHistory.delete(id);
+        this.eventSequences.delete(id);
+        this.tickClaims.delete(id);
+      }
+    }
+  }
+  claimTask(taskId) {
+    const record = this.tasks.get(taskId);
+    if (!record || record.task.status.state !== "submitted") {
+      return Promise.resolve(void 0);
+    }
+    const next = updateStatusRecord(record, {
+      taskId,
+      status: { state: "working" }
+    });
+    this.tasks.set(taskId, next.record);
+    this.publish(
+      taskId,
+      this.assignEventId(taskId, { kind: "status-update", event: next.event })
+    );
+    return Promise.resolve(cloneTaskResult(next.record.task));
+  }
+  resumeTask(input) {
+    const record = this.getRequiredRecord(input.taskId);
+    const nextRecord = resumeTaskRecord(record, input);
+    this.tasks.set(input.taskId, nextRecord);
+    return Promise.resolve(cloneTaskResult(nextRecord.task));
+  }
+  getTask(taskId, options = {}) {
+    const record = this.tasks.get(taskId);
+    return Promise.resolve(
+      record ? projectTask(record.task, options) : void 0
+    );
+  }
+  getConversation(contextId, options = {}) {
+    const records = [...this.tasks.values()].filter((record) => record.task.contextId === contextId).filter((record) => record.task.tenant === options.tenant).sort((left, right) => left.updatedAt - right.updatedAt);
+    if (records.length === 0) {
+      return Promise.resolve(void 0);
+    }
+    return Promise.resolve(
+      buildConversationFromTasks(
+        records.map((record) => record.task),
+        options
+      )
+    );
+  }
+  hasTask(taskId) {
+    return Promise.resolve(this.tasks.has(taskId));
+  }
+  listTasks(input = {}) {
+    return Promise.resolve(listInMemoryTasks(this.tasks.values(), input));
+  }
+  listConversations(input = {}) {
+    return Promise.resolve(
+      listInMemoryConversations(this.tasks.values(), input)
+    );
+  }
+  updateBridgeMetadata(taskId, bridgeMetadata) {
+    const record = this.getRequiredRecord(taskId);
+    const nextRecord = updateBridgeMetadataRecord(record, bridgeMetadata);
+    this.tasks.set(taskId, nextRecord);
+    return Promise.resolve(cloneTaskResult(nextRecord.task));
+  }
+  updateStatus(input) {
+    const record = this.getRequiredRecord(input.taskId);
+    const next = updateStatusRecord(record, input);
+    this.tasks.set(input.taskId, next.record);
+    this.publish(
+      input.taskId,
+      this.assignEventId(input.taskId, {
+        kind: "status-update",
+        event: next.event
+      })
+    );
+    return Promise.resolve(
+      cloneEventResult({ kind: "status-update", event: next.event }).event
+    );
+  }
+  appendArtifact(input) {
+    const record = this.getRequiredRecord(input.taskId);
+    const next = appendArtifactRecord(record, input);
+    this.tasks.set(input.taskId, next.record);
+    this.publish(
+      input.taskId,
+      this.assignEventId(input.taskId, {
+        kind: "artifact-update",
+        event: next.event
+      })
+    );
+    return Promise.resolve(
+      cloneEventResult({ kind: "artifact-update", event: next.event }).event
+    );
+  }
+  appendHistory(taskId, message, historyLength) {
+    const record = this.getRequiredRecord(taskId);
+    const nextRecord = appendHistoryRecord(record, message, historyLength);
+    this.tasks.set(taskId, nextRecord);
+    return Promise.resolve(cloneTaskResult(nextRecord.task));
+  }
+  subscribe(taskId, options = {}) {
+    const record = this.getRequiredRecord(taskId);
+    this.ensureEventState(taskId);
+    const currentSequence = this.eventSequences.get(taskId) ?? 0;
+    const after = decodeTaskEventCursor(options.after);
+    const replayAfter = after == null ? currentSequence : Math.min(after, currentSequence);
+    const queue = new AsyncEventQueue();
+    queue.push({
+      kind: "task",
+      id: encodeTaskEventCursor(currentSequence),
+      task: cloneTaskResult(record.task)
+    });
+    const replayEvents = (this.eventHistory.get(taskId) ?? []).filter((event) => (decodeTaskEventCursor(event.id) ?? 0) > replayAfter).map((event) => cloneEventResult(event));
+    for (const event of replayEvents) {
+      queue.push(event);
+    }
+    if (isTerminalTaskState(record.task.status.state)) {
+      queue.close();
+      return Promise.resolve({
+        [Symbol.asyncIterator]() {
+          return queue;
+        }
+      });
+    }
+    let set = this.subscribers.get(taskId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.subscribers.set(taskId, set);
+    }
+    set.add(queue);
+    const subscribersMap = this.subscribers;
+    return Promise.resolve({
+      [Symbol.asyncIterator]() {
+        return {
+          next: () => queue.next(),
+          return: () => {
+            queue.close();
+            const subs = subscribersMap.get(taskId);
+            subs?.delete(queue);
+            if (subs && subs.size === 0) {
+              subscribersMap.delete(taskId);
+            }
+            return Promise.resolve({ value: void 0, done: true });
+          }
+        };
+      }
+    });
+  }
+  putCheckpoint(key, data) {
+    this.checkpointKV.set(key, data);
+    return Promise.resolve();
+  }
+  getCheckpoint(key) {
+    return Promise.resolve(this.checkpointKV.get(key));
+  }
+  deleteCheckpoint(key) {
+    this.checkpointKV.delete(key);
+    return Promise.resolve();
+  }
+  listCheckpoints(prefix) {
+    const keys = [...this.checkpointKV.keys()].filter(
+      (k) => k.startsWith(prefix)
+    );
+    return Promise.resolve(keys);
+  }
+  claimNextTick(tickAtMs, schedulerId = "default") {
+    let claimed = this.tickClaims.get(schedulerId);
+    if (!claimed) {
+      claimed = /* @__PURE__ */ new Set();
+      this.tickClaims.set(schedulerId, claimed);
+    }
+    if (claimed.has(tickAtMs)) {
+      return Promise.resolve(false);
+    }
+    claimed.add(tickAtMs);
+    return Promise.resolve(true);
+  }
+  close() {
+    for (const subscribers of this.subscribers.values()) {
+      for (const subscriber of subscribers) {
+        subscriber.close();
+      }
+    }
+    this.subscribers.clear();
+    this.checkpointKV.clear();
+    this.eventHistory.clear();
+    this.eventSequences.clear();
+    this.tasks.clear();
+    this.tickClaims.clear();
+    return Promise.resolve();
+  }
+  getRequiredRecord(taskId) {
+    const record = this.tasks.get(taskId);
+    if (!record) {
+      throw new TaskNotFoundError(taskId);
+    }
+    return record;
+  }
+  ensureEventState(taskId) {
+    if (!this.eventSequences.has(taskId)) {
+      this.eventSequences.set(taskId, 0);
+    }
+    if (!this.eventHistory.has(taskId)) {
+      this.eventHistory.set(taskId, []);
+    }
+  }
+  assignEventId(taskId, event) {
+    this.ensureEventState(taskId);
+    const nextSequence = (this.eventSequences.get(taskId) ?? 0) + 1;
+    this.eventSequences.set(taskId, nextSequence);
+    const withId = {
+      ...event,
+      id: encodeTaskEventCursor(nextSequence)
+    };
+    this.eventHistory.get(taskId).push(cloneEventResult(withId));
+    return withId;
+  }
+  publish(taskId, event) {
+    const subscribers = this.subscribers.get(taskId);
+    if (!subscribers) return;
+    for (const subscriber of subscribers) {
+      subscriber.push(cloneEventResult(event));
+    }
+    if (event.kind === "status-update" && (event.event.final || isTerminalTaskState(event.event.status.state))) {
+      this.subscribers.delete(taskId);
+      for (const subscriber of subscribers) {
+        subscriber.close();
+      }
+    }
+  }
+};
+
+// src/adapters/data/task-store/sqlite.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path4 = require("node:path");
+var import_better_sqlite33 = __toESM(require("better-sqlite3"), 1);
+
+// src/adapters/data/task-store/sqlite-subscriptions.ts
+function createPollingSubscription(opts) {
+  const {
+    attachEventId: attachEventId2,
+    currentSequence,
+    initialRows,
+    initialTask,
+    pollIntervalMs,
+    readRows
+  } = opts;
+  let sequence = initialRows.length > 0 ? initialRows[initialRows.length - 1].sequence : currentSequence;
+  const isFinalStatusEvent = (event) => event.kind === "status-update" && (event.event.final || isTerminalTaskState(event.event.status.state));
+  const pending = initialRows.map(attachEventId2);
+  let closeAfterPendingDrains = isTerminalTaskState(initialTask.status.state) || pending.some(isFinalStatusEvent);
+  return {
+    [Symbol.asyncIterator]() {
+      let closed = false;
+      let first = true;
+      let consecutiveEmpty = 0;
+      return {
+        async next() {
+          if (closed) {
+            return { value: void 0, done: true };
+          }
+          if (first) {
+            first = false;
+            return {
+              value: {
+                kind: "task",
+                id: encodeTaskEventCursor(currentSequence),
+                task: cloneTaskResult(initialTask)
+              },
+              done: false
+            };
+          }
+          while (!closed) {
+            if (pending.length > 0) {
+              consecutiveEmpty = 0;
+              const nextEvent = pending.shift();
+              if (pending.length === 0 && (closeAfterPendingDrains || isFinalStatusEvent(nextEvent))) {
+                closeAfterPendingDrains = true;
+              }
+              return { value: nextEvent, done: false };
+            }
+            if (closeAfterPendingDrains) {
+              closed = true;
+              return { value: void 0, done: true };
+            }
+            const rows = readRows(sequence);
+            if (rows.length > 0) {
+              consecutiveEmpty = 0;
+              sequence = rows[rows.length - 1].sequence;
+              const nextEvents = rows.map(attachEventId2);
+              for (const event of nextEvents) {
+                pending.push(event);
+              }
+              if (nextEvents.some(isFinalStatusEvent)) {
+                closeAfterPendingDrains = true;
+              }
+              continue;
+            }
+            consecutiveEmpty++;
+            const backoffMs = Math.min(
+              pollIntervalMs * 2 ** (consecutiveEmpty - 1),
+              500
+            );
+            await sleep(backoffMs);
+          }
+          return { value: void 0, done: true };
+        },
+        return() {
+          closed = true;
+          return Promise.resolve({ value: void 0, done: true });
+        },
+        [Symbol.asyncIterator]() {
+          return this;
+        }
+      };
+    }
+  };
+}
+
+// src/adapters/data/task-store/sqlite-queries.ts
+function readRecord(db, taskId) {
+  const row = db.prepare(
+    `
+    SELECT task_json, updated_at FROM tasks WHERE id = ?
+  `
+  ).get(taskId);
+  if (!row) return void 0;
+  return { task: JSON.parse(row.task_json), updatedAt: row.updated_at };
+}
+function readSnapshot(db, taskId) {
+  return db.transaction((currentTaskId) => {
+    const record = readRecord(db, currentTaskId);
+    if (!record) return void 0;
+    const row = db.prepare(
+      `
+      SELECT COALESCE(MAX(sequence), 0) AS sequence FROM task_events WHERE task_id = ?
+    `
+    ).get(currentTaskId);
+    return { task: record.task, sequence: row.sequence ?? 0 };
+  })(taskId);
+}
+function readConversationRecords(db, contextId, tenant) {
+  const effectiveTenant = tenant ?? void 0;
+  const params = [contextId];
+  const tenantSql = effectiveTenant === void 0 ? "tenant IS NULL" : "tenant = ?";
+  if (effectiveTenant !== void 0) {
+    params.push(effectiveTenant);
+  }
+  const rows = db.prepare(
+    `
+    SELECT task_json, updated_at FROM tasks
+    WHERE context_id = ? AND ${tenantSql}
+    ORDER BY created_at ASC, updated_at ASC, id ASC
+  `
+  ).all(...params);
+  return rows.map((row) => ({
+    task: JSON.parse(row.task_json),
+    updatedAt: row.updated_at
+  }));
+}
+function readConversationRecordsBatch(db, contextIds) {
+  if (contextIds.length === 0) return [];
+  const placeholders = contextIds.map(() => "?").join(", ");
+  const rows = db.prepare(
+    `
+    SELECT task_json, updated_at FROM tasks
+    WHERE context_id IN (${placeholders})
+    ORDER BY created_at ASC, updated_at ASC, id ASC
+  `
+  ).all(...contextIds);
+  return rows.map((row) => ({
+    task: JSON.parse(row.task_json),
+    updatedAt: row.updated_at
+  }));
+}
+function writeRecord(db, record) {
+  db.prepare(
+    `
+    INSERT INTO tasks (
+      id, context_id, tenant, created_at, last_modified,
+      status_state, status_timestamp, updated_at, task_json
+    ) VALUES (
+      @id, @context_id, @tenant, @created_at, @last_modified,
+      @status_state, @status_timestamp, @updated_at, @task_json
+    )
+    ON CONFLICT(id) DO UPDATE SET
+      context_id = excluded.context_id,
+      tenant = excluded.tenant,
+      created_at = excluded.created_at,
+      last_modified = excluded.last_modified,
+      status_state = excluded.status_state,
+      status_timestamp = excluded.status_timestamp,
+      updated_at = excluded.updated_at,
+      task_json = excluded.task_json
+  `
+  ).run(toTaskRow(record));
+}
+function insertEvent(db, taskId, event) {
+  const storedEvent = { ...event };
+  delete storedEvent.id;
+  db.prepare(
+    `
+    INSERT INTO task_events (task_id, event_kind, payload_json) VALUES (?, ?, ?)
+  `
+  ).run(taskId, event.kind, JSON.stringify(storedEvent));
+}
+function toTaskRow(record) {
+  return {
+    id: record.task.id,
+    context_id: record.task.contextId,
+    tenant: record.task.tenant ?? null,
+    created_at: record.task.createdAt ?? "",
+    last_modified: record.task.lastModified ?? "",
+    status_state: record.task.status.state,
+    status_timestamp: record.task.status.timestamp ?? null,
+    updated_at: record.updatedAt,
+    task_json: JSON.stringify(record.task)
+  };
+}
+function attachEventId(row) {
+  return {
+    ...JSON.parse(row.payload_json),
+    id: encodeTaskEventCursor(row.sequence)
+  };
+}
+function transactTask(db, taskId, mutate) {
+  return db.transaction((currentTaskId) => {
+    const record = readRecord(db, currentTaskId);
+    if (!record) throw new TaskNotFoundError(currentTaskId);
+    const next = mutate(record);
+    writeRecord(db, next.record);
+    if (next.event) insertEvent(db, currentTaskId, next.event);
+    return next;
+  })(taskId);
+}
+function buildSubscription(db, taskId, pollIntervalMs, options = {}) {
+  const snapshot = readSnapshot(db, taskId);
+  if (!snapshot) {
+    throw new TaskNotFoundError(taskId);
+  }
+  const after = decodeTaskEventCursor(options.after);
+  const currentSequence = snapshot.sequence;
+  const sequence = after == null ? currentSequence : Math.min(after, currentSequence);
+  const initialTask = cloneTaskResult(snapshot.task);
+  const readRows = (afterSequence) => db.prepare(
+    `
+    SELECT sequence, payload_json FROM task_events
+    WHERE task_id = ? AND sequence > ?
+    ORDER BY sequence ASC
+  `
+  ).all(taskId, afterSequence);
+  const initialRows = readRows(sequence);
+  return createPollingSubscription({
+    attachEventId,
+    currentSequence,
+    initialRows,
+    initialTask,
+    pollIntervalMs,
+    readRows
+  });
+}
+function listConversationsQuery(db, input = {}) {
+  const limit = Math.max(1, Math.min(input.limit ?? 50, 200));
+  const offset = input.cursor ? Number.parseInt(input.cursor, 10) : 0;
+  const conditions = [];
+  const params = { limit, offset };
+  if (input.tenant !== void 0) {
+    if (input.tenant === null) {
+      conditions.push("tenant IS NULL");
+    } else {
+      conditions.push("tenant = @tenant");
+      params.tenant = input.tenant;
+    }
+  }
+  const whereSql = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const countRow = db.prepare(
+    `
+    SELECT COUNT(*) AS count FROM (
+      SELECT context_id FROM tasks ${whereSql} GROUP BY context_id, tenant
+    )
+  `
+  ).get(params);
+  const rows = db.prepare(
+    `
+    SELECT
+      context_id, tenant,
+      COUNT(*) AS task_count,
+      MAX(updated_at) AS updated_at
+    FROM tasks ${whereSql}
+    GROUP BY context_id, tenant
+    ORDER BY updated_at DESC
+    LIMIT @limit OFFSET @offset
+  `
+  ).all(params);
+  const contextIds = rows.map((row) => row.context_id);
+  const allTaskRecords = readConversationRecordsBatch(db, contextIds);
+  const tasksByKey = /* @__PURE__ */ new Map();
+  for (const record of allTaskRecords) {
+    const key = `${record.task.contextId}\0${record.task.tenant ?? ""}`;
+    const bucket = tasksByKey.get(key);
+    if (bucket) bucket.push(record.task);
+    else tasksByKey.set(key, [record.task]);
+  }
+  return createListConversationsResult({
+    conversations: rows.map(
+      (row) => buildConversationFromTasks(
+        tasksByKey.get(`${row.context_id}\0${row.tenant ?? ""}`) ?? [],
+        {
+          ...input,
+          includeHistory: input.includeHistory ?? false,
+          includeTasks: input.includeTasks ?? false
+        }
+      )
+    ),
+    nextCursor: offset + limit < countRow.count ? String(offset + limit) : null,
+    pageSize: limit,
+    totalSize: countRow.count
+  });
+}
+
+// src/adapters/data/task-store/sqlite.ts
+var DEFAULT_BUSY_TIMEOUT_MS = 5e3;
+var DEFAULT_POLL_INTERVAL_MS = 50;
+var SqliteTaskStore = class _SqliteTaskStore {
+  db;
+  pollIntervalMs;
+  constructor(options = {}) {
+    const dbPath = options.path ?? _SqliteTaskStore.defaultPath();
+    if (dbPath !== ":memory:") {
+      const dir = (0, import_node_path4.dirname)(
+        (0, import_node_path4.isAbsolute)(dbPath) ? dbPath : (0, import_node_path4.join)(process.cwd(), dbPath)
+      );
+      if (!(0, import_node_fs3.existsSync)(dir)) (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
+    }
+    this.db = new import_better_sqlite33.default(dbPath);
+    this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.pragma(
+      `busy_timeout = ${options.busyTimeoutMs ?? DEFAULT_BUSY_TIMEOUT_MS}`
+    );
+    this.db.pragma("foreign_keys = ON");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        context_id TEXT NOT NULL,
+        tenant TEXT,
+        created_at TEXT NOT NULL DEFAULT '',
+        last_modified TEXT NOT NULL DEFAULT '',
+        status_state TEXT NOT NULL DEFAULT 'submitted',
+        status_timestamp TEXT,
+        updated_at INTEGER NOT NULL DEFAULT 0,
+        task_json TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_tasks_context_id ON tasks(context_id);
+      CREATE INDEX IF NOT EXISTS idx_tasks_status_state ON tasks(status_state);
+      CREATE INDEX IF NOT EXISTS idx_tasks_tenant ON tasks(tenant);
+      CREATE INDEX IF NOT EXISTS idx_tasks_updated_at ON tasks(updated_at);
+
+      CREATE TABLE IF NOT EXISTS task_events (
+        sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL,
+        event_kind TEXT NOT NULL,
+        payload_json TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY(task_id) REFERENCES tasks(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_task_events_task_id ON task_events(task_id);
+      CREATE INDEX IF NOT EXISTS idx_task_events_task_sequence ON task_events(task_id, sequence);
+
+      CREATE TABLE IF NOT EXISTS checkpoints (
+        key TEXT PRIMARY KEY,
+        data TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS scheduler_tick_claims (
+        scheduler_id TEXT NOT NULL,
+        tick_at_ms INTEGER NOT NULL,
+        claimed_at INTEGER NOT NULL,
+        PRIMARY KEY (scheduler_id, tick_at_ms)
+      );
+    `);
+  }
+  createTask(input) {
+    const record = createTaskRecord(input);
+    writeRecord(this.db, record);
+    return Promise.resolve(cloneTaskResult(record.task));
+  }
+  claimTask(taskId) {
+    const result = transactTask(this.db, taskId, (record) => {
+      if (record.task.status.state !== "submitted") {
+        return { record, claimed: false };
+      }
+      const next = updateStatusRecord(record, {
+        taskId,
+        status: { state: "working" }
+      });
+      return {
+        record: next.record,
+        event: {
+          kind: "status-update",
+          event: next.event
+        },
+        claimed: true
+      };
+    });
+    if (!result.claimed) {
+      return Promise.resolve(void 0);
+    }
+    return Promise.resolve(cloneTaskResult(result.record.task));
+  }
+  resumeTask(input) {
+    const nextRecord = transactTask(this.db, input.taskId, (record) => ({
+      record: resumeTaskRecord(record, input)
+    }));
+    return Promise.resolve(cloneTaskResult(nextRecord.record.task));
+  }
+  getTask(taskId, options = {}) {
+    const record = readRecord(this.db, taskId);
+    return Promise.resolve(
+      record ? projectTask(record.task, options) : void 0
+    );
+  }
+  hasTask(taskId) {
+    const row = this.db.prepare("SELECT 1 FROM tasks WHERE id = ?").get(taskId);
+    return Promise.resolve(row != null);
+  }
+  listTasks(input = {}) {
+    const states = input.state == null ? [] : Array.isArray(input.state) ? input.state : [input.state];
+    const limit = Math.max(1, input.limit ?? 50);
+    const offset = Math.max(0, Number.parseInt(input.cursor ?? "0", 10) || 0);
+    const whereParts = [];
+    const params = { limit, offset };
+    if (input.contextId) {
+      whereParts.push("context_id = @contextId");
+      params.contextId = input.contextId;
+    }
+    if (input.tenant !== void 0) {
+      whereParts.push("tenant = @tenant");
+      params.tenant = input.tenant;
+    }
+    if (states.length > 0) {
+      const placeholders = states.map((state, index) => {
+        const key = `state${index}`;
+        params[key] = state;
+        return `@${key}`;
+      });
+      whereParts.push(`status_state IN (${placeholders.join(", ")})`);
+    }
+    if (input.statusTimestampAfter) {
+      whereParts.push("status_timestamp >= @statusTimestampAfter");
+      params.statusTimestampAfter = input.statusTimestampAfter;
+    }
+    const whereSql = whereParts.length > 0 ? `WHERE ${whereParts.join(" AND ")}` : "";
+    const countRow = this.db.prepare(`SELECT COUNT(*) AS count FROM tasks ${whereSql}`).get(params);
+    const rows = this.db.prepare(
+      `
+      SELECT task_json, updated_at FROM tasks ${whereSql} ORDER BY updated_at DESC LIMIT @limit OFFSET @offset
+    `
+    ).all(params);
+    let parsed = rows.map((row) => ({
+      task: JSON.parse(row.task_json),
+      updatedAt: row.updated_at
+    }));
+    if (input.packId) {
+      parsed = parsed.filter(
+        (r) => r.task.metadata?.bridge?.packId === input.packId
+      );
+    }
+    if (input.parentTaskId) {
+      parsed = parsed.filter(
+        (r) => r.task.metadata?.bridge?.parentTaskId === input.parentTaskId
+      );
+    }
+    return Promise.resolve({
+      tasks: parsed.map((record) => projectTask(record.task, input)),
+      nextCursor: offset + limit < countRow.count ? String(offset + limit) : null,
+      pageSize: limit,
+      totalSize: parsed.length
+    });
+  }
+  getConversation(contextId, options = {}) {
+    const records = readConversationRecords(this.db, contextId, options.tenant);
+    if (records.length === 0) return Promise.resolve(void 0);
+    return Promise.resolve(
+      buildConversationFromTasks(
+        records.map((r) => r.task),
+        options
+      )
+    );
+  }
+  listConversations(input = {}) {
+    return Promise.resolve(listConversationsQuery(this.db, input));
+  }
+  updateBridgeMetadata(taskId, bridgeMetadata) {
+    const nextRecord = transactTask(this.db, taskId, (record) => ({
+      record: updateBridgeMetadataRecord(record, bridgeMetadata)
+    }));
+    return Promise.resolve(cloneTaskResult(nextRecord.record.task));
+  }
+  updateStatus(input) {
+    const result = transactTask(this.db, input.taskId, (record) => {
+      const next = updateStatusRecord(record, input);
+      return {
+        record: next.record,
+        event: {
+          kind: "status-update",
+          event: next.event
+        }
+      };
+    });
+    const event = result.event;
+    if (event.kind !== "status-update") {
+      throw new Error("Unexpected task store event type");
+    }
+    return Promise.resolve(cloneValue(event.event));
+  }
+  appendArtifact(input) {
+    const result = transactTask(this.db, input.taskId, (record) => {
+      const next = appendArtifactRecord(record, input);
+      return {
+        record: next.record,
+        event: {
+          kind: "artifact-update",
+          event: next.event
+        }
+      };
+    });
+    const event = result.event;
+    if (event.kind !== "artifact-update") {
+      throw new Error("Unexpected task store event type");
+    }
+    return Promise.resolve(cloneValue(event.event));
+  }
+  appendHistory(taskId, message, historyLength) {
+    const nextRecord = transactTask(this.db, taskId, (record) => ({
+      record: appendHistoryRecord(record, message, historyLength)
+    }));
+    return Promise.resolve(cloneTaskResult(nextRecord.record.task));
+  }
+  subscribe(taskId, options = {}) {
+    try {
+      return Promise.resolve(
+        buildSubscription(this.db, taskId, this.pollIntervalMs, options)
+      );
+    } catch (error) {
+      return Promise.reject(
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+  putCheckpoint(key, data) {
+    this.db.prepare(
+      `
+      INSERT INTO checkpoints (key, data, updated_at) VALUES (?, ?, datetime('now'))
+      ON CONFLICT(key) DO UPDATE SET data = excluded.data, updated_at = datetime('now')
+    `
+    ).run(key, data);
+    return Promise.resolve();
+  }
+  getCheckpoint(key) {
+    const row = this.db.prepare("SELECT data FROM checkpoints WHERE key = ?").get(key);
+    return Promise.resolve(row?.data);
+  }
+  deleteCheckpoint(key) {
+    this.db.prepare("DELETE FROM checkpoints WHERE key = ?").run(key);
+    return Promise.resolve();
+  }
+  listCheckpoints(prefix) {
+    const rows = this.db.prepare("SELECT key FROM checkpoints WHERE key LIKE ? ORDER BY key").all(`${prefix}%`);
+    return Promise.resolve(rows.map((r) => r.key));
+  }
+  claimNextTick(tickAtMs, schedulerId = "default") {
+    const result = this.db.prepare(
+      `
+      INSERT OR IGNORE INTO scheduler_tick_claims (scheduler_id, tick_at_ms, claimed_at)
+      VALUES (?, ?, ?)
+    `
+    ).run(schedulerId, tickAtMs, Date.now());
+    return Promise.resolve(result.changes > 0);
+  }
+  close() {
+    this.db.close();
+    return Promise.resolve();
+  }
+  static defaultPath(_workspace = process.cwd()) {
+    return getOctoFlowDbPath("tasks");
+  }
+};
+
+// src/adapters/data/task-store/factory.ts
+function isTaskStore(value) {
+  return typeof value === "object" && value !== null && typeof value.createTask === "function";
+}
+function resolveConfig(options) {
+  if (isTaskStore(options.taskStore)) {
+    throw new Error(
+      "resolveConfig() received a TaskStore instance instead of a config object"
+    );
+  }
+  if (options.storage !== void 0) {
+    return options.taskStore ?? options.config?.taskStore ?? (options.storage ? { type: "sqlite" } : { type: "memory" });
+  }
+  if (options.config?.storage !== void 0) {
+    return options.config.taskStore ?? (options.config.storage ? { type: "sqlite" } : { type: "memory" });
+  }
+  return options.taskStore ?? options.config?.taskStore ?? { type: "memory" };
+}
+function resolveSqlitePath(config) {
+  if (config.path) {
+    return config.path;
+  }
+  return getOctoFlowDbPath("tasks");
+}
+function createExternalTaskStore(config, options, workspace) {
+  const connector = options.taskStoreConnectors?.[config.name];
+  if (!connector) {
+    throw new Error(
+      `Unknown external task store connector "${config.name}". Pass a TaskStore instance directly or register a connector with createBridge({ taskStoreConnectors }).`
+    );
+  }
+  return connector({ config, workspace });
+}
+function createTaskStore(options = {}) {
+  if (isTaskStore(options.taskStore)) {
+    return options.taskStore;
+  }
+  const config = resolveConfig(options);
+  const workspace = options.workspace ?? process.cwd();
+  if (config.type === "memory") {
+    return new InMemoryTaskStore({ maxTasks: config.maxTasks });
+  }
+  if (config.type === "external") {
+    return createExternalTaskStore(config, options, workspace);
+  }
+  return new SqliteTaskStore({
+    ...config,
+    path: resolveSqlitePath(config)
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InMemoryMemoryStore,
+  InMemorySessionStore,
+  InMemoryTaskStore,
+  SqliteMemoryStore,
+  SqliteSessionStore,
+  SqliteTaskStore,
+  createMemoryStore,
+  createSessionStore,
+  createTaskStore
+});
+//# sourceMappingURL=subpath-stores.cjs.map