@opencode-ai/core 0.0.0-dev-17471

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

@@ -0,0 +1,254 @@
+import {
+  exports_id
+} from "./location-mutation-tcn24h1d.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/job.ts
+var exports_job = {};
+__export(exports_job, {
+  node: () => node,
+  make: () => make,
+  Service: () => Service,
+  Job: () => exports_job
+});
+import { Cause, Clock, Context, Deferred, Effect, Exit, Layer, Scope, SynchronizedRef } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+class Service extends Context.Service()("@opencode/Job") {
+}
+function snapshot(job) {
+  return {
+    ...job.info,
+    ...job.info.metadata ? { metadata: { ...job.info.metadata } } : {}
+  };
+}
+function errorText(error) {
+  if (error instanceof Error)
+    return error.message;
+  return String(error);
+}
+function incrementSession(input, sessionID) {
+  return new Map(input).set(sessionID, (input.get(sessionID) ?? 0) + 1);
+}
+function decrementSession(input, sessionID) {
+  const count = input.get(sessionID);
+  if (count === undefined)
+    return input;
+  const next = new Map(input);
+  if (count <= 1)
+    next.delete(sessionID);
+  else
+    next.set(sessionID, count - 1);
+  return next;
+}
+var make = Effect.gen(function* () {
+  const state = {
+    jobs: yield* SynchronizedRef.make(new Map),
+    scope: yield* Scope.Scope
+  };
+  const settle = Effect.fn("Job.settle")(function* (id, token, exit) {
+    const completed_at = yield* Clock.currentTimeMillis;
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      const job = jobs.get(id);
+      if (!job)
+        return [{}, jobs];
+      if (job.token !== token)
+        return [{}, jobs];
+      if (job.info.status !== "running")
+        return [{ info: snapshot(job) }, jobs];
+      const status = Exit.isSuccess(exit) ? "completed" : Cause.hasInterruptsOnly(exit.cause) ? "cancelled" : "error";
+      const next = {
+        ...job,
+        blockingSessions: new Map,
+        info: {
+          ...job.info,
+          status,
+          completed_at,
+          ...Exit.isSuccess(exit) ? { output: exit.value } : {},
+          ...Exit.isFailure(exit) ? { error: errorText(Cause.squash(exit.cause)) } : {}
+        }
+      };
+      return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)];
+    });
+    if (result.info && result.done)
+      yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore);
+    if (result.scope) {
+      yield* Scope.close(result.scope, Exit.void).pipe(Effect.forkIn(state.scope, { startImmediately: true }));
+    }
+    return result.info;
+  });
+  const fork = Effect.fn("Job.fork")(function* (scope, id, token, run) {
+    return yield* run.pipe(Effect.matchCauseEffect({
+      onSuccess: (output) => settle(id, token, Exit.succeed(output)),
+      onFailure: (cause) => settle(id, token, Exit.failCause(cause))
+    }), Effect.asVoid, Effect.forkIn(scope, { startImmediately: true }));
+  });
+  const get = Effect.fn("Job.get")(function* (id) {
+    const job = (yield* SynchronizedRef.get(state.jobs)).get(id);
+    if (!job)
+      return;
+    return snapshot(job);
+  });
+  const start = Effect.fn("Job.start")(function* (input) {
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      const id = input.id ?? exports_id.ascending("job");
+      const started_at = yield* Clock.currentTimeMillis;
+      const done = yield* Deferred.make();
+      const backgrounded = yield* Deferred.make();
+      const result = yield* SynchronizedRef.modifyEffect(state.jobs, Effect.fnUntraced(function* (jobs) {
+        const existing = jobs.get(id);
+        if (existing?.info.status === "running") {
+          return [{ info: snapshot(existing) }, jobs];
+        }
+        const scope = yield* Scope.fork(state.scope, "parallel");
+        const token = {};
+        const job = {
+          info: {
+            id,
+            type: input.type,
+            title: input.title,
+            status: "running",
+            started_at,
+            metadata: input.metadata
+          },
+          done,
+          backgrounded,
+          scope,
+          token,
+          blockingSessions: new Map,
+          isBackgrounded: false
+        };
+        return [{ info: snapshot(job), scope, token }, new Map(jobs).set(id, job)];
+      }));
+      if ("scope" in result)
+        yield* fork(result.scope, id, result.token, restore(input.run));
+      return result.info;
+    }));
+  });
+  const wait = Effect.fn("Job.wait")(function* (input) {
+    const job = (yield* SynchronizedRef.get(state.jobs)).get(input.id);
+    if (!job)
+      return { timedOut: false };
+    if (job.info.status !== "running")
+      return { info: snapshot(job), timedOut: false };
+    if (input.timeout === undefined)
+      return { info: yield* Deferred.await(job.done), timedOut: false };
+    if (input.timeout <= 0)
+      return { info: snapshot(job), timedOut: true };
+    const info = yield* Deferred.await(job.done).pipe(Effect.timeoutOption(input.timeout));
+    if (info._tag === "Some")
+      return { info: info.value, timedOut: false };
+    return { info: snapshot(job), timedOut: true };
+  });
+  const removeBlock = Effect.fn("Job.removeBlock")(function* (input) {
+    yield* SynchronizedRef.update(state.jobs, (jobs) => {
+      const job = jobs.get(input.id);
+      if (!job || job.info.status !== "running" || job.isBackgrounded)
+        return jobs;
+      return new Map(jobs).set(input.id, {
+        ...job,
+        blockingSessions: decrementSession(job.blockingSessions, input.sessionID)
+      });
+    });
+  });
+  const block = Effect.fn("Job.block")(function* (input) {
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      const job = jobs.get(input.id);
+      if (!job)
+        return [{ type: "missing" }, jobs];
+      if (job.info.status !== "running")
+        return [{ type: "finished", info: snapshot(job) }, jobs];
+      if (job.isBackgrounded)
+        return [{ type: "backgrounded", info: snapshot(job) }, jobs];
+      return [
+        { type: "wait", wait: { done: job.done, backgrounded: job.backgrounded } },
+        new Map(jobs).set(input.id, {
+          ...job,
+          blockingSessions: incrementSession(job.blockingSessions, input.sessionID)
+        })
+      ];
+    });
+    if (result.type === "missing")
+      return;
+    if (result.type === "finished")
+      return { type: "finished", info: result.info };
+    if (result.type === "backgrounded")
+      return { type: "backgrounded", info: result.info };
+    return yield* Effect.raceFirst(Deferred.await(result.wait.done).pipe(Effect.map((info) => ({ type: "finished", info }))), Deferred.await(result.wait.backgrounded).pipe(Effect.map((info) => ({ type: "backgrounded", info })))).pipe(Effect.ensuring(removeBlock(input)));
+  });
+  const background = Effect.fn("Job.background")(function* (id) {
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      const job = jobs.get(id);
+      if (!job || job.info.status !== "running")
+        return [{}, jobs];
+      if (job.isBackgrounded)
+        return [{ info: snapshot(job) }, jobs];
+      const next = {
+        ...job,
+        isBackgrounded: true,
+        blockingSessions: new Map
+      };
+      return [{ info: snapshot(next), backgrounded: job.backgrounded }, new Map(jobs).set(id, next)];
+    });
+    if (result.info && result.backgrounded)
+      yield* Deferred.succeed(result.backgrounded, result.info).pipe(Effect.ignore);
+    return result.info;
+  });
+  const backgroundAll = Effect.fn("Job.backgroundAll")(function* (input) {
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      const results = [];
+      const next = new Map(jobs);
+      for (const [id, job] of jobs) {
+        if (job.info.status !== "running")
+          continue;
+        if (job.isBackgrounded)
+          continue;
+        if (input.type !== undefined && job.info.type !== input.type)
+          continue;
+        if (!job.blockingSessions.has(input.sessionID))
+          continue;
+        const updated = {
+          ...job,
+          isBackgrounded: true,
+          blockingSessions: new Map
+        };
+        results.push({ info: snapshot(updated), backgrounded: job.backgrounded });
+        next.set(id, updated);
+      }
+      return [results, next];
+    });
+    yield* Effect.forEach(result, (item) => item.info && item.backgrounded ? Deferred.succeed(item.backgrounded, item.info) : Effect.void, { discard: true });
+    return result.flatMap((item) => item.info ? [item.info] : []);
+  });
+  const cancel = Effect.fn("Job.cancel")(function* (id) {
+    const completed_at = yield* Clock.currentTimeMillis;
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+      const job = jobs.get(id);
+      if (!job)
+        return [{}, jobs];
+      if (job.info.status !== "running")
+        return [{ info: snapshot(job) }, jobs];
+      const next = {
+        ...job,
+        blockingSessions: new Map,
+        info: {
+          ...job.info,
+          status: "cancelled",
+          completed_at
+        }
+      };
+      return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)];
+    });
+    if (result.info && result.done)
+      yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore);
+    if (result.scope)
+      yield* Scope.close(result.scope, Exit.void);
+    return result.info;
+  });
+  return Service.of({ get, start, wait, block, background, backgroundAll, cancel });
+});
+var layer = Layer.effect(Service, make);
+var node = makeGlobalNode({ service: Service, layer, deps: [] });
+
+export { Service, make, node, exports_job };

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

