@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-f1ge3yjy.js

@@ -0,0 +1,179 @@
+import {
+  definition
+} from "./permission-d6s8p2vk.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/codemode/tool.ts
+var exports_tool = {};
+__export(exports_tool, {
+  create: () => create,
+  catalog: () => catalog,
+  CodeModeTool: () => exports_tool
+});
+import { CodeMode, Tool, toolError } from "@opencode-ai/codemode";
+import { Effect, Ref, Schema, Semaphore } from "effect";
+var ExecuteFile = Schema.Struct({
+  data: Schema.String,
+  mime: Schema.String,
+  name: Schema.optionalKey(Schema.String)
+});
+var ExecuteCall = Schema.Struct({
+  tool: Schema.String,
+  status: Schema.Literals(["running", "completed", "error"]),
+  input: Schema.optionalKey(Schema.Record(Schema.String, Schema.Json))
+});
+var ExecuteOutput = Schema.Struct({
+  output: Schema.String,
+  toolCalls: Schema.Array(ExecuteCall),
+  error: Schema.optionalKey(Schema.Literal(true)),
+  files: Schema.Array(ExecuteFile)
+});
+var description = [
+  "Run JavaScript in a confined Code Mode runtime to orchestrate tool calls and compose their results.",
+  "Imports, direct filesystem access, and timers are unavailable. Do not use `fetch`; all external access goes through `tools`.",
+  "Within `{ code }`, the only callable tools are those explicitly listed in the Code Mode catalog instructions or returned by `search`. Inside `{ code }`, ignore tools shown outside the Code Mode catalog. They are not available in the Code Mode runtime.",
+  'Call tools through `tools` using only exact paths and signatures from the catalog. Do not infer or normalize tool names; preserve bracket notation such as `tools.<namespace>["tool-name"](input)`.',
+  "Prefer an explicit `return`; if omitted, the final top-level expression becomes the result.",
+  "Await every call whose completion matters; pending calls are interrupted when execution ends. Run independent calls concurrently with `Promise.all`."
+].join(`
+`);
+var create = (registrations, executeTool) => {
+  return {
+    name: "execute",
+    description,
+    input: CodeMode.Input,
+    output: ExecuteOutput,
+    execute: ({ code }, context) => Effect.gen(function* () {
+      const callIndex = yield* Ref.make(0);
+      const files = yield* Ref.make([]);
+      const calls = yield* Ref.make([]);
+      const lock = Semaphore.makeUnsafe(1);
+      const updateCalls = (update) => lock.withPermit(Ref.updateAndGet(calls, update).pipe(Effect.flatMap((toolCalls2) => context.progress({ toolCalls: toolCalls2 }))));
+      const result = yield* runtime(registrations, (name, tool, input) => Effect.gen(function* () {
+        const index = yield* Ref.getAndUpdate(callIndex, (index2) => index2 + 1);
+        const executed = yield* executeTool(name, tool, input, context).pipe(Effect.mapError((failure) => toolError(failure.message, failure)));
+        const content2 = typeof executed.content === "string" ? [{ type: "text", text: executed.content }] : executed.content ?? [];
+        const outputFileParts = outputFiles(content2);
+        if (outputFileParts.length > 0)
+          yield* Ref.update(files, (items) => [...items, { index, files: outputFileParts }]);
+        return executed.output;
+      }), {
+        onToolCallStart: ({ index, name, input }) => {
+          const shown = displayInput(input);
+          return updateCalls((items) => {
+            const next = [...items];
+            next[index] = { tool: name, status: "running", ...shown ? { input: shown } : {} };
+            return next;
+          });
+        },
+        onToolCallEnd: ({ index, name, input, outcome }) => {
+          const shown = displayInput(input);
+          return updateCalls((items) => {
+            const next = [...items];
+            next[index] = {
+              ...items[index] ?? { tool: name, ...shown ? { input: shown } : {} },
+              status: outcome === "success" ? "completed" : "error"
+            };
+            return next;
+          });
+        }
+      }).execute(code);
+      const toolCalls = yield* Ref.get(calls);
+      const collected = (yield* Ref.get(files)).toSorted((left, right) => left.index - right.index).flatMap((item) => item.files);
+      const output = formatResult(result);
+      const value = {
+        output,
+        toolCalls,
+        files: collected,
+        ...result.ok ? {} : { error: true }
+      };
+      const content = [{ type: "text", text: value.output }];
+      content.push(...value.files.map((file) => ({
+        type: "file",
+        uri: `data:${file.mime};base64,${file.data}`,
+        mime: file.mime,
+        ...file.name === undefined ? {} : { name: file.name }
+      })));
+      const metadata = {
+        toolCalls: value.toolCalls,
+        ...value.error ? { error: true } : {}
+      };
+      return {
+        output: value,
+        content,
+        metadata
+      };
+    })
+  };
+};
+var catalog = (registrations) => {
+  const pinned = new Set(Array.from(registrations.values()).filter((registration) => registration.options?.pinned === true).map(qualifiedName));
+  return runtime(registrations, () => Effect.fail(toolError("Execute context is unavailable"))).catalog().map((entry) => ({ ...entry, pinned: pinned.has(entry.path) }));
+};
+function runtime(registrations, executeTool, hooks) {
+  const tools = {};
+  for (const [name, registration] of registrations) {
+    const child = definition(registration);
+    const path = qualifiedName(registration);
+    tools[path] = Tool.make({
+      description: child.description,
+      input: child.inputSchema,
+      output: child.outputSchema,
+      execute: (input) => executeTool(name, registration, input)
+    });
+  }
+  return CodeMode.make({ tools, ...hooks });
+}
+function qualifiedName(registration) {
+  const normalized = registration.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+  if (registration.options?.namespace === undefined)
+    return normalized;
+  return `${registration.options.namespace}.${normalized}`;
+}
+function displayInput(input) {
+  if (input === null || input === undefined)
+    return;
+  if (typeof input !== "object" || Array.isArray(input))
+    return { input };
+  if (Object.keys(input).length === 0)
+    return;
+  return input;
+}
+function formatResult(result) {
+  const output = result.ok ? formatValue(result.value) : [result.error.message, ...(result.error.suggestions ?? []).filter((hint) => !result.error.message.includes(hint))].join(`
+`).trim();
+  const warnings = result.ok && result.warnings && result.warnings.length > 0 ? `Warnings:
+${result.warnings.map((item) => `- [${item.kind}] ${item.message}`).join(`
+`)}` : undefined;
+  const logs = result.logs && result.logs.length > 0 ? `Logs:
+${result.logs.join(`
+`)}` : undefined;
+  return [output, warnings, logs].filter((part) => part !== undefined && part !== "").join(`
+
+`);
+}
+function formatValue(value) {
+  if (typeof value === "string")
+    return value;
+  return JSON.stringify(value, null, 2) ?? String(value);
+}
+function outputFiles(content) {
+  return content.flatMap((part) => {
+    if (part.type !== "file")
+      return [];
+    const prefix = `data:${part.mime};base64,`;
+    if (!part.uri.startsWith(prefix))
+      return [];
+    return [
+      {
+        data: part.uri.slice(prefix.length),
+        mime: part.mime,
+        ...part.name === undefined ? {} : { name: part.name }
+      }
+    ];
+  });
+}
+
+export { create, catalog, exports_tool };

