@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-710w2ech.js

@@ -0,0 +1,24 @@
+import {
+  packageName2
+} from "./worktree-9qn3qky1.js";
+
+// src/plugin/provider/cerebras.ts
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var CerebrasPlugin2 = define({
+  id: "opencode.provider.cerebras",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        const name = packageName2(item.provider.package);
+        if (name !== "@ai-sdk/cerebras" && name !== "@opencode/ai/providers/cerebras")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = { ...provider.headers, "X-Cerebras-3rd-Party-Integration": "opencode" };
+        });
+      }
+    });
+  })
+});
+
+export { CerebrasPlugin2 };

package/dist/chunks/worktree-71q4at8m.js

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

package/dist/chunks/worktree-76j77zm8.js

@@ -0,0 +1,44 @@
+import {
+  Service74,
+  node79
+} from "./worktree-z82wee6n.js";
+import {
+  Service27
+} from "./worktree-1x11rq2a.js";
+import {
+  Service59,
+  node64
+} from "./worktree-nrs7ag5n.js";
+import {
+  node20
+} from "./worktree-dvgvg99t.js";
+import {
+  node6
+} from "./worktree-047x8f8f.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/worktree/refresh.ts
+var exports_refresh = {};
+__export(exports_refresh, {
+  WorktreeRefresh: () => exports_refresh,
+  node: () => node5
+});
+import { Effect, Layer } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+var layer = Layer.effectDiscard(Effect.gen(function* () {
+  const location = yield* Service74;
+  const plugins = yield* Service27;
+  const worktrees = yield* Service59;
+  if (location.workspaceID)
+    return;
+  yield* plugins.awaitActivation.pipe(Effect.andThen(worktrees.refresh()), Effect.catchCause((cause) => Effect.logWarning("worktree refresh failed", { cause })), Effect.forkScoped);
+}));
+var node5 = makeLocationNode({
+  name: "worktree-refresh",
+  layer,
+  deps: [node64, node79, node20, node6]
+});
+
+export { node5, exports_refresh };

package/dist/chunks/worktree-7akdwqpd.js

@@ -0,0 +1,16 @@
+// src/database/migration/20260601010001_normalize_storage_paths.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260601010001_normalize_storage_paths",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`UPDATE project SET worktree = REPLACE(worktree, char(92), '/') WHERE worktree GLOB '[A-Za-z]:' || char(92) || '*' OR worktree LIKE char(92) || char(92) || '%';`);
+      yield* tx.run(`UPDATE project SET sandboxes = REPLACE(sandboxes, char(92) || char(92), '/') WHERE instr(sandboxes, char(92)) > 0 AND (worktree GLOB '[A-Za-z]:*' OR worktree LIKE '//%');`);
+      yield* tx.run(`UPDATE session SET directory = REPLACE(directory, char(92), '/') WHERE directory GLOB '[A-Za-z]:' || char(92) || '*' OR directory LIKE char(92) || char(92) || '%';`);
+      yield* tx.run(`UPDATE session SET path = REPLACE(path, char(92), '/') WHERE path IS NOT NULL AND instr(path, char(92)) > 0 AND (directory GLOB '[A-Za-z]:*' OR directory LIKE '//%');`);
+    });
+  }
+};
+var _20260601010001_normalize_storage_paths_default = migration;
+
+export { _20260601010001_normalize_storage_paths_default };

package/dist/chunks/worktree-7bmhse3q.js

