@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-2402vzrj.js

@@ -0,0 +1,175 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/repository.ts
+var exports_repository = {};
+__export(exports_repository, {
+  InvalidBranchError: () => InvalidBranchError3,
+  InvalidReferenceError: () => InvalidReferenceError2,
+  Repository: () => exports_repository,
+  UnsupportedLocalRepositoryError: () => UnsupportedLocalRepositoryError2,
+  cacheIdentity: () => cacheIdentity2,
+  cachePath: () => cachePath2,
+  isFile: () => isFile2,
+  isRemote: () => isRemote2,
+  parse: () => parse4,
+  parseRemote: () => parseRemote2,
+  same: () => same2,
+  validateBranch: () => validateBranch3
+});
+import path from "path";
+import { fileURLToPath } from "url";
+import { Schema } from "effect";
+
+class InvalidReferenceError2 extends Schema.TaggedError()("RepositoryInvalidReferenceError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class UnsupportedLocalRepositoryError2 extends Schema.TaggedError()("RepositoryUnsupportedLocalRepositoryError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class InvalidBranchError3 extends Schema.TaggedError()("RepositoryInvalidBranchError", {
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+function parse4(input) {
+  const cleaned = normalizeInput(input);
+  if (!cleaned)
+    return;
+  const githubPrefixed = cleaned.match(/^github:([^/\s]+)\/([^/\s]+)$/);
+  if (githubPrefixed)
+    return buildRemote({ host: "github.com", segments: [githubPrefixed[1], githubPrefixed[2]] });
+  if (!cleaned.includes("://")) {
+    const scp = cleaned.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/);
+    if (scp)
+      return buildRemote({ host: scp[1], segments: parts(scp[2]), remote: cleaned });
+    const direct = parts(cleaned);
+    if (direct.length >= 2 && hostLike(direct[0]))
+      return buildRemote({ host: direct[0], segments: direct.slice(1) });
+    if (direct.length === 2)
+      return buildRemote({ host: "github.com", segments: direct });
+  }
+  try {
+    const url = new URL(cleaned);
+    if (url.protocol === "file:")
+      return buildFile({ url, remote: cleaned });
+    const segments = parts(url.pathname);
+    return buildRemote({
+      host: url.host,
+      segments,
+      remote: url.host === "github.com" ? githubRemote(segments.join("/")) : cleaned,
+      protocol: url.protocol
+    });
+  } catch {
+    return;
+  }
+}
+function parseRemote2(input) {
+  const reference = parse4(input);
+  if (!reference) {
+    throw new InvalidReferenceError2({
+      repository: input,
+      message: "Repository must be a git URL, host/path reference, or GitHub owner/repo shorthand"
+    });
+  }
+  if (!isRemote2(reference)) {
+    throw new UnsupportedLocalRepositoryError2({
+      repository: input,
+      message: "Local file repositories are not supported"
+    });
+  }
+  return reference;
+}
+function validateBranch3(branch) {
+  if (/^[A-Za-z0-9/_.-]+$/.test(branch) && !branch.startsWith("-") && !branch.includes(".."))
+    return;
+  throw new InvalidBranchError3({
+    branch,
+    message: "Branch must contain only alphanumeric characters, /, _, ., and -, and cannot start with - or contain .."
+  });
+}
+function isFile2(reference) {
+  return reference.protocol === "file:";
+}
+function isRemote2(reference) {
+  return !isFile2(reference);
+}
+function cachePath2(root, reference, branch) {
+  const base = path.join(root, ...reference.host.split(":"), ...reference.segments);
+  return branch ? `${base}@${encodeURIComponent(branch)}` : base;
+}
+function cacheIdentity2(reference) {
+  return `${reference.host}/${reference.path}`;
+}
+function same2(left, right) {
+  return cacheIdentity2(left) === cacheIdentity2(right);
+}
+function normalizeInput(input) {
+  return input.trim().replace(/^git\+/, "").replace(/#.*$/, "").replace(/\/+$/, "");
+}
+function trimGitSuffix(input) {
+  return input.replace(/\.git$/, "");
+}
+function parts(input) {
+  return input.split("/").map((item) => trimGitSuffix(item.trim())).filter(Boolean);
+}
+function safeHost(input) {
+  return Boolean(input) && !input.startsWith("-") && !/[\s/\\]/.test(input);
+}
+function safeSegment(input) {
+  return input !== "." && input !== ".." && !input.includes(":") && !/[\s/\\]/.test(input);
+}
+function hostLike(input) {
+  return input.includes(".") || input.includes(":") || input === "localhost";
+}
+function withSlash(input) {
+  return input.endsWith("/") ? input : `${input}/`;
+}
+function githubRemote(pathname) {
+  const base = process.env.OPENCODE_REPO_CLONE_GITHUB_BASE_URL;
+  if (!base)
+    return `https://github.com/${pathname}.git`;
+  return new URL(`${pathname}.git`, withSlash(base)).href;
+}
+function buildRemote(input) {
+  const segments = input.segments.map(trimGitSuffix).filter(Boolean);
+  if (!safeHost(input.host) || !segments.length || segments.some((segment) => !safeSegment(segment)))
+    return;
+  const repositoryPath = segments.join("/");
+  const host = input.host.toLowerCase();
+  return {
+    host,
+    path: repositoryPath,
+    segments,
+    owner: segments.length === 2 ? segments[0] : undefined,
+    repo: segments[segments.length - 1],
+    remote: input.remote ?? (host === "github.com" ? githubRemote(repositoryPath) : `https://${host}/${repositoryPath}.git`),
+    label: host === "github.com" && segments.length === 2 ? repositoryPath : `${host}/${repositoryPath}`,
+    protocol: input.protocol
+  };
+}
+function buildFile(input) {
+  const filePath = path.normalize(fileURLToPath(input.url));
+  const segments = filePath.split(/[\\/]+/).filter(Boolean);
+  if (!segments.length)
+    return;
+  return {
+    host: "file",
+    path: filePath,
+    segments: segments.map((segment) => segment.replace(/:$/, "")),
+    owner: undefined,
+    repo: trimGitSuffix(segments[segments.length - 1]),
+    remote: input.remote,
+    label: filePath,
+    protocol: "file:"
+  };
+}
+
+export { InvalidReferenceError2, UnsupportedLocalRepositoryError2, InvalidBranchError3, parse4, parseRemote2, validateBranch3, isFile2, isRemote2, cachePath2, cacheIdentity2, same2, exports_repository };

package/dist/chunks/repository-2710q6r3.js

@@ -0,0 +1,20 @@
+// src/event/sql.ts
+import { sqliteTable, text, integer, index, uniqueIndex } from "drizzle-orm/sqlite-core";
+var EventSequenceTable2 = sqliteTable("event_sequence", {
+  aggregate_id: text().notNull().primaryKey(),
+  seq: integer().notNull(),
+  owner_id: text()
+});
+var EventTable2 = sqliteTable("event", {
+  id: text().$type().primaryKey(),
+  aggregate_id: text().notNull().references(() => EventSequenceTable2.aggregate_id, { onDelete: "cascade" }),
+  seq: integer().notNull(),
+  created: integer().notNull().default(0),
+  type: text().notNull(),
+  data: text({ mode: "json" }).$type().notNull()
+}, (table) => [
+  uniqueIndex("event_aggregate_seq_idx").on(table.aggregate_id, table.seq),
+  index("event_aggregate_type_seq_idx").on(table.aggregate_id, table.type, table.seq)
+]);
+
+export { EventSequenceTable2, EventTable2 };

package/dist/chunks/repository-27wgnz1z.js

@@ -0,0 +1,49 @@
+import {
+  Service44
+} from "./repository-smnv2tch.js";
+import {
+  Service31
+} from "./repository-3yetcf2r.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/plugin/mcp.ts
+var exports_mcp = {};
+__export(exports_mcp, {
+  ConfigMcpPlugin: () => exports_mcp,
+  Plugin: () => Plugin7,
+  register: () => register2
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect, Stream } from "effect";
+var Plugin7 = define({
+  id: "opencode.config.mcp",
+  effect: Effect.fn(function* (ctx) {
+    yield* register2(ctx.event.subscribe());
+  })
+});
+var register2 = Effect.fn("ConfigMCPPlugin.register")(function* (events) {
+  const config = yield* Service44;
+  const mcp = yield* Service31;
+  const loaded = { entries: [] };
+  yield* events.pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(mcp.reload()), Effect.catchCause((cause) => Effect.logError("failed to reload MCP config", { cause })))), Effect.ignore, Effect.forkScoped({ startImmediately: true }));
+  loaded.entries = yield* config.entries();
+  yield* mcp.transform((editor) => {
+    const documents = loaded.entries.filter((entry) => entry.type === "document");
+    const timeout = Object.assign({}, ...documents.flatMap((entry) => entry.info.mcp?.timeout ? [entry.info.mcp.timeout] : []));
+    const servers = new Map;
+    for (const document of documents) {
+      for (const [name, server] of Object.entries(document.info.mcp?.servers ?? {})) {
+        servers.set(name, server);
+      }
+    }
+    for (const [name, server] of servers) {
+      if (editor.get(name))
+        continue;
+      editor.set(name, { ...server, timeout: { ...timeout, ...server.timeout } });
+    }
+  });
+});
+
+export { Plugin7, register2, exports_mcp };

package/dist/chunks/repository-2a5m3afh.js

@@ -0,0 +1,36 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/environment/files.ts
+var exports_files = {};
+__export(exports_files, {
+  EnvironmentFiles: () => exports_files,
+  Failed: () => Failed2,
+  FileType: () => FileType2,
+  NotFound: () => NotFound2,
+  WrongKind: () => WrongKind2,
+  typeFollowing: () => typeFollowing2
+});
+import { Effect, Schema } from "effect";
+var FileType2 = Schema.Literals(["file", "directory", "symlink", "other"]);
+
+class NotFound2 extends Schema.TaggedError()("Environment.NotFound", {
+  path: Schema.String
+}) {
+}
+
+class WrongKind2 extends Schema.TaggedError()("Environment.WrongKind", {
+  path: Schema.String,
+  actual: FileType2
+}) {
+}
+
+class Failed2 extends Schema.TaggedError()("Environment.Failed", {
+  path: Schema.String,
+  cause: Schema.Defect()
+}) {
+}
+var typeFollowing2 = (files, path) => files.stat(path).pipe(Effect.flatMap((info) => info.type === "symlink" ? files.read(path, { offset: 0, length: 0 }).pipe(Effect.map((result) => result.info.type), Effect.catchTag("Environment.WrongKind", (error) => Effect.succeed(error.actual))) : Effect.succeed(info.type)));
+
+export { FileType2, NotFound2, WrongKind2, Failed2, typeFollowing2, exports_files };

package/dist/chunks/repository-2axfhc9x.js

@@ -0,0 +1,49 @@
+// src/util/error.ts
+import { Schema } from "effect";
+
+class NamedError2 extends Error {
+  static hasName(error, name) {
+    return typeof error === "object" && error !== null && "name" in error && error.name === name;
+  }
+  static create(name, data) {
+    return NamedError2.createSchemaClass(name, Schema.isSchema(data) ? data : Schema.Struct(data));
+  }
+  static createSchemaClass(name, data) {
+    const schema = Schema.Struct({
+      name: Schema.Literal(name),
+      data
+    }).annotate({ identifier: name });
+    const result = class extends NamedError2 {
+      data;
+      static Schema = schema;
+      static EffectSchema = schema;
+      static tag = name;
+      name = name;
+      constructor(data, options) {
+        super(name, options);
+        this.data = data;
+        this.name = name;
+      }
+      static isInstance(input) {
+        return NamedError2.hasName(input, name);
+      }
+      schema() {
+        return schema;
+      }
+      toObject() {
+        return {
+          name,
+          data: this.data
+        };
+      }
+    };
+    Object.defineProperty(result, "name", { value: name });
+    return result;
+  }
+  static Unknown = NamedError2.create("UnknownError", {
+    message: Schema.String,
+    ref: Schema.optional(Schema.String)
+  });
+}
+
+export { NamedError2 };

package/dist/chunks/repository-2c3vjs8z.js

@@ -0,0 +1,17 @@
+// src/database/migration/20260603001617_session_message_projection_indexes.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260603001617_session_message_projection_indexes",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_message_session_idx\`;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_message_session_type_idx\`;`);
+      yield* tx.run(`CREATE INDEX \`event_aggregate_seq_idx\` ON \`event\` (\`aggregate_id\`,\`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_session_type_time_created_id_idx\` ON \`session_message\` (\`session_id\`,\`type\`,\`time_created\`,\`id\`);`);
+    });
+  }
+};
+var _20260603001617_session_message_projection_indexes_default = migration;
+
+export { _20260603001617_session_message_projection_indexes_default };