@@ -0,0 +1,17 @@
+// src/github-copilot/responses/tool/web-search.ts
+import { z } from "zod/v4";
+var webSearchArgsSchema = z.object({
+  filters: z.object({
+    allowedDomains: z.array(z.string()).optional()
+  }).optional(),
+  searchContextSize: z.enum(["low", "medium", "high"]).optional(),
+  userLocation: z.object({
+    type: z.literal("approximate"),
+    country: z.string().optional(),
+    city: z.string().optional(),
+    region: z.string().optional(),
+    timezone: z.string().optional()
+  }).optional()
+});
+
+export { webSearchArgsSchema };

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

@@ -0,0 +1,106 @@
+import {
+  which
+} from "./location-mutation-g7k9te92.js";
+
+// src/ripgrep/binary.ts
+import path from "path";
+import { Context, Effect, Layer, Stream } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { ChildProcess } from "effect/unstable/process";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import { CrossSpawnSpawner } from "@opencode-ai/util/cross-spawn-spawner";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { httpClient } from "@opencode-ai/util/effect/app-node-platform";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+var RipgrepBinary;
+((RipgrepBinary) => {
+  const VERSION = "15.1.0";
+  const PLATFORM = {
+    "arm64-darwin": { platform: "aarch64-apple-darwin", extension: "tar.gz" },
+    "arm64-linux": { platform: "aarch64-unknown-linux-gnu", extension: "tar.gz" },
+    "x64-darwin": { platform: "x86_64-apple-darwin", extension: "tar.gz" },
+    "x64-linux": { platform: "x86_64-unknown-linux-musl", extension: "tar.gz" },
+    "arm64-win32": { platform: "aarch64-pc-windows-msvc", extension: "zip" },
+    "ia32-win32": { platform: "i686-pc-windows-msvc", extension: "zip" },
+    "x64-win32": { platform: "x86_64-pc-windows-msvc", extension: "zip" }
+  };
+
+  class Service extends Context.Service()("@opencode/RipgrepBinary") {
+  }
+  RipgrepBinary.Service = Service;
+  const layer = Layer.effect(Service, Effect.gen(function* () {
+    const fs = yield* FSUtil.Service;
+    const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+    const spawner = yield* ChildProcessSpawner;
+    const global = yield* Global.Service;
+    const findExecutable = (name) => which(name, undefined, global.bin);
+    const run = Effect.fnUntraced(function* (command, args) {
+      const handle = yield* spawner.spawn(ChildProcess.make(command, args, { extendEnv: true, stdin: "ignore" }));
+      const [stdout, stderr, code] = yield* Effect.all([
+        Stream.mkString(Stream.decodeText(handle.stdout)),
+        Stream.mkString(Stream.decodeText(handle.stderr)),
+        handle.exitCode
+      ], { concurrency: "unbounded" });
+      return { stdout, stderr, code };
+    }, Effect.scoped);
+    const extract = Effect.fnUntraced(function* (archive, config, target) {
+      const dir = yield* fs.makeTempDirectoryScoped({ directory: global.bin, prefix: "ripgrep-" });
+      if (config.extension === "zip") {
+        const shell = (yield* Effect.sync(() => findExecutable("powershell.exe") ?? findExecutable("pwsh.exe"))) ?? "powershell.exe";
+        const result = yield* run(shell, [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `$global:ProgressPreference = 'SilentlyContinue'; Expand-Archive -LiteralPath '${archive.replaceAll("'", "''")}' -DestinationPath '${dir.replaceAll("'", "''")}' -Force`
+        ]);
+        if (result.code !== 0)
+          throw new Error(result.stderr.trim() || result.stdout.trim() || `ripgrep extraction failed with code ${result.code}`);
+      }
+      if (config.extension === "tar.gz") {
+        const result = yield* run("tar", ["-xzf", archive, "-C", dir]);
+        if (result.code !== 0)
+          throw new Error(result.stderr.trim() || result.stdout.trim() || `ripgrep extraction failed with code ${result.code}`);
+      }
+      const extracted = path.join(dir, `ripgrep-${VERSION}-${config.platform}`, process.platform === "win32" ? "rg.exe" : "rg");
+      if (!(yield* fs.isFile(extracted)))
+        throw new Error(`ripgrep archive did not contain executable: ${extracted}`);
+      yield* fs.copyFile(extracted, target);
+      if (process.platform !== "win32")
+        yield* fs.chmod(target, 493);
+    }, Effect.scoped);
+    return Service.of({
+      filepath: yield* Effect.cached(Effect.gen(function* () {
+        const system = yield* Effect.sync(() => findExecutable(process.platform === "win32" ? "rg.exe" : "rg"));
+        if (system && (yield* fs.isFile(system).pipe(Effect.orDie)))
+          return system;
+        const target = path.join(global.bin, `rg${process.platform === "win32" ? ".exe" : ""}`);
+        if (yield* fs.isFile(target).pipe(Effect.orDie))
+          return target;
+        const platformKey = `${process.arch}-${process.platform}`;
+        const config = PLATFORM[platformKey];
+        if (!config)
+          throw new Error(`unsupported platform for ripgrep: ${platformKey}`);
+        const filename = `ripgrep-${VERSION}-${config.platform}.${config.extension}`;
+        const url = `https://github.com/BurntSushi/ripgrep/releases/download/${VERSION}/${filename}`;
+        const archive = path.join(global.bin, filename);
+        yield* Effect.logInfo("downloading ripgrep", { url });
+        yield* fs.ensureDir(global.bin).pipe(Effect.orDie);
+        const bytes = yield* HttpClientRequest.get(url).pipe(http.execute, Effect.flatMap((response) => response.arrayBuffer), Effect.mapError((cause) => cause instanceof Error ? cause : new Error(String(cause))));
+        if (bytes.byteLength === 0)
+          throw new Error(`failed to download ripgrep from ${url}`);
+        yield* fs.writeWithDirs(archive, new Uint8Array(bytes));
+        yield* extract(archive, config, target);
+        yield* fs.remove(archive, { force: true }).pipe(Effect.ignore);
+        return target;
+      }))
+    });
+  }));
+  RipgrepBinary.node = makeGlobalNode({
+    service: Service,
+    layer,
+    deps: [FSUtil.node, Global.node, httpClient, CrossSpawnSpawner.node]
+  });
+})(RipgrepBinary ||= {});
+
+export { RipgrepBinary };

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