@@ -0,0 +1,118 @@
+import {
+  getTableColumnsRuntime2,
+  orderSelectedFields2,
+  mapUpdateSet2
+} from "./worktree-emrn6kk6.js";
+
+// src/database/drizzle/sqlite-core/effect/insert.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind, is } from "drizzle-orm/entity";
+import { SQL, sql } from "drizzle-orm/sql/sql";
+import { extractUsedTable } from "drizzle-orm/sqlite-core/utils";
+import { haveSameKeys } from "drizzle-orm/utils";
+import { QueryBuilder } from "drizzle-orm/sqlite-core/query-builders/query-builder";
+class SQLiteEffectInsertBuilder2 {
+  table;
+  session;
+  dialect;
+  withList;
+  static [entityKind] = "SQLiteEffectInsertBuilder";
+  constructor(table, session, dialect, withList) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.withList = withList;
+  }
+  values(values) {
+    values = Array.isArray(values) ? values : [values];
+    if (values.length === 0) {
+      throw new Error("values() must be called with at least one value");
+    }
+    return new SQLiteEffectInsertBase2(this.table, values, this.session, this.dialect, this.withList);
+  }
+  select(selectQuery) {
+    const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder) : selectQuery;
+    if (!is(select, SQL) && !haveSameKeys(getTableColumnsRuntime2(this.table), select._.selectedFields)) {
+      throw new Error("Insert select error: selected fields are not the same or are in a different order compared to the table definition");
+    }
+    return new SQLiteEffectInsertBase2(this.table, select, this.session, this.dialect, this.withList, true);
+  }
+}
+
+class SQLiteEffectInsertBase2 {
+  effectSession;
+  effectDialect;
+  static [entityKind] = "SQLiteEffectInsert";
+  config;
+  constructor(table, values, effectSession, effectDialect, withList, select) {
+    this.effectSession = effectSession;
+    this.effectDialect = effectDialect;
+    this.config = { table, values, withList, select };
+  }
+  returning(fields = getTableColumnsRuntime2(this.config.table)) {
+    this.config.returning = orderSelectedFields2(fields);
+    return this;
+  }
+  onConflictDoNothing(config = {}) {
+    if (!this.config.onConflict)
+      this.config.onConflict = [];
+    if (config.target === undefined) {
+      this.config.onConflict.push(sql` on conflict do nothing`);
+      return this;
+    }
+    const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
+    const whereSql = config.where ? sql` where ${config.where}` : sql``;
+    this.config.onConflict.push(sql` on conflict ${targetSql} do nothing${whereSql}`);
+    return this;
+  }
+  onConflictDoUpdate(config) {
+    if (config.where && (config.targetWhere || config.setWhere)) {
+      throw new Error('You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.');
+    }
+    if (!this.config.onConflict)
+      this.config.onConflict = [];
+    const whereSql = config.where ? sql` where ${config.where}` : undefined;
+    const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : undefined;
+    const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : undefined;
+    const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
+    const setSql = this.effectDialect.buildUpdateSet(this.config.table, mapUpdateSet2(this.config.table, config.set));
+    this.config.onConflict.push(sql` on conflict ${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`);
+    return this;
+  }
+  getSQL() {
+    return this.effectDialect.buildInsertQuery(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: "insert",
+      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(SQLiteEffectInsertBase2);
+
+export { SQLiteEffectInsertBuilder2, SQLiteEffectInsertBase2 };

package/dist/chunks/worktree-7c3npc5w.js

@@ -0,0 +1,335 @@
+import {
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  Service74,
+  node79
+} from "./worktree-z82wee6n.js";
+import {
+  Service52,
+  node55
+} from "./worktree-pr7ch8ks.js";
+import {
+  cleanup3
+} from "./worktree-gd4qta3r.js";
+import {
+  Service48,
+  args2,
+  node51
+} from "./worktree-w55j1d38.js";
+import {
+  Service77,
+  node82
+} from "./worktree-r05k2dy1.js";
+import {
+  Service47,
+  node50
+} from "./worktree-52fpbh6z.js";
+import {
+  SessionSchema2
+} from "./worktree-2f04pwep.js";
+import {
+  latest2,
+  Service54,
+  node58
+} from "./worktree-r82b328h.js";
+import {
+  MAX_LINES2,
+  MAX_BYTES2
+} from "./worktree-qr42g2ex.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/shell.ts
+var exports_shell4 = {};
+__export(exports_shell4, {
+  DIRECTORY: () => DIRECTORY2,
+  NotFoundError: () => NotFoundError6,
+  RETENTION: () => RETENTION2,
+  Service: () => Service46,
+  Shell: () => exports_shell4,
+  cleanup: () => cleanup2,
+  node: () => node49
+});
+import path from "path";
+import { Context, Deferred, Duration, Effect, Fiber, Latch, Layer, Schema, Schedule, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { produce } from "immer";
+import { Shell } from "@opencode/schema/shell";
+import { AppProcess } from "@opencode/util/process";
+import { makeGlobalNode, makeLocationNode } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+class NotFoundError6 extends Schema.TaggedError()("Shell.NotFoundError", {
+  id: Shell.ID
+}) {
+}
+var EXITED_LIMIT = 25;
+var RETENTION2 = Duration.days(7);
+var DIRECTORY2 = "shell";
+
+class Service46 extends Context.Service()("@opencode/Shell") {
+}
+var cleanup2 = Effect.fn("Shell.cleanup")(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const directory = path.join(global.data, DIRECTORY2);
+  const projects = yield* fs.readDirectoryEntries(directory).pipe(Effect.map((entries) => entries.filter((entry) => entry.type === "directory")), Effect.orElseSucceed(() => []));
+  const files = yield* Effect.forEach(projects, (project) => fs.readDirectoryEntries(path.join(directory, project.name)).pipe(Effect.map((entries) => entries.flatMap((entry) => entry.type === "file" && /^sh_[0-9a-f]{12}.*\.out$/.test(entry.name) ? [path.join(directory, project.name, entry.name)] : [])), Effect.orElseSucceed(() => [])), { concurrency: 8 });
+  yield* cleanup3(fs, files.flat(), RETENTION2);
+});
+var cleanupLayer = Layer.effectDiscard(cleanup2().pipe(Effect.repeat(Schedule.spaced(Duration.hours(1))), Effect.forkScoped));
+var cleanupNode = makeGlobalNode({
+  name: "shell-output-cleanup",
+  layer: cleanupLayer,
+  deps: [FSUtil.node, Global.node]
+});
+var layer = () => Layer.effect(Service46, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const location = yield* Service74;
+  const global = yield* Global.Service;
+  const shell = yield* Service48;
+  const environment = yield* Service52;
+  const hooks = yield* Service77;
+  const environments = yield* Service47;
+  const config = yield* Service54;
+  const context = yield* Effect.context();
+  const runFork = Effect.runForkWith(context);
+  const commands = new Map;
+  const exitOrder = [];
+  const outputDir = path.join(global.data, DIRECTORY2, location.project.id);
+  const { mkdir, unlink } = yield* Effect.promise(() => import("fs/promises"));
+  const { createWriteStream, createReadStream } = yield* Effect.promise(() => import("fs"));
+  yield* Effect.promise(() => mkdir(outputDir, { recursive: true }));
+  yield* Effect.addFinalizer(() => Effect.gen(function* () {
+    for (const command of commands.values()) {
+      if (command.timeoutFiber)
+        yield* Fiber.interrupt(command.timeoutFiber);
+      yield* Deferred.interrupt(command.done);
+    }
+    commands.clear();
+    exitOrder.length = 0;
+  }));
+  const require2 = Effect.fnUntraced(function* (id) {
+    const command = commands.get(id);
+    if (!command)
+      return yield* new NotFoundError6({ id });
+    return command;
+  });
+  const removeCommand = Effect.fnUntraced(function* (id) {
+    const command = commands.get(id);
+    const index = exitOrder.indexOf(id);
+    if (index !== -1)
+      exitOrder.splice(index, 1);
+    if (!command)
+      return;
+    commands.delete(id);
+    if (command.timeoutFiber)
+      yield* Fiber.interrupt(command.timeoutFiber);
+    yield* Deferred.fail(command.done, new NotFoundError6({ id }));
+    yield* Effect.promise(() => unlink(command.file).catch(() => {}));
+    yield* bus.publish(Shell.Event.Deleted, { id });
+  });
+  const remove = Effect.fn("Shell.remove")(function* (id) {
+    yield* require2(id);
+    yield* removeCommand(id);
+  });
+  const list = Effect.fn("Shell.list")(function* () {
+    return Array.from(commands.values()).filter((command) => command.info.status === "running").map((command) => command.info);
+  });
+  const get = Effect.fn("Shell.get")(function* (id) {
+    return (yield* require2(id)).info;
+  });
+  const wait = Effect.fn("Shell.wait")(function* (id) {
+    return yield* Deferred.await((yield* require2(id)).done);
+  });
+  const timeout = Effect.fn("Shell.timeout")(function* (id, duration) {
+    const command = yield* require2(id);
+    if (command.info.status !== "running" || !command.timeout)
+      return command.info;
+    yield* command.timeout(duration);
+    return command.info;
+  });
+  const output = Effect.fnUntraced(function* (id, input) {
+    const command = yield* require2(id);
+    const cursor = input?.cursor ?? 0;
+    const limit = input?.limit ?? 65536;
+    if (cursor >= command.size)
+      return { output: "", cursor: command.size, size: command.size, truncated: false };
+    const start = Math.max(0, cursor);
+    const length = Math.min(limit, command.size - start);
+    const buffer = Buffer.alloc(length);
+    const bytesRead = yield* Effect.promise(() => new Promise((resolve) => {
+      const stream = createReadStream(command.file, { start, end: start + length - 1 });
+      let offset = 0;
+      stream.on("data", (chunk) => {
+        const bytes = Buffer.from(chunk);
+        bytes.copy(buffer, offset);
+        offset += bytes.length;
+      });
+      stream.on("end", () => resolve(offset));
+      stream.on("error", () => resolve(0));
+    }));
+    return {
+      output: buffer.subarray(0, bytesRead).toString("utf8"),
+      cursor: start + bytesRead,
+      size: command.size,
+      truncated: false
+    };
+  });
+  const result = Effect.fn("Shell.result")(function* (started) {
+    const info = yield* wait(started.id).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed({ ...started, status: "killed", time: { ...started.time, completed: Date.now() } })));
+    const capture = yield* Effect.gen(function* () {
+      const limits = latest2(yield* config.entries(), "tool_output");
+      const maxLines = limits?.max_lines ?? MAX_LINES2;
+      const maxBytes = limits?.max_bytes ?? MAX_BYTES2;
+      const latest = yield* output(info.id, { cursor: Number.MAX_SAFE_INTEGER });
+      const page = yield* output(info.id, { cursor: Math.max(0, latest.size - maxBytes), limit: maxBytes });
+      const lines = page.output.split(`
+`);
+      if (page.output.endsWith(`
+`))
+        lines.pop();
+      const truncated = latest.size > maxBytes || lines.length > maxLines;
+      const text = lines.length > maxLines ? lines.slice(-maxLines).join(`
+`) : page.output;
+      const notice = truncated ? `
+
+[output truncated; full output saved to: ${info.file}]` : "";
+      return { output: `${text || "(no output)"}${notice}`, truncated };
+    }).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed(undefined)));
+    return { info, capture };
+  });
+  const create = Effect.fn("Shell.create")(function* (input, before) {
+    const sessionID = input.metadata?.sessionID;
+    const sessionEnvironment = location.workspaceID === undefined && Schema.is(SessionSchema2.ID)(sessionID) ? yield* environments.get(sessionID) : undefined;
+    const invocation = {
+      command: input.command,
+      cwd: input.cwd ?? location.directory,
+      timeout: input.timeout,
+      shell: input.shell ?? (yield* shell.resolve({ priority: "config" })),
+      env: {
+        ...sessionEnvironment ?? process.env,
+        TERM: "xterm-256color",
+        OPENCODE_TERMINAL: "1"
+      }
+    };
+    yield* hooks.trigger("shell", "create.before", invocation);
+    if (before)
+      yield* before(invocation);
+    const id = Shell.ID.ascending();
+    const args = args2(invocation.shell, invocation.command);
+    const file = path.join(outputDir, `${id}.out`);
+    const info = {
+      id,
+      status: "running",
+      command: invocation.command,
+      cwd: invocation.cwd,
+      shell: invocation.shell,
+      file,
+      metadata: input.metadata ?? {},
+      time: { started: Date.now() }
+    };
+    const ready = Deferred.makeUnsafe();
+    runFork(Effect.scoped(Effect.gen(function* () {
+      const handle = yield* environment.spawner.spawn(ChildProcess.make(invocation.shell, args, {
+        cwd: invocation.cwd,
+        env: invocation.env,
+        stdin: "ignore",
+        detached: process.platform !== "win32",
+        forceKillAfter: Duration.seconds(3)
+      })).pipe(Effect.mapError((cause) => new AppProcess.AppProcessError({ command: invocation.command, cause })));
+      const command = {
+        info: produce(info, (draft) => {
+          draft.pid = handle.pid;
+        }),
+        file,
+        size: 0,
+        done: Deferred.makeUnsafe()
+      };
+      commands.set(id, command);
+      const stream = createWriteStream(file);
+      const outputDone = Latch.makeUnsafe();
+      const pump = handle.all.pipe(Stream.runForEach((chunk) => Effect.sync(() => {
+        stream.write(chunk);
+        command.size += chunk.length;
+      })));
+      runFork(Effect.gen(function* () {
+        yield* pump.pipe(Effect.catch(() => Effect.void));
+        yield* Effect.promise(() => new Promise((resolve) => {
+          stream.end(() => resolve());
+        }));
+        yield* outputDone.open;
+      }));
+      yield* Effect.promise(() => new Promise((resolve) => {
+        stream.once("open", () => resolve());
+        stream.once("error", () => resolve());
+      }));
+      const finish = (status, exit, beforeWait = Effect.void) => Effect.gen(function* () {
+        if (command.info.status !== "running")
+          return;
+        command.info = produce(command.info, (draft) => {
+          draft.status = status;
+          if (exit !== undefined)
+            draft.exit = exit;
+          draft.time.completed = Date.now();
+        });
+        yield* beforeWait;
+        yield* outputDone.await;
+        yield* Deferred.succeed(command.done, command.info);
+        yield* bus.publish(Shell.Event.Exited, {
+          id,
+          ...exit !== undefined ? { exit } : {},
+          status
+        });
+        exitOrder.push(id);
+        while (exitOrder.length > EXITED_LIMIT) {
+          const oldest = exitOrder[0];
+          if (!oldest)
+            break;
+          yield* removeCommand(oldest);
+        }
+        const timeoutFiber = command.timeoutFiber;
+        command.timeout = undefined;
+        command.timeoutFiber = undefined;
+        if (timeoutFiber)
+          yield* Fiber.interrupt(timeoutFiber);
+      });
+      command.timeout = (duration) => Effect.gen(function* () {
+        if (command.timeoutFiber)
+          yield* Fiber.interrupt(command.timeoutFiber);
+        command.timeoutFiber = undefined;
+        if (duration === 0 || command.info.status !== "running")
+          return;
+        command.timeoutFiber = runFork(Effect.sleep(Duration.millis(duration)).pipe(Effect.flatMap(() => finish("timeout", undefined, handle.kill({ forceKillAfter: Duration.seconds(3) }).pipe(Effect.catch(() => Effect.void))))));
+      });
+      yield* command.timeout(invocation.timeout);
+      runFork(handle.exitCode.pipe(Effect.flatMap((code) => finish("exited", code)), Effect.catch(() => finish("exited"))));
+      yield* bus.publish(Shell.Event.Created, { info });
+      yield* Deferred.succeed(ready, command);
+      yield* Deferred.await(command.done).pipe(Effect.catch(() => Effect.void));
+    })).pipe(Effect.catchTag("AppProcessError", (error) => Deferred.fail(ready, error))));
+    const command = yield* Deferred.await(ready);
+    return command.info;
+  });
+  return Service46.of({ create, list, get, wait, result, timeout, output, remove });
+}));
+var node49 = makeLocationNode({
+  service: Service46,
+  layer: layer(),
+  deps: [
+    node84,
+    node79,
+    Global.node,
+    node51,
+    node55,
+    node82,
+    node50,
+    node58,
+    cleanupNode
+  ]
+});
+
+export { NotFoundError6, RETENTION2, DIRECTORY2, Service46, cleanup2, node49, exports_shell4 };