package/dist/chunks/repository-2cgm8dc1.js

@@ -0,0 +1,61 @@
+import {
+  Service54
+} from "./repository-mw6spqsr.js";
+import {
+  Service26
+} from "./repository-51cmmk6m.js";
+import {
+  text2,
+  deliver2
+} from "./repository-x1ezjp6w.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/subagent-job.ts
+var exports_subagent_job = {};
+__export(exports_subagent_job, {
+  SubagentJob: () => exports_subagent_job,
+  make: () => make10
+});
+import { Effect, Scope } from "effect";
+var make10 = Effect.gen(function* () {
+  const sessions = yield* Service26;
+  const jobs = yield* Service54;
+  const scope = yield* Scope.Scope;
+  const notifications = new Set;
+  const notify = Effect.fn("SubagentJob.notify")(function* (recovery, startedAt) {
+    const key = `${recovery.childSessionID}:${startedAt}`;
+    if (notifications.has(key))
+      return;
+    notifications.add(key);
+    yield* Effect.gen(function* () {
+      const info = (yield* jobs.wait({ id: recovery.childSessionID })).info;
+      if (info)
+        yield* deliver2(sessions, jobs, { ...info, recovery });
+    }).pipe(Effect.ensuring(Effect.sync(() => notifications.delete(key))), Effect.forkIn(scope, { startImmediately: true }));
+  });
+  return {
+    start: (recovery) => jobs.start({
+      id: recovery.childSessionID,
+      type: "subagent",
+      title: recovery.description,
+      metadata: {},
+      recovery,
+      run: Effect.gen(function* () {
+        yield* sessions.resume(recovery.childSessionID);
+        const messages = yield* sessions.messages({ sessionID: recovery.childSessionID, order: "desc", limit: 20 });
+        const assistant = messages.find((message) => message.type === "assistant" && message.time.completed !== undefined && message.error === undefined);
+        return text2(assistant);
+      })
+    }),
+    background: Effect.fn("SubagentJob.background")(function* (recovery) {
+      const info = yield* jobs.background(recovery.childSessionID);
+      if (info)
+        yield* notify(recovery, info.started_at);
+    }),
+    notify
+  };
+});
+
+export { make10, exports_subagent_job };