@@ -0,0 +1,94 @@
+import {
+  schema_gen_default
+} from "./location-mutation-ecxv0vtt.js";
+import {
+  migrations
+} from "./location-mutation-04qt761j.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/database/migration.ts
+var exports_migration = {};
+__export(exports_migration, {
+  applyOnly: () => applyOnly,
+  apply: () => apply,
+  DatabaseMigration: () => exports_migration
+});
+import { sql } from "drizzle-orm";
+import { Effect, Semaphore } from "effect";
+import { supportsForeignKeyToggle } from "#sqlite";
+var lock = Semaphore.makeUnsafe(1);
+function apply(db) {
+  return lock.withPermit(Effect.gen(function* () {
+    const tables = yield* db.all(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND substr(name, 1, 1) <> '_'`);
+    if (tables.some((table) => table.name === "session" || table.name === "session_v2"))
+      return yield* applyOnly(db, migrations);
+    if (tables.length > 0)
+      return yield* Effect.die(new Error("Database is not empty and has no session table"));
+    const started = Date.now();
+    yield* Effect.logInfo("database schema bootstrap started", { migrations: migrations.length });
+    yield* db.transaction((tx) => Effect.gen(function* () {
+      yield* schema_gen_default.up(tx);
+      yield* tx.run(sql`CREATE TABLE ${sql.identifier("migration")} (id TEXT PRIMARY KEY, time_completed INTEGER NOT NULL)`);
+      yield* Effect.forEach(migrations, (migration) => tx.run(sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`));
+    }));
+    yield* Effect.logInfo("database schema bootstrap completed", {
+      migrations: migrations.length,
+      durationMs: Date.now() - started
+    });
+  }));
+}
+function applyOnly(db, input) {
+  return Effect.gen(function* () {
+    yield* db.run(sql`CREATE TABLE IF NOT EXISTS ${sql.identifier("migration")} (id TEXT PRIMARY KEY, time_completed INTEGER NOT NULL)`);
+    let completed = new Set((yield* db.all(sql`SELECT id FROM ${sql.identifier("migration")}`)).map((row) => row.id));
+    if (completed.size === 0) {
+      if (yield* db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${"__drizzle_migrations"}`)) {
+        yield* db.run(sql`
+          INSERT OR IGNORE INTO ${sql.identifier("migration")} (id, time_completed)
+          SELECT name, ${Date.now()}
+          FROM ${sql.identifier("__drizzle_migrations")}
+          WHERE name IS NOT NULL
+        `);
+        completed = new Set((yield* db.all(sql`SELECT id FROM ${sql.identifier("migration")}`)).map((row) => row.id));
+      }
+    }
+    for (const migration of input) {
+      if (completed.has(migration.id))
+        continue;
+      const started = Date.now();
+      yield* Effect.logInfo("database migration started", { migration: migration.id });
+      const apply2 = db.transaction((tx) => Effect.gen(function* () {
+        yield* migration.up(tx);
+        yield* tx.run(sql`INSERT INTO ${sql.identifier("migration")} (id, time_completed) VALUES (${migration.id}, ${Date.now()})`);
+      }));
+      if (migration.foreignKeys !== false) {
+        yield* apply2.pipe(Effect.tapError((error) => Effect.logError("database migration failed", {
+          migration: migration.id,
+          durationMs: Date.now() - started,
+          error
+        })));
+        yield* Effect.logInfo("database migration completed", {
+          migration: migration.id,
+          durationMs: Date.now() - started
+        });
+        continue;
+      }
+      const relaxForeignKeys = supportsForeignKeyToggle ? db.run(sql`PRAGMA foreign_keys = OFF`) : db.run(sql`PRAGMA defer_foreign_keys = ON`);
+      const restoreForeignKeys = supportsForeignKeyToggle ? db.run(sql`PRAGMA foreign_keys = ON`) : Effect.void;
+      yield* relaxForeignKeys;
+      yield* apply2.pipe(Effect.ensuring(restoreForeignKeys.pipe(Effect.orDie)), Effect.tapError((error) => Effect.logError("database migration failed", {
+        migration: migration.id,
+        durationMs: Date.now() - started,
+        error
+      })));
+      yield* Effect.logInfo("database migration completed", {
+        migration: migration.id,
+        durationMs: Date.now() - started
+      });
+    }
+  });
+}
+
+export { apply, applyOnly, exports_migration };

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

@@ -0,0 +1,124 @@
+import {
+  exports_catalog
+} from "./location-mutation-57tzwnz4.js";
+import {
+  exports_instructions
+} from "./location-mutation-8k8ks5a6.js";
+import {
+  __export
+} from "./location-mutation-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 };