@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-d6vvk673.js

@@ -0,0 +1,149 @@
+import {
+  __export,
+  __require
+} from "./location-mutation-rvfvac9x.js";
+
+// src/provider.ts
+var exports_provider = {};
+__export(exports_provider, {
+  packageName: () => packageName,
+  mergeOverlay: () => mergeOverlay,
+  mergeHeaders: () => mergeHeaders,
+  loadPackage: () => loadPackage,
+  isAISDK: () => isAISDK,
+  aisdk: () => aisdk,
+  Settings: () => Settings,
+  Request: () => Request,
+  Provider: () => exports_provider,
+  LoadError: () => LoadError,
+  Info: () => Info,
+  ID: () => ID,
+  AISDK_PREFIX: () => AISDK_PREFIX
+});
+import { Effect, Schema } from "effect";
+import { Provider } from "@opencode-ai/schema/provider";
+import { importModule, resolveModule } from "@opencode-ai/util/runtime-import";
+var ID = Provider.ID;
+var AISDK_PREFIX = "aisdk:";
+var isAISDK = (value) => value?.startsWith(AISDK_PREFIX) ?? false;
+var aisdk = (value) => isAISDK(value) ? value : `${AISDK_PREFIX}${value}`;
+function packageName(value) {
+  if (value === undefined || !isAISDK(value))
+    return value;
+  return value.slice(AISDK_PREFIX.length);
+}
+var JsonRecord = Schema.Record(Schema.String, Schema.Json);
+var decodeJsonRecord = Schema.decodeUnknownSync(JsonRecord);
+
+class LoadError extends Schema.TaggedErrorClass()("Provider.LoadError", {
+  package: Schema.String,
+  cause: Schema.Defect()
+}) {
+}
+var packages = new Map;
+var builtins = new Map([
+  ["@opencode-ai/ai/providers/amazon-bedrock", () => import("@opencode-ai/ai/providers/amazon-bedrock")],
+  ["@opencode-ai/ai/providers/amazon-bedrock/mantle", () => import("@opencode-ai/ai/providers/amazon-bedrock/mantle")],
+  [
+    "@opencode-ai/ai/providers/amazon-bedrock/mantle/chat",
+    () => import("@opencode-ai/ai/providers/amazon-bedrock/mantle/chat")
+  ],
+  [
+    "@opencode-ai/ai/providers/amazon-bedrock/mantle/responses",
+    () => import("@opencode-ai/ai/providers/amazon-bedrock/mantle/responses")
+  ],
+  ["@opencode-ai/ai/providers/anthropic", () => import("@opencode-ai/ai/providers/anthropic")],
+  ["@opencode-ai/ai/providers/azure", () => import("@opencode-ai/ai/providers/azure")],
+  ["@opencode-ai/ai/providers/azure/chat", () => import("@opencode-ai/ai/providers/azure/chat")],
+  ["@opencode-ai/ai/providers/azure/responses", () => import("@opencode-ai/ai/providers/azure/responses")],
+  ["@opencode-ai/ai/providers/google", () => import("@opencode-ai/ai/providers/google")],
+  ["@opencode-ai/ai/providers/openai", () => import("@opencode-ai/ai/providers/openai")],
+  ["@opencode-ai/ai/providers/openai/chat", () => import("@opencode-ai/ai/providers/openai/chat")],
+  ["@opencode-ai/ai/providers/openai/responses", () => import("@opencode-ai/ai/providers/openai/responses")],
+  ["@opencode-ai/ai/providers/openai-compatible", () => import("@opencode-ai/ai/providers/openai-compatible")],
+  ["@opencode-ai/ai/providers/openrouter", () => import("@opencode-ai/ai/providers/openrouter")],
+  ["@opencode-ai/ai/providers/xai", () => import("@opencode-ai/ai/providers/xai")]
+]);
+var loadPackage = Effect.fn("Provider.loadPackage")(function* (specifier, npm) {
+  const builtin = builtins.get(specifier);
+  if (builtin)
+    return yield* importPackage(specifier, specifier, builtin);
+  const resolved = yield* Effect.sync(() => {
+    if (specifier.startsWith("file://") || specifier.startsWith("@opencode-ai/ai/"))
+      return specifier;
+    try {
+      return import.meta.resolve(specifier);
+    } catch {
+      return;
+    }
+  });
+  if (resolved)
+    return yield* importPackage(specifier, resolved);
+  if (!npm) {
+    return yield* new LoadError({
+      package: specifier,
+      cause: new Error(`Provider package ${specifier} is not installed`)
+    });
+  }
+  const parts = specifier.split("/");
+  const root = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0] ?? specifier;
+  const installed = yield* npm.add(root).pipe(Effect.mapError((cause) => new LoadError({ package: specifier, cause })));
+  const entrypoint = yield* Effect.try({
+    try: () => specifier === root && installed.entrypoint ? installed.entrypoint : resolveModule(specifier, installed.directory),
+    catch: (cause) => new LoadError({ package: specifier, cause })
+  });
+  return yield* importPackage(specifier, entrypoint);
+});
+function mergeOverlay(base, overlay) {
+  if (base === undefined)
+    return overlay && decodeJsonRecord({ ...overlay });
+  if (overlay === undefined)
+    return decodeJsonRecord({ ...base });
+  return decodeJsonRecord(Object.fromEntries(new Set([...Object.keys(base), ...Object.keys(overlay)]).values().map((key) => {
+    const left = base[key];
+    const right = overlay[key];
+    if (right === undefined)
+      return [key, left];
+    if (typeof left === "object" && left !== null && !Array.isArray(left) && typeof right === "object" && right !== null && !Array.isArray(right))
+      return [
+        key,
+        mergeOverlay(left, right) ?? {}
+      ];
+    return [key, right];
+  })));
+}
+function mergeHeaders(base, overlay) {
+  if (base === undefined)
+    return overlay && { ...overlay };
+  if (overlay === undefined)
+    return { ...base };
+  return Object.fromEntries([...Object.entries(base), ...Object.entries(overlay)].reduce((result, entry) => {
+    result.set(entry[0].toLowerCase(), entry);
+    return result;
+  }, new Map).values());
+}
+var Request = Provider.Request;
+var Settings = Provider.Settings;
+var Info = Provider.Info;
+var importPackage = Effect.fn("Provider.importPackage")(function* (specifier, entrypoint, load = () => importModule(entrypoint)) {
+  const module = yield* Effect.tryPromise({
+    try: () => {
+      const existing = packages.get(entrypoint);
+      if (existing)
+        return existing;
+      const loaded = load();
+      packages.set(entrypoint, loaded);
+      return loaded;
+    },
+    catch: (cause) => new LoadError({ package: specifier, cause })
+  });
+  if (typeof module !== "object" || module === null || typeof module.model !== "function") {
+    return yield* new LoadError({
+      package: specifier,
+      cause: new Error(`Provider package ${specifier} does not export model(modelID, settings)`)
+    });
+  }
+  return module;
+});
+
+export { ID, AISDK_PREFIX, isAISDK, aisdk, packageName, LoadError, loadPackage, mergeOverlay, mergeHeaders, Request, Settings, Info, exports_provider };