package/dist/chunks/repository-2fbr18f9.js

@@ -0,0 +1,145 @@
+import {
+  Service79,
+  node84
+} from "./repository-8m31s27t.js";
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  Service54,
+  node58
+} from "./repository-mw6spqsr.js";
+import {
+  Service52,
+  node56
+} from "./repository-1bvekr7f.js";
+import {
+  SessionEvent2
+} from "./repository-ec1grn59.js";
+import {
+  make18
+} from "./repository-r8xr0va3.js";
+import {
+  DrainResult2,
+  Service49
+} from "./repository-8gxqpgph.js";
+import {
+  UserInterruptedError2
+} from "./repository-3x8gcmrs.js";
+import {
+  Service60,
+  node64
+} from "./repository-1n274c67.js";
+import {
+  toSessionError2
+} from "./repository-ezbaq0hv.js";
+import {
+  nextPromotable2
+} from "./repository-0wjw63yk.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/execution.ts
+var exports_execution = {};
+__export(exports_execution, {
+  Service: () => Service48,
+  SessionExecution: () => exports_execution,
+  layer: () => layer20,
+  node: () => node53,
+  noopLayer: () => noopLayer3,
+  terminal: () => terminal2
+});
+import { Cause, Context, Effect, Exit, Layer } from "effect";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+class Service48 extends Context.Service()("@opencode/SessionExecution") {
+}
+function terminal2(exit, reason) {
+  if (Exit.isSuccess(exit))
+    return { type: "succeeded" };
+  if (Cause.hasInterrupts(exit.cause))
+    return { type: "interrupted", reason: reason ?? "shutdown" };
+  const failure = Cause.squash(exit.cause);
+  if (failure instanceof UserInterruptedError2)
+    return { type: "interrupted", reason: "user" };
+  return { type: "failed", error: toSessionError2(failure) };
+}
+var layer20 = Layer.effect(Service48, Effect.gen(function* () {
+  const store = yield* Service60;
+  const instances = yield* Service52;
+  const bus = yield* Service78;
+  const jobs = yield* Service54;
+  const db = (yield* Service79).db;
+  const reportLifecycle = (sessionID, effect) => effect.pipe(Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logError("Failed to publish Session execution lifecycle", cause).pipe(Effect.annotateLogs({ sessionID }))), Effect.asVoid);
+  const claimOnCommit = (sessionID) => ({
+    commit: () => store.claim(sessionID)
+  });
+  const releaseOnCommit = (sessionID) => ({
+    commit: () => store.release(sessionID)
+  });
+  const drain = Effect.fnUntraced(function* (sessionID, force, continuation, promotable = "input") {
+    const session = yield* store.get(sessionID);
+    if (!session)
+      return yield* Effect.die(new Error(`Session not found: ${sessionID}`));
+    const result = yield* Service49.use((runner) => runner.drain({ sessionID, force, continuation, promotable })).pipe(instances.provide(session), Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logError("Failed to drain Session", cause).pipe(Effect.annotateLogs({ sessionID }))));
+    return yield* DrainResult2.$match(result, {
+      Complete: () => Effect.void,
+      Moved: (result) => drain(sessionID, false, result.continuation, promotable)
+    });
+  });
+  const coordinator = yield* make18({
+    started: (sessionID) => reportLifecycle(sessionID, bus.publish(SessionEvent2.Execution.Started, { sessionID }, claimOnCommit(sessionID))),
+    drain: (sessionID, force, promotable) => drain(sessionID, force, undefined, promotable),
+    settled: (sessionID, exit, reason) => reportLifecycle(sessionID, Effect.gen(function* () {
+      const outcome = terminal2(exit, reason);
+      if (outcome.type === "succeeded") {
+        yield* bus.publish(SessionEvent2.Execution.Succeeded, { sessionID }, releaseOnCommit(sessionID));
+        return;
+      }
+      if (outcome.type === "interrupted") {
+        if (outcome.reason !== "shutdown")
+          yield* jobs.cancel(sessionID);
+        yield* bus.publish(SessionEvent2.Execution.Interrupted, { sessionID, reason: outcome.reason }, outcome.reason === "shutdown" ? undefined : releaseOnCommit(sessionID));
+        return;
+      }
+      yield* bus.publish(SessionEvent2.Execution.Failed, {
+        sessionID,
+        error: outcome.error
+      }, releaseOnCommit(sessionID));
+    }))
+  });
+  return Service48.of({
+    active: coordinator.active,
+    isActive: coordinator.isActive,
+    interrupt: (sessionID, options) => Effect.gen(function* () {
+      const interrupted = yield* coordinator.interrupt(sessionID, options?.reason ?? "user", options);
+      if (!options?.continue)
+        return interrupted;
+      const next = yield* nextPromotable2(db, sessionID, "input");
+      if (next === undefined)
+        return interrupted;
+      if (next.delivery === "steer" || next.type === "compaction" || next.type === "move")
+        yield* coordinator.wake(sessionID, "steer");
+      return interrupted;
+    }),
+    resume: coordinator.run,
+    wake: coordinator.wake,
+    awaitIdle: coordinator.awaitIdle
+  });
+}));
+var node53 = makeGlobalNode({
+  service: Service48,
+  layer: layer20,
+  deps: [node64, node56, node83, node84, node58]
+});
+var noopLayer3 = Layer.succeed(Service48, Service48.of({
+  active: Effect.succeed(new Set),
+  isActive: () => Effect.succeed(false),
+  resume: () => Effect.void,
+  wake: () => Effect.void,
+  interrupt: () => Effect.succeed(false),
+  awaitIdle: () => Effect.void
+}));
+
+export { Service48, terminal2, layer20, node53, noopLayer3, exports_execution };

