@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-t1xz8esh.js

@@ -0,0 +1,115 @@
+import {
+  exports_snapshot
+} from "./permission-vh4z0rtm.js";
+import {
+  exports_message
+} from "./permission-25pxtba7.js";
+import {
+  SessionMessageTable
+} from "./permission-zvvp2xr4.js";
+import {
+  SessionEvent
+} from "./permission-a83yvq99.js";
+import {
+  exports_schema
+} from "./permission-y8rs54ne.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  exports_database
+} from "./permission-8w2n8x74.js";
+import {
+  RelativePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/revert.ts
+var exports_revert = {};
+__export(exports_revert, {
+  stage: () => stage,
+  commit: () => commit,
+  clear: () => clear,
+  SessionRevert: () => exports_revert,
+  MessageNotFoundError: () => MessageNotFoundError
+});
+import { and, asc, eq, gt } from "drizzle-orm";
+import { Effect, Schema } from "effect";
+class MessageNotFoundError extends Schema.TaggedErrorClass()("Session.MessageNotFoundError", {
+  sessionID: exports_schema.ID,
+  messageID: exports_message.ID
+}) {
+}
+var plan = Effect.fn("SessionRevert.plan")(function* (input) {
+  const db = (yield* exports_database.Service).db;
+  const boundary = yield* db.select({ seq: SessionMessageTable.seq }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, input.sessionID), eq(SessionMessageTable.id, input.messageID))).get().pipe(Effect.orDie);
+  if (!boundary)
+    return yield* new MessageNotFoundError(input);
+  const rows = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, input.sessionID), eq(SessionMessageTable.type, "assistant"), gt(SessionMessageTable.seq, boundary.seq))).orderBy(asc(SessionMessageTable.seq)).all().pipe(Effect.orDie);
+  const decode = Schema.decodeUnknownEffect(exports_message.Info);
+  const files = new Map;
+  for (const row of rows) {
+    const message = yield* decode({ ...row.data, id: row.id, type: row.type }).pipe(Effect.orDie);
+    if (message.type !== "assistant" || !message.snapshot?.start)
+      continue;
+    for (const file of message.snapshot.files ?? [])
+      if (!files.has(file))
+        files.set(file, exports_snapshot.ID.make(message.snapshot.start));
+  }
+  return files;
+});
+var stage = Effect.fn("SessionRevert.stage")(function* (input) {
+  const snapshot = yield* exports_snapshot.Service;
+  const bus = yield* exports_bus.Service;
+  const original = input.session.revert?.snapshot ? exports_snapshot.ID.make(input.session.revert.snapshot) : yield* snapshot.capture();
+  const next = yield* plan({ sessionID: input.session.id, messageID: input.messageID });
+  const restore = new Map;
+  if (original) {
+    for (const file of input.session.revert?.files ?? [])
+      restore.set(RelativePath.make(file.file), original);
+  }
+  if (input.files !== false)
+    for (const [file, tree] of next)
+      restore.set(file, tree);
+  if (restore.size)
+    yield* snapshot.restore({ files: restore });
+  const paths = input.files === false ? [] : Array.from(next.keys());
+  const files = original ? yield* snapshot.diff({ from: original, to: (yield* snapshot.capture()) ?? original, paths }) : [];
+  const revert = {
+    messageID: input.messageID,
+    snapshot: original,
+    files
+  };
+  yield* bus.publish(SessionEvent.RevertEvent.Staged, {
+    sessionID: input.session.id,
+    revert
+  });
+  return revert;
+});
+var clear = Effect.fn("SessionRevert.clear")(function* (session) {
+  if (!session.revert)
+    return;
+  const snapshot = yield* exports_snapshot.Service;
+  const original = session.revert.snapshot ? exports_snapshot.ID.make(session.revert.snapshot) : undefined;
+  if (original)
+    yield* snapshot.restore({
+      files: new Map((session.revert.files ?? []).map((file) => [RelativePath.make(file.file), original]))
+    });
+  const bus = yield* exports_bus.Service;
+  yield* bus.publish(SessionEvent.RevertEvent.Cleared, {
+    sessionID: session.id
+  });
+});
+var commit = Effect.fn("SessionRevert.commit")(function* (session) {
+  if (!session.revert)
+    return;
+  const bus = yield* exports_bus.Service;
+  yield* bus.publish(SessionEvent.RevertEvent.Committed, {
+    sessionID: session.id,
+    to: session.revert.messageID
+  });
+});
+
+export { MessageNotFoundError, stage, clear, commit, exports_revert };