package/dist/chunks/location-mutation-dbah77c1.js

@@ -0,0 +1,17 @@
+// src/github-copilot/responses/tool/local-shell.ts
+import { z } from "zod/v4";
+var localShellInputSchema = z.object({
+  action: z.object({
+    type: z.literal("exec"),
+    command: z.array(z.string()),
+    timeoutMs: z.number().optional(),
+    user: z.string().optional(),
+    workingDirectory: z.string().optional(),
+    env: z.record(z.string(), z.string()).optional()
+  })
+});
+var localShellOutputSchema = z.object({
+  output: z.string()
+});
+
+export { localShellInputSchema, localShellOutputSchema };

package/dist/chunks/location-mutation-ddjpbqb0.js

@@ -0,0 +1,168 @@
+import {
+  InstructionBlobTable,
+  InstructionStateTable
+} from "./location-mutation-9d2xhdr4.js";
+import {
+  SessionEvent
+} from "./location-mutation-a83yvq99.js";
+import {
+  exports_instructions
+} from "./location-mutation-8k8ks5a6.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/session/instruction-state.ts
+var exports_instruction_state = {};
+__export(exports_instruction_state, {
+  reset: () => reset,
+  preview: () => preview,
+  prepare: () => prepare,
+  observe: () => observe,
+  initialize: () => initialize,
+  initial: () => initial,
+  current: () => current,
+  commit: () => commit,
+  apply: () => apply,
+  advanceEpoch: () => advanceEpoch,
+  InstructionState: () => exports_instruction_state
+});
+import { eq, inArray, sql } from "drizzle-orm";
+import { Effect, Option } from "effect";
+var observe = Effect.fn("InstructionState.observe")(function* (db, instructions, sessionID) {
+  const [observed, stored] = yield* Effect.all([exports_instructions.read(instructions), find(db, sessionID)], {
+    concurrency: "unbounded"
+  });
+  const result = yield* observeAgainst(observed, stored?.current_values);
+  return {
+    sessionID,
+    initial: !stored,
+    previous: stored?.current_values ?? {},
+    ...result
+  };
+});
+var commit = Effect.fn("InstructionState.commit")(function* (db, bus, instructions, observation) {
+  if (!observation.initial && Object.keys(observation.delta).length === 0)
+    return;
+  const text = observation.initial ? "" : yield* renderUpdateText(db, instructions, observation);
+  yield* bus.publish(SessionEvent.InstructionsUpdated, {
+    sessionID: observation.sessionID,
+    delta: observation.delta,
+    ...text.length > 0 ? { text } : {}
+  }, {
+    ...observation.initial ? { metadata: { instructions: { initial: true } } } : {},
+    commit: () => insertBlobs(db, observation.blobs)
+  });
+});
+var renderUpdateText = Effect.fnUntraced(function* (db, instructions, observation) {
+  const replaced = Object.entries(observation.previous).filter(([key]) => Object.hasOwn(observation.delta, key));
+  const blobs = yield* loadBlobs(db, replaced.map(([, hash]) => hash));
+  const previous = Object.fromEntries(replaced.map(([key, hash]) => [key, requireBlob(blobs, hash)]));
+  const admitted = new Map(Object.entries(observation.blobs).map(([hash, value]) => [exports_instructions.Hash.make(hash), value]));
+  return exports_instructions.renderUpdate(instructions, previous, dereferenceDelta(observation.delta, admitted));
+});
+var prepare = Effect.fn("InstructionState.prepare")(function* (db, bus, instructions, sessionID) {
+  yield* commit(db, bus, instructions, yield* observe(db, instructions, sessionID));
+});
+var apply = Effect.fn("InstructionState.apply")(function* (db, sessionID, seq, delta) {
+  const stored = yield* find(db, sessionID);
+  const current = exports_instructions.applyHashDelta(stored?.current_values ?? {}, delta);
+  if (!stored) {
+    yield* db.insert(InstructionStateTable).values({
+      session_id: sessionID,
+      epoch_start: seq,
+      through_seq: seq,
+      initial_values: current,
+      current_values: current
+    }).run().pipe(Effect.orDie);
+    return;
+  }
+  yield* db.update(InstructionStateTable).set({ through_seq: seq, current_values: current }).where(eq(InstructionStateTable.session_id, sessionID)).run().pipe(Effect.orDie);
+});
+var initialize = Effect.fn("InstructionState.initialize")(function* (db, sessionID, seq, values) {
+  yield* db.insert(InstructionStateTable).values({
+    session_id: sessionID,
+    epoch_start: seq,
+    through_seq: seq,
+    initial_values: values,
+    current_values: values
+  }).onConflictDoNothing().run().pipe(Effect.orDie);
+});
+var advanceEpoch = Effect.fn("InstructionState.advanceEpoch")(function* (db, sessionID, epochStart) {
+  yield* db.update(InstructionStateTable).set({
+    epoch_start: epochStart,
+    through_seq: epochStart,
+    initial_values: sql`${InstructionStateTable.current_values}`
+  }).where(eq(InstructionStateTable.session_id, sessionID)).run().pipe(Effect.orDie);
+});
+var reset = Effect.fn("InstructionState.reset")(function* (db, sessionID) {
+  yield* db.delete(InstructionStateTable).where(eq(InstructionStateTable.session_id, sessionID)).run().pipe(Effect.orDie);
+});
+var initial = Effect.fn("InstructionState.initial")(function* (db, sessionID, instructions) {
+  const state = yield* find(db, sessionID);
+  if (!state)
+    return yield* Effect.die(new Error(`Instruction state not found during assembly: ${sessionID}`));
+  const blobs = yield* loadBlobs(db, Object.values(state.initial_values));
+  return exports_instructions.renderInitial(instructions, dereference(state.initial_values, blobs));
+});
+var current = Effect.fn("InstructionState.current")(function* (db, sessionID) {
+  return (yield* find(db, sessionID))?.current_values;
+});
+var preview = Effect.fn("InstructionState.preview")(function* (db, sessionID, instructions, observed) {
+  const state = yield* find(db, sessionID);
+  const result = yield* observeAgainst(observed, state?.current_values);
+  const observedBlobs = new Map(Object.entries(result.blobs).map(([hash, value]) => [exports_instructions.Hash.make(hash), value]));
+  if (!state) {
+    const values = dereference(result.current, observedBlobs);
+    return { initial: exports_instructions.renderInitial(instructions, values), update: "" };
+  }
+  const stored = yield* loadBlobs(db, [...Object.values(state.initial_values), ...Object.values(state.current_values)]);
+  return {
+    initial: exports_instructions.renderInitial(instructions, dereference(state.initial_values, stored)),
+    update: exports_instructions.renderUpdate(instructions, dereference(state.current_values, stored), dereferenceDelta(result.delta, new Map([...stored, ...observedBlobs])))
+  };
+});
+var observeAgainst = Effect.fnUntraced(function* (observed, previous) {
+  const admission = yield* exports_instructions.diff(observed, previous);
+  return {
+    current: exports_instructions.applyHashDelta(previous ?? {}, admission.delta),
+    ...admission
+  };
+});
+var find = Effect.fnUntraced(function* (db, sessionID) {
+  return yield* db.select().from(InstructionStateTable).where(eq(InstructionStateTable.session_id, sessionID)).get().pipe(Effect.orDie);
+});
+var insertBlobs = Effect.fnUntraced(function* (db, blobs) {
+  const rows = Object.entries(blobs).map(([hash, value]) => ({ hash: exports_instructions.Hash.make(hash), value }));
+  if (rows.length === 0)
+    return;
+  yield* db.insert(InstructionBlobTable).values(rows).onConflictDoNothing().run().pipe(Effect.orDie);
+});
+var loadBlobs = Effect.fnUntraced(function* (db, values) {
+  const hashes = [...new Set(values)];
+  const batches = Array.from({ length: Math.ceil(hashes.length / 500) }, (_, index) => hashes.slice(index * 500, (index + 1) * 500));
+  const rows = (yield* Effect.forEach(batches, (batch) => db.select().from(InstructionBlobTable).where(inArray(InstructionBlobTable.hash, batch)).all().pipe(Effect.orDie), { concurrency: 4 })).flat();
+  const blobs = new Map(rows.map((row) => [row.hash, row.value]));
+  for (const hash of hashes) {
+    if (!blobs.has(hash))
+      return yield* Effect.die(new Error(`Instruction blob not found: ${hash}`));
+  }
+  return blobs;
+});
+function dereference(values, blobs) {
+  return Object.fromEntries(Object.entries(values).map(([key, hash]) => [key, requireBlob(blobs, hash)]));
+}
+function dereferenceDelta(delta, blobs) {
+  return Object.fromEntries(Object.entries(delta).map(([key, hash]) => [
+    key,
+    hash === "removed" ? Option.none() : Option.some(requireBlob(blobs, hash))
+  ]));
+}
+function requireBlob(blobs, hash) {
+  const value = blobs.get(hash);
+  if (value === undefined)
+    throw new Error(`Instruction blob not found: ${hash}`);
+  return value;
+}
+
+export { observe, commit, prepare, apply, initialize, advanceEpoch, reset, initial, current, preview, exports_instruction_state };

