@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-m9w0rfyh.js

@@ -0,0 +1,123 @@
+import {
+  getTableColumnsRuntime2,
+  getViewSelectedFieldsRuntime2,
+  orderSelectedFields2,
+  mapUpdateSet2,
+  getTableLikeName2
+} from "./worktree-emrn6kk6.js";
+
+// src/database/drizzle/sqlite-core/effect/update.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind, is } from "drizzle-orm/entity";
+import { SelectionProxyHandler } from "drizzle-orm/selection-proxy";
+import { SQLiteTable } from "drizzle-orm/sqlite-core/table";
+import { extractUsedTable } from "drizzle-orm/sqlite-core/utils";
+import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
+import { Subquery } from "drizzle-orm/subquery";
+class SQLiteEffectUpdateBuilder2 {
+  table;
+  session;
+  dialect;
+  withList;
+  static [entityKind] = "SQLiteEffectUpdateBuilder";
+  constructor(table, session, dialect, withList) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.withList = withList;
+  }
+  set(values) {
+    return new SQLiteEffectUpdateBase2(this.table, mapUpdateSet2(this.table, values), this.session, this.dialect, this.withList);
+  }
+}
+
+class SQLiteEffectUpdateBase2 {
+  effectSession;
+  effectDialect;
+  static [entityKind] = "SQLiteEffectUpdate";
+  config;
+  constructor(table, set, effectSession, effectDialect, withList) {
+    this.effectSession = effectSession;
+    this.effectDialect = effectDialect;
+    this.config = { set, table, withList, joins: [] };
+  }
+  from(source) {
+    this.config.from = source;
+    return this;
+  }
+  createJoin(joinType) {
+    return (table, on) => {
+      const tableName = getTableLikeName2(table);
+      if (typeof tableName === "string" && this.config.joins.some((join) => join.alias === tableName)) {
+        throw new Error(`Alias "${tableName}" is already used in this query`);
+      }
+      if (typeof on === "function") {
+        const from = this.config.from ? is(table, SQLiteTable) ? getTableColumnsRuntime2(table) : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? getViewSelectedFieldsRuntime2(table).selectedFields : undefined : undefined;
+        on = on(new Proxy(getTableColumnsRuntime2(this.config.table), new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })), from && new Proxy(from, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })));
+      }
+      this.config.joins.push({ on, table, joinType, alias: tableName });
+      return this;
+    };
+  }
+  leftJoin = this.createJoin("left");
+  rightJoin = this.createJoin("right");
+  innerJoin = this.createJoin("inner");
+  fullJoin = this.createJoin("full");
+  where(where) {
+    this.config.where = where;
+    return this;
+  }
+  orderBy(...columns) {
+    if (typeof columns[0] === "function") {
+      const orderBy = columns[0](new Proxy(getTableColumnsRuntime2(this.config.table), new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
+      this.config.orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
+      return this;
+    }
+    this.config.orderBy = columns;
+    return this;
+  }
+  limit(limit) {
+    this.config.limit = limit;
+    return this;
+  }
+  returning(fields = getTableColumnsRuntime2(this.config.table)) {
+    this.config.returning = orderSelectedFields2(fields);
+    return this;
+  }
+  getSQL() {
+    return this.effectDialect.buildUpdateQuery(this.config);
+  }
+  toSQL() {
+    return this.effectDialect.sqlToQuery(this.getSQL());
+  }
+  _prepare(isOneTimeQuery = true) {
+    return this.effectSession[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.effectDialect.sqlToQuery(this.getSQL()), this.config.returning, this.config.returning ? "all" : "run", undefined, {
+      type: "update",
+      tables: extractUsedTable(this.config.table)
+    });
+  }
+  prepare() {
+    return this._prepare(false);
+  }
+  run = (placeholderValues) => {
+    return this._prepare().run(placeholderValues);
+  };
+  all = (placeholderValues) => {
+    return this._prepare().all(placeholderValues);
+  };
+  get = (placeholderValues) => {
+    return this._prepare().get(placeholderValues);
+  };
+  values = (placeholderValues) => {
+    return this._prepare().values(placeholderValues);
+  };
+  execute = (placeholderValues) => {
+    return this._prepare().execute(placeholderValues);
+  };
+  $dynamic() {
+    return this;
+  }
+}
+applyEffectWrapper(SQLiteEffectUpdateBase2);
+
+export { SQLiteEffectUpdateBuilder2, SQLiteEffectUpdateBase2 };

package/dist/chunks/worktree-madgwgkk.js

@@ -0,0 +1,56 @@
+import {
+  Service80,
+  node85
+} from "./worktree-ecj1wrg9.js";
+import {
+  KVTable2
+} from "./worktree-3hepkmqq.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/kv.ts
+var exports_kv = {};
+__export(exports_kv, {
+  KV: () => exports_kv,
+  Service: () => Service58,
+  node: () => node62
+});
+import { and, asc, eq, gt, gte, lt } from "drizzle-orm";
+import { Context, Effect, Layer } from "effect";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+class Service58 extends Context.Service()("@opencode/KV") {
+}
+var layer = Layer.effect(Service58, Effect.gen(function* () {
+  const db = (yield* Service80).db;
+  return Service58.of({
+    get: Effect.fn("KV.get")(function* (key) {
+      return (yield* db.select({ value: KVTable2.value }).from(KVTable2).where(eq(KVTable2.key, key)).get().pipe(Effect.orDie))?.value;
+    }),
+    set: Effect.fn("KV.set")(function* (key, value) {
+      yield* db.insert(KVTable2).values({ key, value }).onConflictDoUpdate({ target: KVTable2.key, set: { value, time_updated: Date.now() } }).run().pipe(Effect.orDie);
+    }),
+    remove: Effect.fn("KV.remove")(function* (key) {
+      yield* db.delete(KVTable2).where(eq(KVTable2.key, key)).run().pipe(Effect.orDie);
+    }),
+    scan: Effect.fn("KV.scan")(function* (options) {
+      const limit = Number.isNaN(options.limit) ? 100 : Math.min(Math.max(Math.floor(options.limit ?? 100), 1), 1000);
+      const end = prefixEnd(options.prefix);
+      const rows = yield* db.select({ key: KVTable2.key, value: KVTable2.value }).from(KVTable2).where(and(options.prefix === "" ? undefined : gte(KVTable2.key, options.prefix), end === undefined ? undefined : lt(KVTable2.key, end), options.after === undefined ? undefined : gt(KVTable2.key, options.after))).orderBy(asc(KVTable2.key)).limit(limit + 1).all().pipe(Effect.orDie);
+      const entries = rows.slice(0, limit);
+      if (rows.length <= limit)
+        return { entries };
+      return { entries, next: entries[entries.length - 1].key };
+    })
+  });
+}));
+function prefixEnd(prefix) {
+  const points = Array.from(prefix);
+  const index = points.findLastIndex((value) => value.codePointAt(0) < 1114111);
+  if (index < 0)
+    return;
+  return `${points.slice(0, index).join("")}${String.fromCodePoint(points[index].codePointAt(0) + 1)}`;
+}
+var node62 = makeGlobalNode({ service: Service58, layer, deps: [node85] });
+
+export { Service58, node62, exports_kv };

package/dist/chunks/worktree-mfxgaa47.js

@@ -0,0 +1,137 @@
+import {
+  ID11
+} from "./worktree-esam66tc.js";
+import {
+  Service54
+} from "./worktree-r82b328h.js";
+import {
+  foldSettings2
+} from "./worktree-asseqh46.js";
+
+// src/plugin/provider/vllm.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Duration, Effect, Schedule, Schema, Semaphore, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+var providerID = "vllm";
+var RemoteModel = Schema.Struct({
+  id: Schema.String,
+  owned_by: Schema.String,
+  max_model_len: Schema.NullOr(Schema.Int)
+});
+var Response = Schema.Struct({ data: Schema.Array(RemoteModel) });
+var discovery = new Map;
+var discoveryLock = Semaphore.makeUnsafe(1);
+function make8(origin = "http://127.0.0.1:8000", interval = "30 seconds") {
+  return define({
+    id: "opencode.provider.vllm",
+    effect: Effect.fn(function* (ctx) {
+      const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+      const config = yield* Service54;
+      const source = { current: configured(yield* config.entries(), origin) };
+      const loaded = { models: [], hash: "[]" };
+      yield* ctx.integration.transform((integrations) => {
+        if (loaded.models.length === 0)
+          return;
+        integrations.remove(providerID);
+      });
+      yield* ctx.catalog.transform((catalog) => {
+        if (loaded.models.length === 0)
+          return;
+        for (const model of catalog.provider.get(providerID)?.models.values() ?? []) {
+          catalog.model.remove(providerID, model.id);
+        }
+        catalog.provider.update(providerID, (provider) => {
+          provider.name = "vLLM";
+          provider.package = "@opencode/ai/providers/openai-compatible";
+          provider.settings = {
+            baseURL: source.current.baseURL,
+            provider: providerID,
+            apiKey: source.current.apiKey ?? ""
+          };
+          provider.integrationID = undefined;
+          provider.activation = "enabled";
+        });
+        for (const item of loaded.models) {
+          catalog.model.update(providerID, item.id, (model) => {
+            model.modelID = ID11.make(item.id);
+            model.name = item.id;
+            model.capabilities = { tools: false, input: ["text"], output: ["text"] };
+            if (typeof item.max_model_len === "number" && item.max_model_len > 0)
+              model.limit.context = item.max_model_len;
+          });
+        }
+      });
+      const discover = Effect.fn("VLLMPlugin.discover")(function* () {
+        const current = source.current;
+        if (!current.healthEndpoint || !current.modelsEndpoint)
+          return;
+        return yield* discoveryLock.withPermit(Effect.gen(function* () {
+          const endpoint = `${current.healthEndpoint}
+${current.modelsEndpoint}`;
+          const cached = discovery.get(endpoint);
+          if (cached && cached.apiKey === current.apiKey && Date.now() - cached.checked < Duration.toMillis(interval))
+            return { source: current, models: cached.models };
+          discovery.set(endpoint, {
+            checked: Date.now(),
+            apiKey: current.apiKey,
+            models: cached && cached.apiKey === current.apiKey ? cached.models : undefined
+          });
+          const request = (endpoint) => current.apiKey ? HttpClientRequest.get(endpoint).pipe(HttpClientRequest.acceptJson, HttpClientRequest.bearerToken(current.apiKey)) : HttpClientRequest.get(endpoint).pipe(HttpClientRequest.acceptJson);
+          yield* http.execute(request(current.healthEndpoint)).pipe(Effect.timeout("1 second"));
+          const response = yield* http.execute(request(current.modelsEndpoint)).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Response)), Effect.timeout("1 second"));
+          const models = response.data.filter((model) => model.owned_by === providerID && model.id.length > 0).toSorted((a, b) => a.id.localeCompare(b.id));
+          discovery.set(endpoint, { checked: Date.now(), apiKey: current.apiKey, models });
+          return { source: current, models };
+        }));
+      });
+      const refresh = Effect.fn("VLLMPlugin.refresh")(function* () {
+        const result = yield* discover();
+        if (!result?.models || result.source !== source.current)
+          return;
+        const hash = JSON.stringify(result.models);
+        if (hash === loaded.hash)
+          return;
+        loaded.models = result.models;
+        loaded.hash = hash;
+        yield* ctx.integration.reload();
+        yield* ctx.catalog.reload();
+      });
+      yield* refresh().pipe(Effect.ignore, Effect.repeat(Schedule.spaced(interval)), Effect.forkScoped);
+      const reload = Effect.fn("VLLMPlugin.reload")(function* () {
+        const next = configured(yield* config.entries(), origin);
+        if (next.baseURL === source.current.baseURL && next.apiKey === source.current.apiKey && next.healthEndpoint === source.current.healthEndpoint && next.modelsEndpoint === source.current.modelsEndpoint)
+          return;
+        source.current = next;
+        loaded.models = [];
+        loaded.hash = "[]";
+        yield* ctx.integration.reload();
+        yield* ctx.catalog.reload();
+        yield* refresh().pipe(Effect.ignore);
+      });
+      yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(reload), Effect.forkScoped({ startImmediately: true }));
+    })
+  });
+}
+var VLLMPlugin2 = make8();
+function configured(entries, origin) {
+  const settings = foldSettings2(entries, providerID, undefined);
+  const baseURL = (typeof settings?.baseURL === "string" ? settings.baseURL : `${origin.replace(/\/+$/, "")}/v1`).replace(/\/+$/, "");
+  const apiKey = typeof settings?.apiKey === "string" ? settings.apiKey : undefined;
+  if (!URL.canParse(baseURL))
+    return { baseURL, apiKey };
+  const models = new URL(baseURL);
+  if (models.protocol !== "http:" && models.protocol !== "https:")
+    return { baseURL, apiKey };
+  models.pathname = `${models.pathname.replace(/\/+$/, "")}/models`;
+  models.search = "";
+  models.hash = "";
+  const health = new URL(baseURL);
+  const path = health.pathname.replace(/\/+$/, "");
+  const prefix = path.endsWith("/v1") ? path.slice(0, -3) : path;
+  health.pathname = `${prefix}/health`;
+  health.search = "";
+  health.hash = "";
+  return { baseURL, apiKey, healthEndpoint: health.toString(), modelsEndpoint: models.toString() };
+}
+
+export { make8, VLLMPlugin2 };