package/dist/chunks/permission-f26x8jzg.js

@@ -0,0 +1,301 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/mcp/client.ts
+var exports_client = {};
+__export(exports_client, {
+  connect: () => connect,
+  NeedsAuthError: () => NeedsAuthError,
+  MCPClient: () => exports_client,
+  ConnectError: () => ConnectError
+});
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { pathToFileURL } from "node:url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
+import {
+  CallToolResultSchema,
+  ElicitationCompleteNotificationSchema,
+  ElicitRequestSchema,
+  GetPromptResultSchema,
+  ListPromptsResultSchema,
+  ListRootsRequestSchema,
+  ListToolsResultSchema,
+  PromptListChangedNotificationSchema,
+  PromptSchema,
+  ResourceListChangedNotificationSchema,
+  LoggingMessageNotificationSchema,
+  ToolListChangedNotificationSchema,
+  ToolSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { Cause, Effect, Exit, Schema } from "effect";
+var DEFAULT_STARTUP_TIMEOUT = 30000;
+var DEFAULT_CATALOG_TIMEOUT = 30000;
+var DEFAULT_EXECUTION_TIMEOUT = 12 * 60 * 60 * 1000;
+var TolerantListToolsResult = ListToolsResultSchema.extend({
+  tools: ToolSchema.omit({ outputSchema: true }).array()
+});
+var TolerantListPromptsResult = ListPromptsResultSchema.extend({
+  prompts: PromptSchema.array()
+});
+
+class NeedsAuthError extends Schema.TaggedErrorClass()("MCP.NeedsAuthError", {
+  server: Schema.String
+}) {
+  get message() {
+    return `MCP server requires authentication: ${this.server}`;
+  }
+}
+
+class ConnectError extends Schema.TaggedErrorClass()("MCP.ConnectError", {
+  server: Schema.String,
+  message: Schema.String
+}) {
+}
+var connect = Effect.fnUntraced(function* (server, config, directory, authProvider, elicitation, clientInfo = { name: "opencode", version: "unknown" }) {
+  const transport = yield* Effect.gen(function* () {
+    if (config.type === "local") {
+      const [command, ...args] = config.command;
+      return new StdioClientTransport({
+        command,
+        args,
+        cwd: config.cwd ? path.resolve(directory, config.cwd) : directory,
+        stderr: "pipe",
+        env: {
+          ...process.env,
+          ...command === "opencode" ? { BUN_BE_BUN: "1" } : {},
+          ...config.environment
+        }
+      });
+    }
+    if (!URL.canParse(config.url))
+      return yield* new ConnectError({ server, message: `Invalid MCP URL for "${server}"` });
+    return new StreamableHTTPClientTransport(new URL(config.url), {
+      requestInit: config.headers ? { headers: config.headers } : undefined,
+      authProvider
+    });
+  });
+  const client = new Client(clientInfo, {
+    capabilities: {
+      ...elicitation ? { elicitation: { form: { applyDefaults: true }, url: {} } } : {},
+      roots: {}
+    }
+  });
+  client.setRequestHandler(ListRootsRequestSchema, () => Promise.resolve({ roots: [{ uri: pathToFileURL(directory).href }] }));
+  if (elicitation) {
+    client.setRequestHandler(ElicitRequestSchema, (request, extra) => Effect.runPromise(elicitation.create({ server, params: request.params, signal: extra.signal })));
+    client.setNotificationHandler(ElicitationCompleteNotificationSchema, (notification) => Effect.runPromise(elicitation.complete({ server, elicitationID: notification.params.elicitationId })));
+  }
+  const exit = yield* Effect.tryPromise({
+    try: (signal) => client.connect(transport, { timeout: config.timeout?.startup ?? DEFAULT_STARTUP_TIMEOUT, signal }),
+    catch: (error2) => error2
+  }).pipe(Effect.exit);
+  if (Exit.isSuccess(exit)) {
+    yield* Effect.addFinalizer(() => cleanupStdioDescendants(transport).pipe(Effect.andThen(Effect.promise(() => client.close())), Effect.ignore));
+    const catalogTimeout = config.timeout?.catalog ?? DEFAULT_CATALOG_TIMEOUT;
+    const executionTimeout = config.timeout?.execution ?? DEFAULT_EXECUTION_TIMEOUT;
+    return {
+      instructions: client.getInstructions()?.trim() || undefined,
+      tools: () => Effect.gen(function* () {
+        if (!client.getServerCapabilities()?.tools)
+          return [];
+        const tools = yield* Effect.tryPromise({
+          try: () => paginate(async (cursor) => {
+            const params = cursor === undefined ? undefined : { cursor };
+            try {
+              return await client.listTools(params, { timeout: catalogTimeout });
+            } catch (error2) {
+              if (!(error2 instanceof Error) || !isOutputSchemaError(error2))
+                throw error2;
+              return client.request({ method: "tools/list", params }, TolerantListToolsResult, {
+                timeout: catalogTimeout
+              });
+            }
+          }, (result) => result.tools),
+          catch: (error2) => error2 instanceof Error ? error2 : new Error(String(error2))
+        }).pipe(Effect.tapError((error2) => Effect.logWarning("failed to list MCP tools", { server, error: error2.message })));
+        return tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema,
+          outputSchema: "outputSchema" in tool ? tool.outputSchema : undefined
+        }));
+      }),
+      prompts: () => Effect.gen(function* () {
+        if (!client.getServerCapabilities()?.prompts)
+          return [];
+        const prompts = yield* Effect.tryPromise({
+          try: () => paginate(async (cursor) => {
+            const params = cursor === undefined ? undefined : { cursor };
+            return client.request({ method: "prompts/list", params }, TolerantListPromptsResult, {
+              timeout: catalogTimeout
+            });
+          }, (result) => result.prompts),
+          catch: (error2) => error2 instanceof Error ? error2 : new Error(String(error2))
+        }).pipe(Effect.tapError((error2) => Effect.logWarning("failed to list MCP prompts", { server, error: error2.message })));
+        return prompts.map((prompt) => ({
+          name: prompt.name,
+          description: prompt.description,
+          arguments: prompt.arguments?.map((argument) => ({
+            name: argument.name,
+            description: argument.description,
+            required: argument.required
+          }))
+        }));
+      }),
+      resources: () => Effect.gen(function* () {
+        if (!client.getServerCapabilities()?.resources)
+          return [];
+        const resources = yield* Effect.tryPromise({
+          try: () => paginate((cursor) => client.listResources(cursor === undefined ? undefined : { cursor }, { timeout: catalogTimeout }), (result) => result.resources),
+          catch: (error2) => error2 instanceof Error ? error2 : new Error(String(error2))
+        }).pipe(Effect.tapError((error2) => Effect.logWarning("failed to list MCP resources", { server, error: error2.message })));
+        return resources.map((resource) => ({
+          name: resource.name,
+          uri: resource.uri,
+          description: resource.description,
+          mimeType: resource.mimeType
+        }));
+      }),
+      resourceTemplates: () => Effect.gen(function* () {
+        if (!client.getServerCapabilities()?.resources)
+          return [];
+        const templates = yield* Effect.tryPromise({
+          try: () => paginate((cursor) => client.listResourceTemplates(cursor === undefined ? undefined : { cursor }, {
+            timeout: catalogTimeout
+          }), (result) => result.resourceTemplates),
+          catch: (error2) => error2 instanceof Error ? error2 : new Error(String(error2))
+        }).pipe(Effect.tapError((error2) => Effect.logWarning("failed to list MCP resource templates", { server, error: error2.message })));
+        return templates.map((template) => ({
+          name: template.name,
+          uriTemplate: template.uriTemplate,
+          description: template.description,
+          mimeType: template.mimeType
+        }));
+      }),
+      readResource: (input) => Effect.gen(function* () {
+        if (!client.getServerCapabilities()?.resources)
+          return;
+        const result = yield* Effect.tryPromise({
+          try: (signal) => client.readResource({ uri: input.uri }, { signal, timeout: executionTimeout }),
+          catch: (error2) => error2 instanceof Error ? error2 : new Error(String(error2))
+        }).pipe(Effect.tapError((error2) => Effect.logWarning("failed to read MCP resource", { server, uri: input.uri, error: error2.message })));
+        return {
+          contents: result.contents.map((part) => ("text" in part) ? { type: "text", uri: part.uri, text: part.text, mimeType: part.mimeType } : { type: "blob", uri: part.uri, blob: part.blob, mimeType: part.mimeType })
+        };
+      }),
+      prompt: (input) => Effect.tryPromise({
+        try: (signal) => client.request({ method: "prompts/get", params: { name: input.name, arguments: input.args ?? {} } }, GetPromptResultSchema, { signal, timeout: executionTimeout }),
+        catch: (error2) => error2 instanceof Error ? error2 : new Error(String(error2))
+      }).pipe(Effect.map((result) => ({
+        messages: result.messages.map((message) => ({ role: message.role, content: message.content }))
+      }))),
+      callTool: (input) => Effect.tryPromise({
+        try: (signal) => client.callTool({ name: input.name, arguments: input.args ?? {} }, CallToolResultSchema, { signal, timeout: executionTimeout, onprogress: () => {} }),
+        catch: (error2) => error2 instanceof Error ? error2 : new Error(String(error2))
+      }).pipe(Effect.map((result) => ({
+        isError: result.isError === true,
+        structured: result.structuredContent,
+        content: result.content.flatMap((part) => {
+          if (part.type === "text")
+            return [{ type: "text", text: part.text }];
+          if (part.type === "image" || part.type === "audio")
+            return [{ type: "media", data: part.data, mimeType: part.mimeType }];
+          if (part.type === "resource_link")
+            return [{ type: "text", text: part.uri }];
+          if (part.type === "resource") {
+            const resource = part.resource;
+            if ("text" in resource && typeof resource.text === "string")
+              return [{ type: "text", text: resource.text }];
+            if ("blob" in resource && typeof resource.blob === "string" && typeof resource.mimeType === "string")
+              return [{ type: "media", data: resource.blob, mimeType: resource.mimeType }];
+            return [{ type: "text", text: resource.uri }];
+          }
+          return [];
+        })
+      }))),
+      onClose: (callback) => {
+        client.onclose = callback;
+      },
+      onLog: (callback) => {
+        client.setNotificationHandler(LoggingMessageNotificationSchema, (notification) => callback(notification.params));
+      },
+      onToolsChanged: (callback) => {
+        if (!client.getServerCapabilities()?.tools?.listChanged)
+          return;
+        client.setNotificationHandler(ToolListChangedNotificationSchema, async () => callback());
+      },
+      onPromptsChanged: (callback) => {
+        if (!client.getServerCapabilities()?.prompts?.listChanged)
+          return;
+        client.setNotificationHandler(PromptListChangedNotificationSchema, async () => callback());
+      },
+      onResourcesChanged: (callback) => {
+        if (!client.getServerCapabilities()?.resources?.listChanged)
+          return;
+        client.setNotificationHandler(ResourceListChangedNotificationSchema, async () => callback());
+      }
+    };
+  }
+  yield* cleanupStdioDescendants(transport).pipe(Effect.andThen(Effect.promise(() => transport.close())), Effect.ignore);
+  const error = Cause.squash(exit.cause);
+  if (error instanceof UnauthorizedError)
+    return yield* new NeedsAuthError({ server });
+  return yield* new ConnectError({ server, message: error instanceof Error ? error.message : String(error) });
+});
+var cleanupStdioDescendants = (transport) => Effect.gen(function* () {
+  if (!(transport instanceof StdioClientTransport))
+    return;
+  const pid = transport.pid;
+  if (typeof pid !== "number")
+    return;
+  yield* Effect.forEach(yield* descendantPids(pid), (pid2) => Effect.try({
+    try: () => process.kill(pid2, "SIGTERM"),
+    catch: () => {
+      return;
+    }
+  }).pipe(Effect.ignore), { discard: true });
+});
+var descendantPids = Effect.fnUntraced(function* (root) {
+  if (process.platform === "win32")
+    return [];
+  const result = [];
+  const queue = [root];
+  for (let index = 0;index < queue.length; index++) {
+    const parent = queue[index];
+    if (parent === undefined)
+      return result;
+    const children = (yield* childPids(parent)).filter((pid) => !result.includes(pid));
+    result.push(...children);
+    queue.push(...children);
+  }
+  return result;
+});
+var childPids = (pid) => Effect.promise(() => new Promise((resolve) => {
+  execFile("pgrep", ["-P", String(pid)], { encoding: "utf8" }, (_error, stdout) => {
+    resolve(stdout.split(`
+`).map((line) => Number.parseInt(line, 10)).filter((pid2) => Number.isInteger(pid2)));
+  });
+}));
+async function paginate(list, items) {
+  const collected = [];
+  const seen = new Set;
+  let cursor;
+  while (true) {
+    const result = await list(cursor);
+    collected.push(...items(result));
+    if (result.nextCursor === undefined)
+      return collected;
+    if (seen.has(result.nextCursor))
+      throw new Error(`MCP list returned duplicate cursor: ${result.nextCursor}`);
+    seen.add(result.nextCursor);
+    cursor = result.nextCursor;
+  }
+}
+var isOutputSchemaError = (error) => /can't resolve reference|resolves to more than one schema|outputSchema|schema.*reference|reference.*schema/i.test(error.message);
+
+export { NeedsAuthError, ConnectError, connect, exports_client };