package/dist/chunks/location-mutation-ddn74qps.js

@@ -0,0 +1,37 @@
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+import {
+  __require
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/provider/anthropic.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var AnthropicPlugin = define({
+  id: "opencode.provider.anthropic",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!exports_provider.isAISDK(item.provider.package))
+          continue;
+        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/anthropic")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = {
+            ...provider.headers,
+            "anthropic-beta": "interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14"
+          };
+        });
+      }
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "@ai-sdk/anthropic")
+        return;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/anthropic"));
+      evt.sdk = mod.createAnthropic(evt.options);
+    }));
+  })
+});
+
+export { AnthropicPlugin };

package/dist/chunks/location-mutation-df3v2q6j.js

@@ -0,0 +1,77 @@
+// src/util/slug.ts
+var Slug;
+((Slug) => {
+  const ADJECTIVES = [
+    "brave",
+    "calm",
+    "clever",
+    "cosmic",
+    "crisp",
+    "curious",
+    "eager",
+    "gentle",
+    "glowing",
+    "happy",
+    "hidden",
+    "jolly",
+    "kind",
+    "lucky",
+    "mighty",
+    "misty",
+    "neon",
+    "nimble",
+    "playful",
+    "proud",
+    "quick",
+    "quiet",
+    "shiny",
+    "silent",
+    "stellar",
+    "sunny",
+    "swift",
+    "tidy",
+    "witty"
+  ];
+  const NOUNS = [
+    "cabin",
+    "cactus",
+    "canyon",
+    "circuit",
+    "comet",
+    "eagle",
+    "engine",
+    "falcon",
+    "forest",
+    "garden",
+    "harbor",
+    "island",
+    "knight",
+    "lagoon",
+    "meadow",
+    "moon",
+    "mountain",
+    "nebula",
+    "orchid",
+    "otter",
+    "panda",
+    "pixel",
+    "planet",
+    "river",
+    "rocket",
+    "sailor",
+    "squid",
+    "star",
+    "tiger",
+    "wizard",
+    "wolf"
+  ];
+  function create() {
+    return [
+      ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)],
+      NOUNS[Math.floor(Math.random() * NOUNS.length)]
+    ].join("-");
+  }
+  Slug.create = create;
+})(Slug ||= {});
+
+export { Slug };