package/dist/chunks/permission-t2j2ttmx.js

@@ -0,0 +1,51 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/hooks.ts
+var exports_hooks = {};
+__export(exports_hooks, {
+  node: () => node,
+  Service: () => Service,
+  PluginHooks: () => exports_hooks
+});
+import { Context, Effect, Layer, Scope } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+
+class Service extends Context.Service()("@opencode/PluginHooks") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const callbacks = new Map;
+  const key = (domain, name) => `${domain}.${String(name)}`;
+  const register = Effect.fn("PluginHooks.register")(function* (domain, name, callback) {
+    const scope = yield* Scope.Scope;
+    const id = key(domain, name);
+    let active = true;
+    callbacks.set(id, [...callbacks.get(id) ?? [], callback]);
+    const dispose = Effect.sync(() => {
+      if (!active)
+        return;
+      active = false;
+      const next = (callbacks.get(id) ?? []).filter((item) => item !== callback);
+      if (next.length === 0)
+        callbacks.delete(id);
+      else
+        callbacks.set(id, next);
+    });
+    yield* Scope.addFinalizer(scope, dispose);
+    return { dispose };
+  });
+  const trigger = Effect.fn("PluginHooks.trigger")(function* (domain, name, event) {
+    for (const callback of callbacks.get(key(domain, name)) ?? []) {
+      const result = Reflect.apply(callback, undefined, [
+        event
+      ]);
+      yield* result;
+    }
+    return event;
+  });
+  return Service.of({ register, trigger });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [] });
+
+export { Service, node, exports_hooks };

package/dist/chunks/permission-tcn24h1d.js