package/dist/chunks/permission-f4cp4g4a.js

@@ -0,0 +1,17 @@
+// src/database/migration/20260622170816_reset_v2_session_state.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260622170816_reset_v2_session_state",
+  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\`;`);
+    });
+  }
+};
+var _20260622170816_reset_v2_session_state_default = migration;
+
+export { _20260622170816_reset_v2_session_state_default };

package/dist/chunks/permission-f6fn40ps.js

@@ -0,0 +1,81 @@
+import {
+  exports_skill
+} from "./permission-zr271bqv.js";
+import {
+  exports_instructions
+} from "./permission-q4r4pzs4.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/skill/instructions.ts
+var exports_instructions2 = {};
+__export(exports_instructions2, {
+  node: () => node,
+  SkillInstructions: () => exports_instructions2,
+  Service: () => Service
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+var Summary = Schema.Struct({
+  id: exports_skill.ID,
+  name: exports_skill.Name,
+  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 = exports_instructions.diffByKey(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 Service extends Context.Service()("@opencode/SkillInstructions") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const skills = yield* exports_skill.Service;
+  return Service.of({
+    load: Effect.fn("SkillInstructions.load")(function* (selection) {
+      const agent = selection.info;
+      if (!agent)
+        return exports_instructions.empty;
+      const permitted = exports_skill.available(yield* skills.list(), agent);
+      const available = permitted.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 exports_instructions.make({
+        key: exports_instructions.Key.make("core/skill-guidance"),
+        codec: Schema.toCodecJson(Schema.Array(Summary)),
+        read: Effect.succeed(available.length === 0 ? exports_instructions.removed : available),
+        render: {
+          initial: render,
+          changed: update,
+          removed: () => "Skill guidance is no longer available. Do not use any previously listed skill."
+        }
+      });
+    })
+  });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_skill.node] });
+
+export { Service, node, exports_instructions2 as exports_instructions };

package/dist/chunks/permission-f84sxdqn.js

@@ -0,0 +1,49 @@
+// src/database/drizzle/up-migrations/utils.ts
+var MIGRATIONS_TABLE_VERSIONS = {
+  sqlite: 1,
+  pg: 1,
+  effect: 1,
+  mysql: 1,
+  mssql: 1,
+  cockroach: 1,
+  singlestore: 1
+};
+var GET_VERSION_FOR = {
+  mysql: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  pg: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  effect: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  mssql: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  cockroach: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  singlestore: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  sqlite: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  }
+};
+
+export { MIGRATIONS_TABLE_VERSIONS, GET_VERSION_FOR };