@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-say7pt71.js

@@ -0,0 +1,207 @@
+import {
+  ID15,
+  Service73
+} from "./worktree-7vcja736.js";
+import {
+  latest2,
+  Service54
+} from "./worktree-r82b328h.js";
+import {
+  SessionSchema2
+} from "./worktree-2f04pwep.js";
+import {
+  Service37
+} from "./worktree-y5h7afh3.js";
+import {
+  evaluate2,
+  Service70
+} from "./worktree-k56d8zdx.js";
+import {
+  Service17
+} from "./worktree-p9690q97.js";
+import {
+  NO_TEXT2
+} from "./worktree-x1ezjp6w.js";
+import {
+  make5
+} from "./worktree-qt1vhyrn.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/tool/plugin/subagent.ts
+var exports_subagent = {};
+__export(exports_subagent, {
+  Input: () => Input11,
+  Output: () => Output7,
+  Plugin: () => Plugin12,
+  SubagentTool: () => exports_subagent,
+  description: () => description5,
+  name: () => name11
+});
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema } from "effect";
+var name11 = "subagent";
+var backgroundResult = (sessionID) => ({
+  sessionID,
+  status: "running",
+  output: [
+    `The subagent is working in the background (sessionID: ${sessionID}). You will be notified automatically when it finishes.`,
+    "DO NOT sleep, poll for progress, ask the subagent for status, or duplicate this subagent's work; avoid working with the same files or topics it is using.",
+    "Work on non-overlapping tasks, or briefly tell the user what you launched and end your response."
+  ].join(`
+`)
+});
+var Input11 = Schema.Struct({
+  agent: Schema.String.annotate({ description: "The type of specialized agent to use for this task" }),
+  description: Schema.String.annotate({ description: "A short 3-5 word label for the task, displayed to the user" }),
+  prompt: Schema.String.annotate({ description: "The task for the subagent to perform" }),
+  sessionID: Schema.optionalKey(SessionSchema2.ID).annotate({
+    description: "Continue a specific previous subagent conversation by passing its sessionID. Calls without a sessionID start a new conversation."
+  }),
+  background: Schema.optionalKey(Schema.Boolean).annotate({
+    description: "Run the subagent in the background and return immediately. You will be notified when it completes. DO NOT sleep, poll, or proactively check on its progress."
+  })
+});
+var Output7 = Schema.Struct({
+  sessionID: SessionSchema2.ID,
+  status: Schema.Literals(["completed", "running"]),
+  output: Schema.String
+});
+var description5 = [
+  "Spawns an agent in a child session to work on the specified task.",
+  "The output includes a sessionID you can pass back later to continue that specific conversation with the subagent.",
+  "New child sessions start with fresh context, so include all relevant context and instructions when you don't pass a sessionID.",
+  "Foreground (default) runs the subagent to completion and returns its final response.",
+  "Background mode (background=true) launches it asynchronously and returns immediately; you are notified when it finishes.",
+  "Use background only for independent work that can run while you continue elsewhere."
+].join(`
+`);
+var Plugin12 = {
+  id: "opencode.tool.subagent",
+  effect: Effect.fn("SubagentTool.Plugin")(function* (ctx) {
+    const sessions = yield* Service17;
+    const jobs = yield* Service37;
+    const agents = yield* Service73;
+    const config = yield* Service54;
+    const permission = yield* Service70;
+    const subagents = yield* make5;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name11,
+      options: { codemode: false },
+      description: description5,
+      input: Input11,
+      output: Output7,
+      execute: (input, context) => Effect.gen(function* () {
+        const parent = yield* sessions.get(context.sessionID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${context.sessionID}`, error })));
+        let current = parent;
+        let depth = 0;
+        while (current.parentID) {
+          depth++;
+          current = yield* sessions.get(current.parentID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${current.parentID}`, error })));
+        }
+        const limit = latest2(yield* config.entries(), "experimental")?.subagent_depth ?? 1;
+        if (depth >= limit)
+          return yield* new ToolFailure({
+            message: `Subagent depth limit reached (${limit}). Increase "experimental.subagent_depth" to allow nested subagents.`
+          });
+        const agent = yield* agents.resolve(input.agent);
+        if (agent === undefined)
+          return yield* new ToolFailure({ message: `Unknown agent: ${input.agent}` });
+        if (agent.mode === "primary")
+          return yield* new ToolFailure({ message: `Agent ${input.agent} cannot run as a subagent` });
+        yield* permission.assert({
+          action: name11,
+          resources: [agent.id],
+          save: [agent.id],
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source: {
+            type: "tool",
+            messageID: context.messageID,
+            id: context.id
+          }
+        }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Subagent denied: ${agent.id}`, error })));
+        const existing = input.sessionID === undefined ? undefined : yield* sessions.get(input.sessionID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Subagent session not found: ${input.sessionID}`, error })));
+        if (existing !== undefined && existing.parentID !== context.sessionID)
+          return yield* new ToolFailure({
+            message: `Session ${existing.id} is not a child of the current session`
+          });
+        if (existing !== undefined && existing.agent !== agent.id) {
+          yield* sessions.switchAgent({ sessionID: existing.id, agent: agent.id }).pipe(Effect.andThen(agent.model === undefined ? Effect.void : sessions.switchModel({ sessionID: existing.id, model: agent.model })), Effect.mapError((error) => new ToolFailure({ message: `Failed to switch subagent session agent: ${existing.id}`, error })));
+        }
+        const model = agent.model ?? parent.model;
+        const child = existing ?? (yield* sessions.create({
+          parentID: context.sessionID,
+          title: input.description,
+          agent: ID15.make(input.agent),
+          model
+        }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${context.sessionID}`, error }))));
+        const background = input.background === true;
+        yield* context.progress({ sessionID: child.id, status: "running" });
+        yield* sessions.prompt({
+          sessionID: child.id,
+          text: existing === undefined ? ["You are a subagent spawned by another session.", input.prompt].join(`
+`) : input.prompt,
+          ...background && existing === undefined ? { resume: false } : {}
+        }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Failed to prompt subagent: ${child.id}`, error })));
+        const recovery = {
+          kind: "subagent",
+          parentSessionID: context.sessionID,
+          childSessionID: child.id,
+          agent: agent.name,
+          description: input.description
+        };
+        yield* subagents.start(recovery);
+        if (background) {
+          yield* subagents.background(recovery);
+          return backgroundResult(child.id);
+        }
+        const result = yield* jobs.block({ id: child.id, sessionID: context.sessionID }).pipe(Effect.onInterrupt(() => Effect.all([sessions.interrupt(child.id), jobs.cancel(child.id)], {
+          discard: true
+        })));
+        if (result?.type === "backgrounded") {
+          yield* subagents.notify(recovery, result.info.started_at);
+          return backgroundResult(child.id);
+        }
+        if (result?.info.status === "error")
+          return yield* new ToolFailure({
+            message: `Subagent failed (sessionID: ${child.id}): ${result.info.error ?? "unknown error"}`
+          });
+        if (result?.info.status === "cancelled")
+          return yield* new ToolFailure({ message: `Subagent cancelled (sessionID: ${child.id})` });
+        return {
+          sessionID: child.id,
+          status: "completed",
+          output: result?.info.output ?? NO_TEXT2
+        };
+      }).pipe(Effect.map((output) => ({
+        output,
+        content: output.status === "completed" ? `<subagent sessionID="${output.sessionID}" state="completed">
+${output.output}
+</subagent>` : output.output,
+        metadata: { sessionID: output.sessionID, status: output.status }
+      })))
+    })).pipe(Effect.orDie);
+    yield* ctx.session.hook("context", (event) => Effect.gen(function* () {
+      const tool = event.tools[name11];
+      if (!tool)
+        return;
+      const selected = yield* agents.resolve(event.agent);
+      if (!selected)
+        return;
+      const available = (yield* agents.list()).filter((agent) => agent.mode !== "primary" && !agent.hidden && evaluate2(name11, agent.id, selected.permissions).effect !== "deny").toSorted((a, b) => a.id.localeCompare(b.id));
+      if (available.length === 0)
+        return;
+      tool.description = [
+        tool.description,
+        "",
+        "Available subagents:",
+        ...available.map((agent) => `- ${agent.id}: ${agent.description ?? "This subagent should only be called when explicitly requested."}`)
+      ].join(`
+`);
+    }));
+  })
+};
+
+export { name11, Input11, Output7, description5, Plugin12, exports_subagent };