package/dist/chunks/worktree-mj1ykd8q.js

@@ -0,0 +1,39 @@
+import {
+  Service44
+} from "./worktree-4m55frd1.js";
+import {
+  Service35
+} from "./worktree-vkez6a4k.js";
+import {
+  awaitActivation2
+} from "./worktree-1x11rq2a.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session/command.ts
+var exports_command3 = {};
+__export(exports_command3, {
+  SessionCommand: () => exports_command3,
+  execute: () => execute2
+});
+import { Effect } from "effect";
+var execute2 = Effect.fn("SessionCommand.execute")(function* (input) {
+  const instances = yield* Service35;
+  const commands = yield* awaitActivation2.pipe(Effect.andThen(Service44), instances.provide(input.session));
+  yield* commands.execute({
+    name: input.command,
+    invocation: {
+      sessionID: input.session.id,
+      prompt: {
+        text: input.text,
+        files: input.files,
+        agents: input.agents,
+        skills: input.skills
+      },
+      delivery: input.delivery ?? "steer"
+    }
+  });
+});
+
+export { execute2, exports_command3 };

package/dist/chunks/worktree-mkcjrzeh.js

@@ -0,0 +1,15 @@
+import {
+  createProviderPlugin2
+} from "./worktree-ym463w8f.js";
+
+// src/plugin/provider/mistral.ts
+var MistralPlugin2 = createProviderPlugin2({
+  id: "opencode.provider.mistral",
+  package: "@ai-sdk/mistral",
+  load: async (options) => {
+    const { createMistral } = await import("@ai-sdk/mistral");
+    return createMistral(options);
+  }
+});
+
+export { MistralPlugin2 };