@@ -0,0 +1,52 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/id/id.ts
+var exports_id = {};
+__export(exports_id, {
+  timestamp: () => timestamp,
+  descending: () => descending,
+  create: () => createID,
+  ascending: () => ascending,
+  Identifier: () => exports_id
+});
+import { create } from "@opencode-ai/schema/identifier";
+var prefixes = {
+  job: "job",
+  event: "evt",
+  session: "ses",
+  message: "msg",
+  permission: "per",
+  question: "que",
+  part: "prt",
+  pty: "pty",
+  tool: "tool",
+  workspace: "wrk"
+};
+function ascending(prefix, given) {
+  return generateID(prefix, "ascending", given);
+}
+function descending(prefix, given) {
+  return generateID(prefix, "descending", given);
+}
+function generateID(prefix, direction, given) {
+  if (!given) {
+    return createID(prefixes[prefix], direction);
+  }
+  if (!given.startsWith(prefixes[prefix])) {
+    throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`);
+  }
+  return given;
+}
+function createID(prefix, direction, timestamp) {
+  return prefix + "_" + create(direction === "descending", timestamp);
+}
+function timestamp(id) {
+  const prefix = id.split("_")[0];
+  const hex = id.slice(prefix.length + 1, prefix.length + 13);
+  const encoded = BigInt("0x" + hex);
+  return Number(encoded / BigInt(4096));
+}
+
+export { ascending, descending, createID, timestamp, exports_id };

package/dist/chunks/permission-tdm3rp2k.js

@@ -0,0 +1,49 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/workspace/driver.ts
+var exports_driver = {};
+__export(exports_driver, {
+  registryNode: () => registryNode,
+  registry: () => registry,
+  node: () => node,
+  make: () => make,
+  WorkspaceDriver: () => exports_driver,
+  RegistryService: () => RegistryService,
+  ProviderNotFound: () => ProviderNotFound,
+  Error: () => Error,
+  Binding: () => Binding
+});
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+var Binding = Schema.Record(Schema.String, Schema.Json);
+
+class Error extends Schema.TaggedErrorClass()("WorkspaceDriver.Error", {
+  message: Schema.optional(Schema.String),
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+
+class ProviderNotFound extends Schema.TaggedErrorClass()("WorkspaceDriver.ProviderNotFound", {
+  provider: Schema.String
+}) {
+}
+var make = (driver) => driver;
+
+class RegistryService extends Context.Service()("@opencode/WorkspaceDriverRegistry") {
+}
+var registry = (drivers) => ({
+  get: (provider) => {
+    const driver = drivers[provider];
+    return driver ? Effect.succeed(driver) : Effect.fail(new ProviderNotFound({ provider }));
+  }
+});
+var registryNode = (drivers) => makeGlobalNode({
+  service: RegistryService,
+  layer: Layer.succeed(RegistryService, RegistryService.of(registry(drivers))),
+  deps: []
+});
+var node = registryNode({});
+
+export { Binding, Error, ProviderNotFound, make, RegistryService, registry, registryNode, node, exports_driver };

package/dist/chunks/permission-tenv3kfs.js

@@ -0,0 +1,83 @@
+import {
+  exports_mcp
+} from "./permission-1c00jchy.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/websearch/exa.ts
+var exports_exa = {};
+__export(exports_exa, {
+  endpoint: () => endpoint,
+  WebSearchExa: () => exports_exa,
+  Plugin: () => Plugin
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+var endpoint = "https://mcp.exa.ai/mcp";
+var McpInput = Schema.Struct({
+  query: Schema.String,
+  numResults: Schema.Number.pipe(Schema.optional)
+});
+var McpOutput = Schema.Struct({
+  content: Schema.Array(Schema.Struct({
+    type: Schema.Literal("text"),
+    text: Schema.String,
+    _meta: Schema.Struct({ searchTime: Schema.Number }).pipe(Schema.optional)
+  }))
+});
+var Plugin = define({
+  id: "opencode.websearch.exa",
+  effect: Effect.fn("WebSearchExa.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient;
+    yield* ctx.integration.transform((draft) => {
+      draft.update("exa", (integration) => integration.name = "Exa");
+      draft.method.update({
+        integrationID: "exa",
+        method: { type: "key" }
+      });
+      draft.method.update({
+        integrationID: "exa",
+        method: { type: "env", names: ["EXA_API_KEY"] }
+      });
+    });
+    yield* ctx.websearch.transform((draft) => {
+      draft.add({
+        id: "exa",
+        name: "Exa",
+        execute: (input) => Effect.gen(function* () {
+          const connection = yield* ctx.integration.connection.active("exa");
+          const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined;
+          const url = new URL(endpoint);
+          if (credential?.type === "key")
+            url.searchParams.set("exaApiKey", credential.key);
+          const result = yield* exports_mcp.call(http, url.toString(), "web_search_exa", { input: McpInput, output: McpOutput }, { query: input.query, numResults: 8 });
+          const content = result?.content.find((item) => item.text);
+          return content ? parseResults(content.text) : [];
+        })
+      });
+    });
+  })
+});
+function parseResults(text) {
+  return text.split(/\n\n---\n\n/).flatMap((block) => {
+    const url = block.match(/^URL:\s*(.+)$/m)?.[1]?.trim();
+    if (!url)
+      return [];
+    const title = block.match(/^Title:\s*(.+)$/m)?.[1]?.trim();
+    const publishedText = block.match(/^Published:\s*(.+)$/m)?.[1]?.trim();
+    const published = publishedText && publishedText !== "N/A" ? Date.parse(publishedText) : undefined;
+    const content = block.match(/^(?:Highlights|Text):\s*\n?([\s\S]*)$/m)?.[1]?.trim();
+    return [
+      {
+        url,
+        ...title && title !== "N/A" ? { title } : {},
+        ...content ? { content } : {},
+        time: { ...published !== undefined && Number.isFinite(published) ? { published } : {} }
+      }
+    ];
+  });
+}
+
+export { endpoint, Plugin, exports_exa };

package/dist/chunks/permission-thstd87d.js

@@ -0,0 +1,21 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/v1/config/command.ts
+var exports_command = {};
+__export(exports_command, {
+  Info: () => Info,
+  ConfigCommandV1: () => exports_command
+});
+import { Schema } from "effect";
+var Info = Schema.Struct({
+  template: Schema.String,
+  description: Schema.optional(Schema.String),
+  agent: Schema.optional(Schema.String),
+  model: Schema.optional(Schema.String),
+  variant: Schema.optional(Schema.String),
+  subtask: Schema.optional(Schema.Boolean)
+});
+
+export { Info, exports_command };

package/dist/chunks/permission-tmb1f636.js

@@ -0,0 +1,28 @@
+// src/database/migration/20260323234822_events.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260323234822_events",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`event_sequence\` (
+          \`aggregate_id\` text PRIMARY KEY,
+          \`seq\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`event\` (
+          \`id\` text PRIMARY KEY,
+          \`aggregate_id\` text NOT NULL,
+          \`seq\` integer NOT NULL,
+          \`type\` text NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_event_aggregate_id_event_sequence_aggregate_id_fk\` FOREIGN KEY (\`aggregate_id\`) REFERENCES \`event_sequence\`(\`aggregate_id\`) ON DELETE CASCADE
+        );
+      `);
+    });
+  }
+};
+var _20260323234822_events_default = migration;
+
+export { _20260323234822_events_default };