package/dist/chunks/location-mutation-dhcq6c44.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 };

package/dist/chunks/location-mutation-dhphtf1x.js

@@ -0,0 +1,45 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/mime.ts
+var exports_mime = {};
+__export(exports_mime, {
+  detect: () => detect,
+  Mime: () => exports_mime
+});
+function detect(bytes) {
+  if (startsWith(bytes, [137, 80, 78, 71, 13, 10, 26, 10]))
+    return "image/png";
+  if (startsWith(bytes, [255, 216, 255]))
+    return "image/jpeg";
+  if (startsWith(bytes, [71, 73, 70, 56]))
+    return "image/gif";
+  if (startsWith(bytes, [66, 77]))
+    return "image/bmp";
+  if (startsWith(bytes, [37, 80, 68, 70, 45]))
+    return "application/pdf";
+  if (startsWith(bytes, [82, 73, 70, 70]) && startsWith(bytes.subarray(8), [87, 69, 66, 80]))
+    return "image/webp";
+  if (startsWith(bytes.subarray(4), [102, 116, 121, 112]) && (startsWith(bytes.subarray(8), [97, 118, 105, 102]) || startsWith(bytes.subarray(8), [97, 118, 105, 115])))
+    return "image/avif";
+  return isText(bytes) ? "text/plain" : "application/octet-stream";
+}
+function startsWith(bytes, prefix) {
+  return prefix.every((value, index) => bytes[index] === value);
+}
+function isText(bytes) {
+  if (bytes.length === 0)
+    return true;
+  if (bytes.includes(0))
+    return false;
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(bytes, { stream: true });
+  } catch {
+    return false;
+  }
+  const controls = bytes.reduce((count, byte) => count + Number(byte < 9 || byte > 13 && byte < 32), 0);
+  return controls / bytes.length <= 0.3;
+}
+
+export { detect, exports_mime };