package/dist/chunks/worktree-mp448xyj.js

@@ -0,0 +1,23 @@
+// src/database/migration/20260605003541_add_session_context_snapshot.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260605003541_add_session_context_snapshot",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_context_epoch\` (
+          \`session_id\` text PRIMARY KEY,
+          \`baseline\` text NOT NULL,
+          \`snapshot\` text NOT NULL,
+          \`baseline_seq\` integer NOT NULL,
+          \`replacement_seq\` integer,
+          \`revision\` integer DEFAULT 0 NOT NULL,
+          CONSTRAINT \`fk_session_context_epoch_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+    });
+  }
+};
+var _20260605003541_add_session_context_snapshot_default = migration;
+
+export { _20260605003541_add_session_context_snapshot_default };

package/dist/chunks/worktree-mp9h7a8n.js

@@ -0,0 +1,161 @@
+import {
+  AbsolutePath2,
+  RelativePath2
+} from "./worktree-922hggd3.js";
+import {
+  Repository2,
+  TreeID2,
+  Service76,
+  node81
+} from "./worktree-1e9w7pgh.js";
+import {
+  Service74,
+  node79
+} from "./worktree-z82wee6n.js";
+import {
+  create3
+} from "./worktree-kg06axw8.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/snapshot.ts
+var exports_snapshot2 = {};
+__export(exports_snapshot2, {
+  Error: () => Error2,
+  ID: () => ID5,
+  Service: () => Service31,
+  Snapshot: () => exports_snapshot2,
+  node: () => node35,
+  noopLayer: () => noopLayer2
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import path from "path";
+import { Context, Effect, Fiber, Layer, Schema, Scope } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { ID as ID5 } from "@opencode/schema/snapshot";
+import { Hash } from "@opencode/util/hash";
+class Error2 extends Schema.TaggedError()("Snapshot.Error", {
+  operation: Schema.Literals(["capture", "files", "diff", "restore"]),
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+
+class Service31 extends Context.Service()("@opencode/Snapshot") {
+}
+var layer = Layer.effect(Service31, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const git = yield* Service76;
+  const global = yield* Global.Service;
+  const location = yield* Service74;
+  const lifetime = yield* Scope.Scope;
+  const state = create3({
+    name: "snapshot",
+    initial: () => ({ enabled: true }),
+    editor: (editor) => ({
+      configure: (enabled) => {
+        editor.enabled = enabled;
+      }
+    })
+  });
+  const repositoryFiber = yield* Effect.cached(Effect.gen(function* () {
+    const source = yield* git.repo.discover(location.project.directory);
+    if (!source)
+      return yield* new Error2({ operation: "capture", message: "Project is not a Git repository" });
+    const worktree = AbsolutePath2.make(yield* fs.realPath(source.worktree).pipe(Effect.orDie));
+    const gitDirectory = AbsolutePath2.make(path.join(global.data, "snapshot", location.project.id, Hash.fast(worktree)));
+    const snapshotRepository = (yield* fs.existsSafe(path.join(gitDirectory, "HEAD"))) ? new Repository2({ worktree, gitDirectory, commonDirectory: gitDirectory }) : yield* git.repo.create({ worktree, gitDirectory, seed: source }).pipe(Effect.mapError((cause) => failure("capture", cause)));
+    return { source, worktree, snapshotRepository };
+  }).pipe(Effect.forkIn(lifetime)));
+  const repository = repositoryFiber.pipe(Effect.uninterruptible, Effect.flatMap(Fiber.join));
+  const scope = Effect.fnUntraced(function* (worktree) {
+    const relative = path.relative(worktree, location.directory);
+    if (relative.startsWith("..") || path.isAbsolute(relative))
+      return yield* new Error2({ operation: "capture", message: "Location is outside the project" });
+    return RelativePath2.make(relative.replaceAll("\\", "/") || ".");
+  });
+  const enabled = () => location.vcs?.type === "git" && state.get().enabled;
+  const capture = Effect.fn("Snapshot.capture")(function* () {
+    if (!enabled())
+      return;
+    return yield* Effect.gen(function* () {
+      const repo = yield* repository;
+      return ID5.make(yield* git.tree.capture({
+        repository: repo.snapshotRepository,
+        scopes: [yield* scope(repo.worktree)],
+        ignores: repo.source,
+        maximumUntrackedFileBytes: 2 * 1024 * 1024
+      }));
+    }).pipe(Effect.catch((cause) => Effect.logWarning("failed to capture snapshot", { cause }).pipe(Effect.as(undefined))));
+  });
+  const compare = Effect.fnUntraced(function* (operation, input) {
+    const repo = yield* repository.pipe(Effect.mapError((cause) => failure(operation, cause)));
+    const comparison = {
+      repository: repo.snapshotRepository,
+      from: TreeID2.make(input.from),
+      to: TreeID2.make(input.to)
+    };
+    const files = yield* git.tree.files(comparison).pipe(Effect.mapError((cause) => failure(operation, cause)));
+    const ignored = yield* git.index.ignored({ repository: repo.source, paths: files }).pipe(Effect.mapError((cause) => failure(operation, cause)));
+    return {
+      input: comparison,
+      files,
+      ignored
+    };
+  });
+  const files = Effect.fn("Snapshot.files")(function* (input) {
+    const comparison = yield* compare("files", input);
+    return comparison.files.filter((file) => !comparison.ignored.has(file));
+  });
+  const diff = Effect.fn("Snapshot.diff")(function* (input) {
+    const comparison = yield* compare("diff", input);
+    return yield* git.tree.diff({
+      ...comparison.input,
+      context: input.context,
+      paths: (input.paths ?? comparison.files).filter((file) => !comparison.ignored.has(file))
+    }).pipe(Effect.mapError((cause) => failure("diff", cause)));
+  });
+  const plan = Effect.fnUntraced(function* (worktree, input) {
+    const files = new Map;
+    for (const [file, snapshot] of input.files) {
+      const absolute = path.resolve(worktree, file);
+      if (!FSUtil.contains(worktree, absolute))
+        return yield* new Error2({ operation: "restore", message: `Path escapes the project: ${file}` });
+      files.set(file, TreeID2.make(snapshot));
+    }
+    return files;
+  });
+  const restore = Effect.fn("Snapshot.restore")(function* (input) {
+    if (!enabled())
+      return yield* new Error2({ operation: "restore", message: "Snapshots are disabled" });
+    const repo = yield* repository.pipe(Effect.mapError((cause) => failure("restore", cause)));
+    yield* git.tree.restore({ repository: repo.snapshotRepository, files: yield* plan(repo.worktree, input) }).pipe(Effect.mapError((cause) => failure("restore", cause)));
+  });
+  return Service31.of({ transform: state.transform, reload: state.reload, capture, files, diff, restore });
+}).pipe(Effect.withSpan("Snapshot.boot")));
+var node35 = makeLocationNode({
+  service: Service31,
+  layer,
+  deps: [FSUtil.node, node81, Global.node, node79]
+});
+var noopLayer2 = Layer.succeed(Service31, Service31.of({
+  transform: () => Effect.succeed({ dispose: Effect.void }),
+  reload: () => Effect.void,
+  capture: () => Effect.undefined,
+  files: () => Effect.succeed([]),
+  diff: () => Effect.succeed([]),
+  restore: () => Effect.void
+}));
+function failure(operation, cause) {
+  if (cause instanceof Error2 && cause.operation === operation)
+    return cause;
+  return new Error2({
+    operation,
+    message: cause instanceof globalThis.Error ? cause.message : String(cause),
+    cause
+  });
+}
+
+export { ID5, Error2, Service31, node35, noopLayer2, exports_snapshot2 };

package/dist/chunks/worktree-msx8hqn2.js

@@ -0,0 +1,14 @@
+// src/database/migration/20260227213759_add_session_workspace_id.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260227213759_add_session_workspace_id",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`workspace_id\` text;`);
+      yield* tx.run(`CREATE INDEX \`session_workspace_idx\` ON \`session\` (\`workspace_id\`);`);
+    });
+  }
+};
+var _20260227213759_add_session_workspace_id_default = migration;
+
+export { _20260227213759_add_session_workspace_id_default };