package/dist/chunks/permission-ts4t4v20.js

@@ -0,0 +1,97 @@
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  __require
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/provider/google-vertex.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+function resolveProject(options) {
+  return options.project ?? process.env.GOOGLE_VERTEX_PROJECT ?? process.env.GOOGLE_CLOUD_PROJECT ?? process.env.GCP_PROJECT ?? process.env.GCLOUD_PROJECT;
+}
+function resolveLocation(options) {
+  return options.location ?? process.env.GOOGLE_VERTEX_LOCATION ?? process.env.GOOGLE_CLOUD_LOCATION ?? process.env.VERTEX_LOCATION ?? "us-central1";
+}
+function vertexEndpoint(location) {
+  if (location === "global")
+    return "aiplatform.googleapis.com";
+  return `${location}-aiplatform.googleapis.com`;
+}
+function replaceVertexVars(value, project, location) {
+  return value.replaceAll("${GOOGLE_VERTEX_PROJECT}", project ?? "${GOOGLE_VERTEX_PROJECT}").replaceAll("${GOOGLE_VERTEX_LOCATION}", location).replaceAll("${GOOGLE_VERTEX_ENDPOINT}", vertexEndpoint(location));
+}
+function authFetch(fetchWithRuntimeOptions) {
+  return async (input, init) => {
+    const { GoogleAuth } = await import("google-auth-library");
+    const auth = new GoogleAuth({ scopes: ["https://www.googleapis.com/auth/cloud-platform"] });
+    const client = await auth.getClient();
+    const token = await client.getAccessToken();
+    const headers = new Headers(init?.headers);
+    headers.set("Authorization", `Bearer ${token.token}`);
+    return typeof fetchWithRuntimeOptions === "function" ? fetchWithRuntimeOptions(input, { ...init, headers }) : fetch(input, { ...init, headers });
+  };
+}
+var GoogleVertexPlugin = define({
+  id: "opencode.provider.google-vertex",
+  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/google-vertex" && !(item.provider.id === exports_provider.ID.googleVertex && exports_provider.packageName(item.provider.package)?.includes("@ai-sdk/openai-compatible")))
+          continue;
+        const project = resolveProject(item.provider.settings ?? {});
+        const location = String(resolveLocation(item.provider.settings ?? {}));
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.settings = {
+            ...provider.settings,
+            ...project ? { project } : {},
+            location,
+            ...typeof provider.settings?.baseURL === "string" ? { baseURL: replaceVertexVars(provider.settings.baseURL, project, location) } : {},
+            ...exports_provider.packageName(provider.package)?.includes("@ai-sdk/openai-compatible") ? { fetch: authFetch(provider.settings?.fetch) } : {}
+          };
+        });
+      }
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.model.providerID === exports_provider.ID.googleVertex && evt.package.includes("@ai-sdk/openai-compatible")) {
+        evt.options.fetch = authFetch(evt.options.fetch);
+        return;
+      }
+      if (evt.package === "@ai-sdk/google-vertex/anthropic") {
+        const mod2 = yield* Effect.promise(() => import("@ai-sdk/google-vertex/anthropic"));
+        const project2 = resolveProject(evt.options);
+        const location2 = String(resolveLocation(evt.options));
+        const regionalBaseURL = (location2 === "eu" || location2 === "us") && project2 && !evt.options.baseURL ? `https://aiplatform.${location2}.rep.googleapis.com/v1/projects/${project2}/locations/${location2}/publishers/anthropic/models` : undefined;
+        evt.sdk = mod2.createVertexAnthropic({
+          ...evt.options,
+          project: project2,
+          location: location2,
+          ...regionalBaseURL ? { baseURL: regionalBaseURL } : {}
+        });
+        return;
+      }
+      if (evt.package !== "@ai-sdk/google-vertex")
+        return;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/google-vertex"));
+      const project = resolveProject(evt.options);
+      const location = resolveLocation(evt.options);
+      const options = { ...evt.options };
+      delete options.fetch;
+      evt.sdk = mod.createVertex({
+        ...options,
+        project,
+        location
+      });
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== exports_provider.ID.googleVertex)
+        return;
+      evt.language = evt.sdk.languageModel(String(evt.model.modelID ?? evt.model.id).trim());
+    }));
+  })
+});
+
+export { GoogleVertexPlugin };