package/dist/chunks/location-mutation-dht5baf0.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/location-mutation-dkmkay92.js

@@ -0,0 +1,9 @@
+// src/filesystem/watcher-binding.ts
+import { createRequire } from "node:module";
+function load() {
+  const require2 = createRequire(import.meta.url);
+  const libc = typeof OPENCODE_LIBC === "undefined" ? undefined : OPENCODE_LIBC;
+  return require2(process.env.OPENCODE_PARCEL_WATCHER_PATH ?? `@parcel/watcher-${process.platform}-${process.arch}${process.platform === "linux" ? `-${libc || "glibc"}` : ""}`);
+}
+
+export { load };

package/dist/chunks/location-mutation-dppgrtwb.js

@@ -0,0 +1,126 @@
+// src/database/migration/20260804233008_loose_psylocke.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260804233008_loose_psylocke",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`kv\` (
+          \`key\` text PRIMARY KEY,
+          \`value\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`instruction_blob\` (
+          \`hash\` text PRIMARY KEY,
+          \`value\` text
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`instruction_entry\` (
+          \`session_id\` text NOT NULL,
+          \`key\` text NOT NULL,
+          \`value\` text,
+          \`removed\` integer DEFAULT false NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          CONSTRAINT \`instruction_entry_pk\` PRIMARY KEY(\`session_id\`, \`key\`),
+          CONSTRAINT \`fk_instruction_entry_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`instruction_state\` (
+          \`session_id\` text PRIMARY KEY,
+          \`epoch_start\` integer NOT NULL,
+          \`through_seq\` integer NOT NULL,
+          \`initial_values\` text NOT NULL,
+          \`current_values\` text NOT NULL,
+          CONSTRAINT \`fk_instruction_state_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`session_pending\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`data\` text NOT NULL,
+          \`delivery\` text,
+          \`admitted_seq\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_pending_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`session_v2\` (
+          \`id\` text PRIMARY KEY,
+          \`project_id\` text NOT NULL,
+          \`workspace_id\` text,
+          \`parent_id\` text,
+          \`fork_session_id\` text,
+          \`fork_boundary\` text,
+          \`slug\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`path\` text,
+          \`title\` text,
+          \`version\` text NOT NULL,
+          \`share_url\` text,
+          \`summary_additions\` integer,
+          \`summary_deletions\` integer,
+          \`summary_files\` integer,
+          \`summary_diffs\` text,
+          \`metadata\` text,
+          \`cost\` real DEFAULT 0 NOT NULL,
+          \`tokens_input\` integer DEFAULT 0 NOT NULL,
+          \`tokens_output\` integer DEFAULT 0 NOT NULL,
+          \`tokens_reasoning\` integer DEFAULT 0 NOT NULL,
+          \`tokens_cache_read\` integer DEFAULT 0 NOT NULL,
+          \`tokens_cache_write\` integer DEFAULT 0 NOT NULL,
+          \`revert\` text,
+          \`permission\` text,
+          \`agent\` text,
+          \`model\` text,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`time_compacting\` integer,
+          \`time_archived\` integer,
+          \`time_suspended\` integer,
+          CONSTRAINT \`fk_session_v2_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`ALTER TABLE \`event\` ADD \`created\` integer DEFAULT 0 NOT NULL;`);
+      yield* tx.run(`
+        CREATE TABLE IF NOT EXISTS \`__new_session_message\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`seq\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_session_message_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`DROP TABLE \`session_message\`;`);
+      yield* tx.run(`ALTER TABLE \`__new_session_message\` RENAME TO \`session_message\`;`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_message_session_seq_idx\` ON \`session_message\` (\`session_id\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_type_seq_idx\` ON \`session_message\` (\`session_id\`,\`type\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_time_created_id_idx\` ON \`session_message\` (\`session_id\`,\`time_created\`,\`id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_time_created_idx\` ON \`session_message\` (\`time_created\`);`);
+      yield* tx.run(`CREATE INDEX \`session_pending_session_delivery_seq_idx\` ON \`session_pending\` (\`session_id\`,\`delivery\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_pending_session_compaction_idx\` ON \`session_pending\` (\`session_id\`) WHERE "session_pending"."type" = 'compaction';`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_pending_session_admitted_seq_idx\` ON \`session_pending\` (\`session_id\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_project_idx\` ON \`session_v2\` (\`project_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_workspace_idx\` ON \`session_v2\` (\`workspace_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_parent_idx\` ON \`session_v2\` (\`parent_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_v2_time_suspended_idx\` ON \`session_v2\` (\`time_suspended\`) WHERE "session_v2"."time_suspended" is not null;`);
+      yield* tx.run(`DROP TABLE \`data_migration\`;`);
+      yield* tx.run(`DROP TABLE \`session_context_epoch\`;`);
+      yield* tx.run(`DROP TABLE \`session_input\`;`);
+    });
+  }
+};
+var _20260804233008_loose_psylocke_default = migration;
+
+export { _20260804233008_loose_psylocke_default };