package/dist/chunks/worktree-7hhzr64w.js

@@ -0,0 +1,115 @@
+import {
+  Service80,
+  node85
+} from "./worktree-ecj1wrg9.js";
+import {
+  Key4,
+  removed2,
+  make21,
+  combine2
+} from "./worktree-eaj1djv9.js";
+import {
+  InstructionEntryTable2
+} from "./worktree-5c4hm403.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session/instruction-entry.ts
+var exports_instruction_entry = {};
+__export(exports_instruction_entry, {
+  Info: () => Info4,
+  InstructionEntry: () => exports_instruction_entry,
+  Key: () => Key2,
+  MaxValueBytes: () => MaxValueBytes2,
+  Service: () => Service21,
+  Snapshot: () => Snapshot2,
+  ValueTooLargeError: () => ValueTooLargeError2,
+  initialize: () => initialize2,
+  node: () => node26,
+  snapshot: () => snapshot2
+});
+import { and, asc, eq, isNotNull, isNull, ne, or } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { InstructionEntry } from "@opencode/schema/instruction-entry";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+var Key2 = InstructionEntry.Key;
+var Info4 = InstructionEntry.Info;
+var Snapshot2 = InstructionEntry.Snapshot;
+var MaxValueBytes2 = InstructionEntry.MaxValueBytes;
+var ValueTooLargeError2 = InstructionEntry.ValueTooLargeError;
+var InsertBatchSize = 10;
+var snapshot2 = Effect.fn("InstructionEntry.snapshot")(function* (db, sessionID) {
+  return yield* db.select({
+    key: InstructionEntryTable2.key,
+    value: InstructionEntryTable2.value,
+    removed: InstructionEntryTable2.removed
+  }).from(InstructionEntryTable2).where(eq(InstructionEntryTable2.session_id, sessionID)).orderBy(asc(InstructionEntryTable2.key)).all().pipe(Effect.orDie);
+});
+var initialize2 = Effect.fn("InstructionEntry.initialize")(function* (db, sessionID, entries, created) {
+  const batches = Array.from({ length: Math.ceil(entries.length / InsertBatchSize) }, (_, index) => entries.slice(index * InsertBatchSize, (index + 1) * InsertBatchSize));
+  yield* Effect.forEach(batches, (batch) => db.insert(InstructionEntryTable2).values(batch.map((entry) => ({
+    ...entry,
+    session_id: sessionID,
+    time_created: created,
+    time_updated: created
+  }))).run().pipe(Effect.orDie), { discard: true });
+});
+
+class Service21 extends Context.Service()("@opencode/InstructionEntry") {
+}
+var renderValue = (value) => typeof value === "string" ? value : JSON.stringify(value, null, 2);
+var renderBlock = (key, value) => [`<context key="${key}">`, renderValue(value), "</context>"].join(`
+`);
+var source = (entry) => make21({
+  key: Key4.make(`api/${entry.key}`),
+  codec: Schema.toCodecJson(Schema.Json),
+  read: Effect.succeed(entry.removed ? removed2 : entry.value),
+  render: {
+    initial: (value) => renderBlock(entry.key, value),
+    changed: (_previous, value) => [
+      `The context under "${entry.key}" changed and supersedes the previous value:`,
+      renderBlock(entry.key, value)
+    ].join(`
+`),
+    removed: () => `The context under "${entry.key}" no longer applies. Disregard it.`
+  }
+});
+var layer = Layer.effect(Service21, Effect.gen(function* () {
+  const { db } = yield* Service80;
+  const rows = Effect.fnUntraced(function* (sessionID, includeRemoved) {
+    return yield* db.select({
+      key: InstructionEntryTable2.key,
+      value: InstructionEntryTable2.value,
+      removed: InstructionEntryTable2.removed
+    }).from(InstructionEntryTable2).where(and(eq(InstructionEntryTable2.session_id, sessionID), includeRemoved ? undefined : eq(InstructionEntryTable2.removed, false))).orderBy(asc(InstructionEntryTable2.key)).all().pipe(Effect.orDie);
+  });
+  const list = Effect.fn("InstructionEntry.list")(function* (sessionID) {
+    return (yield* rows(sessionID, false)).map((row) => ({ key: row.key, value: row.value }));
+  });
+  const put = Effect.fn("InstructionEntry.put")(function* (input) {
+    const actualBytes = Buffer.byteLength(JSON.stringify(input.value), "utf8");
+    if (actualBytes > MaxValueBytes2)
+      yield* new ValueTooLargeError2({
+        actualBytes,
+        maxBytes: MaxValueBytes2,
+        message: `Instruction entry value is ${actualBytes} bytes; the limit is ${MaxValueBytes2} bytes`
+      });
+    const changed = input.value === null ? isNotNull(InstructionEntryTable2.value) : or(isNull(InstructionEntryTable2.value), ne(InstructionEntryTable2.value, input.value));
+    yield* db.insert(InstructionEntryTable2).values({ session_id: input.sessionID, key: input.key, value: input.value, removed: false }).onConflictDoUpdate({
+      target: [InstructionEntryTable2.session_id, InstructionEntryTable2.key],
+      set: { value: input.value, removed: false, time_updated: Date.now() },
+      setWhere: or(eq(InstructionEntryTable2.removed, true), changed)
+    }).run().pipe(Effect.orDie);
+  });
+  const remove = Effect.fn("InstructionEntry.remove")(function* (input) {
+    yield* db.update(InstructionEntryTable2).set({ value: null, removed: true, time_updated: Date.now() }).where(and(eq(InstructionEntryTable2.session_id, input.sessionID), eq(InstructionEntryTable2.key, input.key), eq(InstructionEntryTable2.removed, false))).run().pipe(Effect.orDie);
+  });
+  const load = Effect.fn("InstructionEntry.load")(function* (sessionID) {
+    return combine2((yield* rows(sessionID, true)).map(source));
+  });
+  return Service21.of({ list, put, remove, load });
+}));
+var node26 = makeLocationNode({ service: Service21, layer, deps: [node85] });
+
+export { Key2, Info4, Snapshot2, MaxValueBytes2, ValueTooLargeError2, snapshot2, initialize2, Service21, node26, exports_instruction_entry };

package/dist/chunks/worktree-7m9af43g.js

@@ -0,0 +1,16 @@
+// src/database/migration/20260312043431_session_message_cursor.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260312043431_session_message_cursor",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP INDEX IF EXISTS \`message_session_idx\`;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`part_message_idx\`;`);
+      yield* tx.run(`CREATE INDEX \`message_session_time_created_id_idx\` ON \`message\` (\`session_id\`,\`time_created\`,\`id\`);`);
+      yield* tx.run(`CREATE INDEX \`part_message_id_id_idx\` ON \`part\` (\`message_id\`,\`id\`);`);
+    });
+  }
+};
+var _20260312043431_session_message_cursor_default = migration;
+
+export { _20260312043431_session_message_cursor_default };