package/dist/chunks/worktree-sdm808jd.js

@@ -0,0 +1,277 @@
+import {
+  Service79
+} from "./worktree-vrm5r67w.js";
+import {
+  OAuth3,
+  Event16
+} from "./worktree-0tg2xvbt.js";
+import {
+  ID8,
+  MethodID2
+} from "./worktree-g0he3e83.js";
+import {
+  ID12,
+  mergeOverlay2,
+  mergeHeaders2
+} from "./worktree-9qn3qky1.js";
+
+// src/plugin/provider/opencode.ts
+import { Duration, Effect, Schema, Semaphore, Stream } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { ConfigProvider } from "@opencode/schema/config/provider";
+import { Money } from "@opencode/schema/money";
+var defaultServer = "https://opencode.ai/console";
+var clientID = "opencode-cli";
+var methodID = MethodID2.make("device");
+var RemoteResponse = Schema.Struct({ providers: Schema.Record(Schema.String, ConfigProvider.Info) });
+var Device = Schema.Struct({
+  device_code: Schema.String,
+  user_code: Schema.String,
+  verification_uri_complete: Schema.String,
+  expires_in: Schema.Number,
+  interval: Schema.Number
+});
+var Token = Schema.Struct({
+  access_token: Schema.String,
+  refresh_token: Schema.String,
+  expires_in: Schema.Number
+});
+var TokenPending = Schema.Struct({ error: Schema.String });
+var DeviceToken = Schema.Union([Token, TokenPending]);
+var User = Schema.Struct({ id: Schema.String, email: Schema.String });
+var Org = Schema.Struct({ id: Schema.String, name: Schema.String });
+function oauth(http) {
+  return {
+    integrationID: ID8.make("opencode"),
+    method: {
+      id: methodID,
+      type: "oauth",
+      label: "OpenCode Console account"
+    },
+    authorize: (answer) => Effect.gen(function* () {
+      const server = yield* normalizeServer(answer.server ?? defaultServer);
+      const device = yield* post(http, `${server}/auth/device/code`, { client_id: clientID }, Device);
+      const verification = yield* Effect.try({
+        try: () => {
+          const url = new URL(device.verification_uri_complete, `${server}/`);
+          if (url.protocol !== "http:" && url.protocol !== "https:")
+            throw new Error("expected HTTP(S)");
+          return url;
+        },
+        catch: (cause) => new Error(`Invalid device verification URL: ${cause instanceof Error ? cause.message : String(cause)}`)
+      });
+      return {
+        mode: "auto",
+        url: verification.href,
+        instructions: `Enter code: ${device.user_code}`,
+        callback: poll(http, server, device.device_code, Duration.seconds(device.interval))
+      };
+    }),
+    refresh: (credential) => Effect.gen(function* () {
+      const server = typeof credential.metadata?.server === "string" ? credential.metadata.server : defaultServer;
+      const token = yield* post(http, `${server}/auth/device/token`, { grant_type: "refresh_token", refresh_token: credential.refresh, client_id: clientID }, Token);
+      return {
+        ...credential,
+        access: token.access_token,
+        refresh: token.refresh_token,
+        expires: Date.now() + token.expires_in * 1000
+      };
+    }),
+    label: (credential) => typeof credential.metadata?.orgName === "string" ? credential.metadata.orgName : undefined
+  };
+}
+var OpencodePlugin2 = define({
+  id: "opencode.provider.opencode",
+  effect: Effect.fn(function* (ctx) {
+    const bus = yield* Service79;
+    const http = yield* HttpClient.HttpClient;
+    const loading = Semaphore.makeUnsafe(1);
+    let connected = false;
+    let providers;
+    const load = Effect.fn("OpencodePlugin.load")(function* () {
+      const connection = yield* ctx.integration.connection.active("opencode");
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+        return;
+      })) : undefined;
+      connected = connection !== undefined;
+      providers = credential ? yield* fetchProviders(http, credential).pipe(Effect.catch((cause) => Effect.logWarning("failed to load OpenCode provider config", { cause }).pipe(Effect.as(undefined)))) : undefined;
+    });
+    yield* ctx.integration.transform((editor) => {
+      editor.update("opencode", (integration) => {
+        integration.name = "OpenCode";
+      });
+      editor.method.update(oauth(http));
+      editor.method.update({ integrationID: "opencode", method: { type: "key", label: "API key (service account)" } });
+    });
+    yield* load();
+    yield* ctx.catalog.transform((catalog) => {
+      for (const [providerID, item] of Object.entries(providers ?? {})) {
+        const source = catalog.provider.get(item.canonical ?? providerID);
+        catalog.provider.update(providerID, (provider) => {
+          if (source && source.provider !== provider)
+            Object.assign(provider, structuredClone(source.provider), { id: provider.id });
+          provider.integrationID = ID8.make("opencode");
+          if (item.canonical !== undefined)
+            provider.canonical = item.canonical;
+          if (item.name !== undefined)
+            provider.name = item.name;
+          provider.package = item.package ?? provider.package;
+          provider.settings = mergeOverlay2(withoutCredentials(provider.settings), withoutCredentials(item.settings));
+          provider.headers = mergeHeaders2(provider.headers, item.headers);
+          provider.body = mergeOverlay2(provider.body, item.body);
+        });
+        for (const [modelID, config] of Object.entries(item.models ?? {})) {
+          const base = source?.models.get(config.modelID ?? modelID) ?? source?.models.get(modelID);
+          catalog.model.update(providerID, modelID, (model) => {
+            Object.assign(model, structuredClone(base ?? model));
+            if (config.family !== undefined)
+              model.family = config.family;
+            if (config.name !== undefined)
+              model.name = config.name;
+            if (config.modelID !== undefined)
+              model.modelID = config.modelID;
+            if (config.compatibility !== undefined)
+              model.compatibility = { ...model.compatibility, ...config.compatibility };
+            model.package = config.package ?? (item.package !== undefined ? undefined : model.package);
+            if (item.settings?.baseURL !== undefined && model.settings)
+              delete model.settings.baseURL;
+            if (config.capabilities !== undefined)
+              model.capabilities = {
+                ...config.capabilities,
+                input: [...config.capabilities.input],
+                output: [...config.capabilities.output]
+              };
+            model.settings = mergeOverlay2(withoutCredentials(model.settings), withoutCredentials(config.settings));
+            model.headers = mergeHeaders2(model.headers, config.headers);
+            model.body = mergeOverlay2(model.body, config.body);
+            for (const variant of config.variants ?? []) {
+              let existing = model.variants.find((item) => item.id === variant.id);
+              if (!existing) {
+                existing = { id: variant.id };
+                model.variants.push(existing);
+              }
+              if (variant.settings !== undefined)
+                existing.settings = mergeOverlay2(existing.settings, withoutCredentials(variant.settings));
+              if (variant.headers !== undefined)
+                existing.headers = mergeHeaders2(existing.headers, variant.headers);
+              if (variant.body !== undefined)
+                existing.body = mergeOverlay2(existing.body, variant.body);
+            }
+            if (config.cost !== undefined)
+              model.cost = (Array.isArray(config.cost) ? config.cost : [config.cost]).map((cost) => ({
+                tier: cost.tier && { ...cost.tier },
+                input: cost.input,
+                output: cost.output,
+                cache: {
+                  read: cost.cache?.read ?? Money.USDPerMillionTokens.zero,
+                  write: cost.cache?.write ?? Money.USDPerMillionTokens.zero
+                }
+              }));
+            model.enabled = !config.disabled;
+            if (config.limit !== undefined)
+              model.limit = { ...model.limit, ...config.limit };
+          });
+        }
+      }
+      const item = catalog.provider.get(ID12.opencode);
+      if (!item)
+        return;
+      const hasKey = Boolean(process.env.OPENCODE_API_KEY || connected || item.provider.settings?.apiKey);
+      catalog.provider.update(item.provider.id, (provider) => {
+        if (!hasKey) {
+          provider.activation = "enabled";
+          provider.settings = { ...provider.settings, apiKey: "public" };
+        }
+      });
+      if (hasKey)
+        return;
+      for (const model of item.models.values()) {
+        if (!model.cost.some((cost) => cost.input > 0))
+          continue;
+        catalog.model.update(item.provider.id, model.id, (draft) => {
+          draft.enabled = false;
+        });
+      }
+    });
+    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* bus.subscribe(Event16.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID8.make("opencode")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+function fetchProviders(http, value) {
+  const metadata = value.metadata;
+  const server = typeof metadata?.server === "string" ? metadata.server : defaultServer;
+  const orgID = typeof metadata?.orgID === "string" ? metadata.orgID : undefined;
+  const token = value.type === "oauth" ? value.access : value.key;
+  return http.execute(HttpClientRequest.get(`${server}/api/v2/config`).pipe(HttpClientRequest.acceptJson, HttpClientRequest.bearerToken(token), HttpClientRequest.setHeaders(orgID ? { "x-org-id": orgID } : {}))).pipe(Effect.flatMap((response) => {
+    if (response.status === 404)
+      return Effect.undefined;
+    return HttpClientResponse.filterStatusOk(response).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(RemoteResponse)), Effect.map((remote) => remote.providers));
+  }));
+}
+function withoutCredentials(body) {
+  return body && Object.fromEntries(Object.entries(body).filter(([key]) => !["apiKey", "authToken", "accessToken"].includes(key)));
+}
+function normalizeServer(input) {
+  return Effect.try({
+    try: () => {
+      if (typeof input !== "string")
+        throw new Error("expected string");
+      const url = new URL(input);
+      if (url.protocol !== "http:" && url.protocol !== "https:")
+        throw new Error("expected HTTP(S)");
+      return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+    },
+    catch: (cause) => new Error(`Invalid OpenCode server URL: ${cause instanceof Error ? cause.message : String(cause)}`)
+  });
+}
+function poll(http, server, deviceCode, interval) {
+  const loop = (wait) => Effect.gen(function* () {
+    yield* Effect.sleep(wait);
+    const result = yield* post(http, `${server}/auth/device/token`, {
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      device_code: deviceCode,
+      client_id: clientID
+    }, DeviceToken, false);
+    if ("access_token" in result)
+      return yield* credential(http, server, result);
+    if (result.error === "authorization_pending")
+      return yield* loop(wait);
+    if (result.error === "slow_down") {
+      return yield* loop(Duration.sum(wait, Duration.seconds(5)));
+    }
+    return yield* Effect.fail(new Error(`Device authorization failed: ${result.error}`));
+  });
+  return loop(interval);
+}
+function credential(http, server, token) {
+  return Effect.gen(function* () {
+    const [user, orgs] = yield* Effect.all([
+      get(http, `${server}/api/user`, token.access_token, User),
+      get(http, `${server}/api/orgs`, token.access_token, Schema.Array(Org))
+    ], { concurrency: 2 });
+    const org = orgs.toSorted((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id))[0];
+    return OAuth3.make({
+      type: "oauth",
+      methodID,
+      access: token.access_token,
+      refresh: token.refresh_token,
+      expires: Date.now() + token.expires_in * 1000,
+      metadata: {
+        server,
+        accountID: user.id,
+        email: user.email,
+        orgID: org?.id,
+        orgName: org?.name
+      }
+    });
+  });
+}
+function get(http, url, token, schema) {
+  return HttpClient.filterStatusOk(http).execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.bearerToken(token))).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)));
+}
+function post(http, url, body, schema, statusOk = true) {
+  return HttpClientRequest.post(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.schemaBodyJson(Schema.Record(Schema.String, Schema.String))(body), Effect.flatMap((request) => http.execute(request)), Effect.flatMap((response) => statusOk ? HttpClientResponse.filterStatusOk(response) : Effect.succeed(response)), Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)));
+}
+
+export { OpencodePlugin2 };