package/dist/chunks/repository-2k8khapm.js

@@ -0,0 +1,16 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/v1/config/plugin.ts
+var exports_plugin3 = {};
+__export(exports_plugin3, {
+  ConfigPluginV1: () => exports_plugin3,
+  Options: () => Options8,
+  Spec: () => Spec2
+});
+import { Schema } from "effect";
+var Options8 = Schema.Record(Schema.String, Schema.Unknown);
+var Spec2 = Schema.Union([Schema.String, Schema.mutable(Schema.Tuple([Schema.String, Options8]))]);
+
+export { Options8, Spec2, exports_plugin3 };

package/dist/chunks/repository-2m84dfka.js

@@ -0,0 +1,88 @@
+import {
+  Key3,
+  removed2,
+  empty3,
+  make20,
+  diffByKey2
+} from "./repository-rhjbct0v.js";
+import {
+  ID5,
+  Name2,
+  available2,
+  Service40,
+  node45
+} from "./repository-9xb0s4b9.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/skill/instructions.ts
+var exports_instructions5 = {};
+__export(exports_instructions5, {
+  Service: () => Service33,
+  SkillInstructions: () => exports_instructions5,
+  node: () => node38
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+var Summary = Schema.Struct({
+  id: ID5,
+  name: Name2,
+  description: Schema.String
+});
+var entries = (skills) => skills.flatMap((skill) => [
+  "  <skill>",
+  `    <id>${skill.id}</id>`,
+  `    <name>${skill.name}</name>`,
+  `    <description>${skill.description}</description>`,
+  "  </skill>"
+]);
+var render = (skills) => [
+  "Skills provide specialized instructions and workflows for specific tasks.",
+  "Use the skill tool to load a skill when a task matches its description.",
+  ...skills.length === 0 ? ["No skills are currently available."] : ["<available_skills>", ...entries(skills), "</available_skills>"]
+].join(`
+`);
+var update = (previous, current) => {
+  const diff = diffByKey2(previous, current, (skill) => skill.id, (before, after) => before.name !== after.name || before.description !== after.description);
+  if (diff.changed.length > 0 || diff.added.length === 0 && diff.removed.length === 0)
+    return [
+      "The available skills have changed. This list supersedes the previous available skills list.",
+      render(current)
+    ].join(`
+`);
+  return [
+    ...diff.added.length === 0 ? [] : ["New skills are available in addition to those previously listed:", ...entries(diff.added)],
+    ...diff.removed.length === 0 ? [] : [
+      `The following skill IDs are no longer available and must not be used: ${diff.removed.map((skill) => skill.id).join(", ")}.`
+    ]
+  ].join(`
+`);
+};
+
+class Service33 extends Context.Service()("@opencode/SkillInstructions") {
+}
+var layer = Layer.effect(Service33, Effect.gen(function* () {
+  const skills = yield* Service40;
+  return Service33.of({
+    load: Effect.fn("SkillInstructions.load")(function* (selection) {
+      const agent = selection.info;
+      if (!agent)
+        return empty3;
+      const available = available2(yield* skills.list(), agent).flatMap((skill) => skill.description === undefined || skill.autoinvoke === false ? [] : [{ id: skill.id, name: skill.name, description: skill.description }]).toSorted((a, b) => a.id.localeCompare(b.id));
+      return make20({
+        key: Key3.make("core/skill-guidance"),
+        codec: Schema.toCodecJson(Schema.Array(Summary)),
+        read: Effect.succeed(available.length === 0 ? removed2 : available),
+        render: {
+          initial: render,
+          changed: update,
+          removed: () => "Skill guidance is no longer available. Do not use any previously listed skill."
+        }
+      });
+    })
+  });
+}));
+var node38 = makeLocationNode({ service: Service33, layer, deps: [node45] });
+
+export { Service33, node38, exports_instructions5 };