package/dist/chunks/permission-tvmhrvfj.js

@@ -0,0 +1,4 @@
+// src/pty/schema.ts
+import { ID } from "@opencode-ai/schema/pty";
+
+export { ID };

package/dist/chunks/permission-tyh0a1hs.js

@@ -0,0 +1,124 @@
+import {
+  exports_catalog
+} from "./permission-57tzwnz4.js";
+import {
+  exports_instructions
+} from "./permission-q4r4pzs4.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/codemode/instructions.ts
+var exports_instructions2 = {};
+__export(exports_instructions2, {
+  update: () => update,
+  render: () => render,
+  make: () => make,
+  CodeModeInstructions: () => exports_instructions2
+});
+import { searchSignature, toolExpression } from "@opencode-ai/codemode";
+import { Effect, Schema } from "effect";
+var prompt = (hasMoreTools) => `The Code Mode tool catalog below is ${hasMoreTools ? "partial" : "complete"}.
+
+${hasMoreTools ? "The Code Mode catalog and `search` results are" : "This catalog is"} the complete set of tools available within Code Mode. Tools presented elsewhere are not available in this runtime.${hasMoreTools ? `
+
+## Search
+
+Use \`search\` to discover exact paths and signatures for additional tools:
+
+- ${searchSignature}` : ""}
+
+## Available tools`;
+function render(catalog) {
+  if (catalog.total === 0)
+    return "No Code Mode tools are currently available. Later Code Mode catalog updates may add or remove tools. Do not call `execute` unless there is at least one available Code Mode tool.";
+  const tools = catalog.namespaces.flatMap((namespace) => {
+    const count = namespace.count === 1 ? "1 tool" : `${namespace.count} tools`;
+    const label = namespace.entries.length === namespace.count ? count : namespace.entries.length === 0 ? `${count}, none shown` : `${count}, ${namespace.entries.length} shown`;
+    return [`- ${namespace.name} (${label})`, ...namespace.entries.map((entry) => entry.line)];
+  });
+  return `${prompt(catalog.shown < catalog.total)}
+
+${tools.join(`
+`)}`;
+}
+function update(previous, current) {
+  const replacement = `The Code Mode tool catalog has changed. This catalog supersedes the previous Code Mode tool catalog.
+
+${render(current)}`;
+  if (current.total === 0)
+    return replacement;
+  const previousComplete = previous.shown === previous.total;
+  const currentComplete = current.shown === current.total;
+  if (previousComplete !== currentComplete)
+    return replacement;
+  const diff = exports_instructions.diffByKey(previous.namespaces.flatMap((namespace) => namespace.entries), current.namespaces.flatMap((namespace) => namespace.entries), (entry) => entry.path, (before, after) => before.line !== after.line);
+  const entriesChanged = diff.added.length > 0 || diff.removed.length > 0 || diff.changed.length > 0;
+  if (!currentComplete) {
+    if (entriesChanged)
+      return replacement;
+    const namespaces = exports_instructions.diffByKey(previous.namespaces, current.namespaces, (namespace) => namespace.name, (before, after) => before.count !== after.count);
+    const changed = namespaces.added.length > 0 || namespaces.removed.length > 0 || namespaces.changed.length > 0;
+    if (!changed)
+      return replacement;
+    const parts2 = ["The Code Mode tool catalog has changed."];
+    if (namespaces.added.length > 0) {
+      parts2.push(`New tool namespaces are available: ${namespaces.added.map((namespace) => `\`${namespace.name}\` (${namespace.count} tools)`).join(", ")}.`);
+    }
+    if (namespaces.changed.length > 0) {
+      parts2.push(`The following namespace inventories changed; search them again before relying on previous results: ${namespaces.changed.map((change) => `\`${change.current.name}\` now has ${change.current.count} tools`).join(", ")}.`);
+    }
+    if (namespaces.removed.length > 0) {
+      parts2.push(`The following tool namespaces are no longer available and must not be used: ${namespaces.removed.map((namespace) => `\`${namespace.name}\``).join(", ")}.`);
+    }
+    const delta2 = parts2.join(`
+
+`);
+    if (delta2.length < replacement.length)
+      return delta2;
+    return replacement;
+  }
+  if (!entriesChanged)
+    return replacement;
+  const parts = ["The Code Mode tool catalog has changed."];
+  if (diff.added.length > 0) {
+    parts.push([
+      "New tools are available in addition to those previously listed:",
+      ...diff.added.map((entry) => entry.line)
+    ].join(`
+`));
+  }
+  if (diff.changed.length > 0) {
+    parts.push([
+      "Changed tool listings supersede the previously listed ones:",
+      ...diff.changed.map((change) => change.current.line)
+    ].join(`
+`));
+  }
+  if (diff.removed.length > 0) {
+    parts.push(`The following tools are no longer available and must not be called: ${diff.removed.map((entry) => toolExpression(entry.path)).join(", ")}.`);
+  }
+  const delta = parts.join(`
+
+`);
+  if (delta.length < replacement.length)
+    return delta;
+  return replacement;
+}
+var key = exports_instructions.Key.make("core/codemode");
+var codec = Schema.toCodecJson(exports_catalog.Summary);
+var make = (entries) => {
+  const catalog = entries === undefined ? exports_instructions.removed : exports_catalog.summarize(entries);
+  return exports_instructions.make({
+    key,
+    codec,
+    read: Effect.succeed(catalog),
+    render: {
+      initial: render,
+      changed: update,
+      removed: () => "Code Mode tools are no longer available. Do not use any previously listed Code Mode tools."
+    }
+  });
+};
+
+export { render, update, make, exports_instructions2 as exports_instructions };

package/dist/chunks/permission-v2adqbbe.js

@@ -0,0 +1,19 @@
+// src/database/migration/20260622202450_simplify_session_input.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260622202450_simplify_session_input",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_context_epoch\`;`);
+      yield* tx.run(`DELETE FROM \`session_input\`;`);
+      yield* tx.run(`DELETE FROM \`session_message\`;`);
+      yield* tx.run(`DELETE FROM \`event\`;`);
+      yield* tx.run(`DELETE FROM \`event_sequence\`;`);
+      yield* tx.run(`UPDATE \`session\` SET \`workspace_id\` = NULL WHERE \`workspace_id\` IS NOT NULL;`);
+      yield* tx.run(`DELETE FROM \`workspace\`;`);
+    });
+  }
+};
+var _20260622202450_simplify_session_input_default = migration;
+
+export { _20260622202450_simplify_session_input_default };