package/dist/chunks/worktree-sdp7kfr6.js

@@ -0,0 +1,153 @@
+// src/database/migration/20260804233008_loose_psylocke.ts
+import { Effect } from "effect";
+import { sql } from "drizzle-orm";
+var previousV2Marker = "20260730195856_optional_session_title";
+var migration = {
+  id: "20260804233008_loose_psylocke",
+  up(tx) {
+    return Effect.gen(function* () {
+      if (yield* tx.get(sql`SELECT id FROM migration WHERE id = ${previousV2Marker}`)) {
+        const v1Only = yield* tx.get(sql`
+          SELECT 1
+          FROM message
+          WHERE NOT EXISTS (
+            SELECT 1 FROM session_message WHERE session_message.session_id = message.session_id
+          )
+          LIMIT 1
+        `);
+        if (v1Only)
+          return yield* Effect.die(new Error("Previous V2 database contains V1-only session history"));
+        yield* tx.run(`DROP INDEX IF EXISTS \`session_project_idx\`;`);
+        yield* tx.run(`DROP INDEX IF EXISTS \`session_workspace_idx\`;`);
+        yield* tx.run(`DROP INDEX IF EXISTS \`session_parent_idx\`;`);
+        yield* tx.run(`DROP INDEX IF EXISTS \`session_time_suspended_idx\`;`);
+        yield* tx.run(`ALTER TABLE \`session\` RENAME TO \`session_v2\`;`);
+        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 IF EXISTS \`data_migration\`;`);
+        yield* tx.run(`DROP TABLE IF EXISTS \`session_context_epoch\`;`);
+        yield* tx.run(`DROP TABLE IF EXISTS \`session_input\`;`);
+        return;
+      }
+      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 };