@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-1jnd8eq9.js

@@ -0,0 +1,201 @@
+import {
+  Service80
+} from "./repository-drknmmyh.js";
+import {
+  Service52
+} from "./repository-1bvekr7f.js";
+import {
+  detect2
+} from "./repository-3smtnn6g.js";
+import {
+  awaitActivation2
+} from "./repository-jqh9b0xq.js";
+import {
+  Service62
+} from "./repository-mgx963cj.js";
+import {
+  AttachmentError2,
+  SkillNotFoundError2
+} from "./repository-3x8gcmrs.js";
+import {
+  prepare3,
+  Service40
+} from "./repository-9xb0s4b9.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/prompt.ts
+var exports_prompt = {};
+__export(exports_prompt, {
+  SessionPrompt: () => exports_prompt,
+  prepare: () => prepare2
+});
+import { Base64, FileAttachment, Prompt } from "@opencode/schema/prompt";
+import { SessionInbox } from "@opencode/schema/session-inbox";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Effect } from "effect";
+import path from "path";
+import { fileURLToPath } from "url";
+var prepare2 = Effect.fn("SessionPrompt.prepare")(function* (request) {
+  const fs = yield* FSUtil.Service;
+  const instances = yield* Service52;
+  return yield* Effect.gen(function* () {
+    yield* awaitActivation2;
+    const hooks = yield* Service62;
+    const event = yield* hooks.trigger("session", "prompt", {
+      sessionID: request.session.id,
+      messageID: request.messageID,
+      prompt: structuredClone({
+        text: request.input.text,
+        files: request.input.files?.slice(),
+        agents: request.input.agents?.slice(),
+        skills: request.input.skills?.slice()
+      }),
+      metadata: structuredClone(request.input.metadata),
+      delivery: request.input.delivery ?? "steer"
+    });
+    const input = event.prompt;
+    const files = input.files ? yield* Effect.forEach(input.files, materializeAttachment, { concurrency: 8 }) : undefined;
+    const requested = input.skills;
+    const selected = yield* Effect.gen(function* () {
+      if (!requested?.length)
+        return;
+      const skillService = yield* Service40;
+      const prepared = new Map;
+      return yield* Effect.forEach(requested, (attachment) => Effect.gen(function* () {
+        const name = prepared.get(attachment.id);
+        if (name !== undefined)
+          return { id: attachment.id, name, mention: attachment.mention };
+        const skill = yield* skillService.get(attachment.id);
+        if (!skill)
+          return yield* new SkillNotFoundError2({ skill: attachment.id });
+        prepared.set(skill.id, skill.name);
+        return {
+          id: skill.id,
+          name: skill.name,
+          text: (yield* prepare3(fs, skill).pipe(Effect.orDie)).output,
+          mention: attachment.mention
+        };
+      }));
+    });
+    return {
+      type: "user",
+      payload: SessionInbox.UserPayload.make({
+        ...Prompt.make({
+          text: input.text,
+          agents: input.agents,
+          files,
+          skills: selected?.length ? selected : undefined
+        }),
+        metadata: event.metadata
+      }),
+      delivery: SessionInbox.Delivery.make(event.delivery)
+    };
+  }).pipe(instances.provide(request.session));
+});
+var materializeAttachment = Effect.fn("SessionPrompt.materializeAttachment")(function* (input) {
+  const resolved = input.uri.startsWith("data:") ? {
+    bytes: yield* decodeDataURL(input.uri),
+    source: { type: "inline" },
+    start: undefined,
+    end: undefined,
+    name: undefined,
+    mime: undefined
+  } : yield* readFileAttachment(input.uri);
+  if (resolved.bytes.byteLength > MAX_ATTACHMENT_BYTES)
+    return yield* new AttachmentError2({
+      uri: input.uri,
+      message: `Attachment exceeds the ${MAX_ATTACHMENT_BYTES} byte limit: ${input.uri}`
+    });
+  const mime = resolved.mime ?? detect2(resolved.bytes);
+  const content = mime === "text/plain" && resolved.start !== undefined ? Buffer.from(Buffer.from(resolved.bytes).toString("utf8").split(`
+`).slice(resolved.start - 1, resolved.end).join(`
+`)) : resolved.bytes;
+  const normalized = yield* normalizeImageAttachment(input, Buffer.from(content).toString("base64"), mime);
+  return FileAttachment.create({
+    data: normalized.data,
+    mime: normalized.mime,
+    source: resolved.source,
+    name: input.name ?? resolved.name,
+    description: input.description,
+    mention: input.mention
+  });
+});
+var normalizeImageAttachment = Effect.fn("SessionPrompt.normalizeImageAttachment")(function* (input, data, mime) {
+  if (!mime.startsWith("image/"))
+    return { data: Base64.make(data), mime };
+  const image = yield* Service80;
+  const label = input.name ?? (input.uri.startsWith("data:") ? "inline attachment" : input.uri);
+  const content = { uri: label, content: data, encoding: "base64", mime };
+  const normalized = yield* image.normalize(label, content).pipe(Effect.catchTag("Image.ResizerUnavailableError", () => Effect.succeed(content)), Effect.mapError((error) => new AttachmentError2({ uri: label, message: error.message })));
+  return { data: Base64.make(normalized.content), mime: normalized.mime };
+});
+var readFileAttachment = Effect.fn("SessionPrompt.readFileAttachment")(function* (uri) {
+  const fs = yield* FSUtil.Service;
+  const url = yield* Effect.try({
+    try: () => new URL(uri),
+    catch: () => new AttachmentError2({ uri, message: `Invalid attachment URI: ${uri}` })
+  });
+  if (url.protocol !== "file:")
+    return yield* new AttachmentError2({ uri, message: `Unsupported attachment URI: ${uri}` });
+  const start = positiveInt(url.searchParams.get("start"));
+  const end = positiveInt(url.searchParams.get("end"));
+  const target = yield* Effect.try({
+    try: () => {
+      url.search = "";
+      url.hash = "";
+      return fileURLToPath(url);
+    },
+    catch: () => new AttachmentError2({ uri, message: `Invalid file URI: ${uri}` })
+  });
+  const info = yield* fs.stat(target).pipe(Effect.mapError(() => new AttachmentError2({ uri, message: `Unable to read attachment: ${uri}` })));
+  if (info.type === "Directory") {
+    const entries = yield* fs.readDirectoryEntries(target).pipe(Effect.mapError(() => new AttachmentError2({ uri, message: `Unable to read attachment: ${uri}` })));
+    return {
+      bytes: Buffer.from(entries.filter((entry) => entry.type === "file" || entry.type === "directory").sort((a, b) => a.type === b.type ? a.name.localeCompare(b.name) : a.type === "directory" ? -1 : 1).map((entry) => entry.name + (entry.type === "directory" ? path.sep : "")).join(`
+`)),
+      source: { type: "uri", uri },
+      start: undefined,
+      end: undefined,
+      name: path.basename(target),
+      mime: "application/x-directory"
+    };
+  }
+  if (info.type !== "File")
+    return yield* new AttachmentError2({ uri, message: `Attachment is not a file: ${uri}` });
+  if (Number(info.size) > MAX_ATTACHMENT_BYTES)
+    return yield* new AttachmentError2({
+      uri,
+      message: `Attachment exceeds the ${MAX_ATTACHMENT_BYTES} byte limit: ${uri}`
+    });
+  const bytes = yield* fs.readFile(target).pipe(Effect.mapError(() => new AttachmentError2({ uri, message: `Unable to read attachment: ${uri}` })));
+  return { bytes, source: { type: "uri", uri }, start, end, name: path.basename(target), mime: undefined };
+});
+var MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+function decodeDataURL(uri) {
+  return Effect.try({
+    try: () => {
+      const comma = uri.indexOf(",");
+      if (comma === -1)
+        throw new Error("Invalid data URL");
+      const metadata = uri.slice(5, comma);
+      const payload = uri.slice(comma + 1);
+      if (!metadata.split(";").some((part) => part.toLowerCase() === "base64"))
+        return Buffer.from(decodeURIComponent(payload));
+      const bytes = Buffer.from(payload, "base64");
+      if (bytes.toString("base64") !== payload)
+        throw new Error("Non-canonical base64");
+      return bytes;
+    },
+    catch: () => new AttachmentError2({ uri, message: "Invalid attachment data URL" })
+  });
+}
+function positiveInt(value) {
+  if (value === null)
+    return;
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+export { prepare2, exports_prompt };

package/dist/chunks/repository-1kg9ymc8.js

@@ -0,0 +1,6 @@
+// src/util/iife.ts
+function iife2(fn) {
+  return fn();
+}
+
+export { iife2 };

package/dist/chunks/repository-1n274c67.js

@@ -0,0 +1,130 @@
+import {
+  Service79,
+  node84
+} from "./repository-8m31s27t.js";
+import {
+  SessionTable2,
+  SessionMessageTable2
+} from "./repository-a1bz86dw.js";
+import {
+  decodeMessageRow2,
+  load3
+} from "./repository-j8g7a3j8.js";
+import {
+  fromRow2
+} from "./repository-b09hzw3k.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/store.ts
+var exports_store = {};
+__export(exports_store, {
+  ListInput: () => ListInput5,
+  Service: () => Service60,
+  SessionStore: () => exports_store,
+  node: () => node64
+});
+import { and, asc, desc, eq, gt, isNotNull, isNull, like, lt, notInArray, or, sql } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Project } from "@opencode/schema/project";
+import { Workspace } from "@opencode/schema/workspace";
+import { AbsolutePath, PositiveInt, RelativePath } from "@opencode/schema/schema";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { Session } from "@opencode/schema/session";
+var ListInputBase = {
+  workspaceID: Workspace.ID.pipe(Schema.optional),
+  search: Schema.String.pipe(Schema.optional),
+  limit: PositiveInt.pipe(Schema.optional),
+  order: Schema.Literals(["asc", "desc"]).pipe(Schema.optional),
+  parentID: Schema.NullOr(Session.ID).pipe(Schema.optional),
+  anchor: Session.ListAnchor.pipe(Schema.optional)
+};
+var ListDirectoryInput = Schema.Struct({
+  ...ListInputBase,
+  directory: AbsolutePath
+});
+var ListProjectInput = Schema.Struct({
+  ...ListInputBase,
+  project: Project.ID,
+  subpath: RelativePath.pipe(Schema.optional)
+});
+var ListAllInput = Schema.Struct(ListInputBase);
+var ListInput5 = Schema.Union([ListDirectoryInput, ListProjectInput, ListAllInput]);
+
+class Service60 extends Context.Service()("@opencode/SessionStore") {
+}
+var layer = Layer.effect(Service60, Effect.gen(function* () {
+  const { db } = yield* Service79;
+  return Service60.of({
+    get: Effect.fnUntraced(function* (sessionID) {
+      const row = yield* db.select().from(SessionTable2).where(eq(SessionTable2.id, sessionID)).get().pipe(Effect.orDie);
+      return row ? fromRow2(row) : undefined;
+    }),
+    list: Effect.fn("SessionStore.list")(function* (input = {}) {
+      const direction = input.anchor?.direction ?? "next";
+      const requestedOrder = input.order ?? "desc";
+      const order = direction === "previous" ? requestedOrder === "asc" ? "desc" : "asc" : requestedOrder;
+      const sortColumn = SessionTable2.time_updated;
+      const conditions = [];
+      if ("directory" in input)
+        conditions.push(eq(SessionTable2.directory, input.directory));
+      if (input.workspaceID)
+        conditions.push(eq(SessionTable2.workspace_id, input.workspaceID));
+      if ("project" in input)
+        conditions.push(eq(SessionTable2.project_id, input.project));
+      if ("project" in input && input.subpath !== undefined)
+        conditions.push(eq(SessionTable2.path, input.subpath));
+      if (input.search)
+        conditions.push(like(SessionTable2.title, `%${input.search}%`));
+      if (input.parentID !== undefined)
+        conditions.push(input.parentID === null ? isNull(SessionTable2.parent_id) : eq(SessionTable2.parent_id, input.parentID));
+      if (input.anchor) {
+        conditions.push(order === "asc" ? or(gt(sortColumn, input.anchor.time), and(eq(sortColumn, input.anchor.time), gt(SessionTable2.id, input.anchor.id))) : or(lt(sortColumn, input.anchor.time), and(eq(sortColumn, input.anchor.time), lt(SessionTable2.id, input.anchor.id))));
+      }
+      const query = db.select().from(SessionTable2).where(conditions.length > 0 ? and(...conditions) : undefined).orderBy(order === "asc" ? asc(sortColumn) : desc(sortColumn), order === "asc" ? asc(SessionTable2.id) : desc(SessionTable2.id));
+      const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(Effect.orDie);
+      return (direction === "previous" ? rows.toReversed() : rows).map((row) => fromRow2(row));
+    }),
+    messages: Effect.fn("SessionStore.messages")(function* (input) {
+      const direction = input.cursor?.direction ?? "next";
+      const requestedOrder = input.order ?? "desc";
+      const order = direction === "previous" ? requestedOrder === "asc" ? "desc" : "asc" : requestedOrder;
+      const anchor = input.cursor ? yield* db.select({ seq: SessionMessageTable2.seq }).from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, input.sessionID), eq(SessionMessageTable2.id, input.cursor.id))).get().pipe(Effect.orDie) : undefined;
+      if (input.cursor && !anchor)
+        return [];
+      const boundary = anchor ? order === "asc" ? gt(SessionMessageTable2.seq, anchor.seq) : lt(SessionMessageTable2.seq, anchor.seq) : undefined;
+      const query = db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, input.sessionID), boundary, input.type === undefined ? undefined : eq(SessionMessageTable2.type, input.type))).orderBy(order === "asc" ? asc(SessionMessageTable2.seq) : desc(SessionMessageTable2.seq));
+      const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(Effect.orDie);
+      return yield* Effect.forEach(direction === "previous" ? rows.toReversed() : rows, decodeMessageRow2);
+    }),
+    context: Effect.fn("SessionStore.context")((sessionID) => load3(db, sessionID, "latest")),
+    message: Effect.fn("SessionStore.message")(function* (messageID) {
+      const row = yield* db.select().from(SessionMessageTable2).where(eq(SessionMessageTable2.id, messageID)).get().pipe(Effect.orDie);
+      return row ? {
+        sessionID: Session.ID.make(row.session_id),
+        message: yield* decodeMessageRow2(row).pipe(Effect.orDie)
+      } : undefined;
+    }),
+    listSuspended: Effect.fn("SessionStore.listSuspended")(function* () {
+      return yield* db.select({ sessionID: SessionTable2.id }).from(SessionTable2).where(and(isNotNull(SessionTable2.time_suspended), isNull(SessionTable2.parent_id))).all().pipe(Effect.orDie, Effect.map((rows) => rows.map((row) => row.sessionID)));
+    }),
+    claim: Effect.fn("SessionStore.claim")(function* (sessionID) {
+      yield* db.update(SessionTable2).set({ time_suspended: Date.now(), time_updated: sql`${SessionTable2.time_updated}` }).where(and(eq(SessionTable2.id, sessionID), isNull(SessionTable2.time_suspended))).run().pipe(Effect.orDie);
+    }),
+    release: Effect.fn("SessionStore.release")(function* (sessionID) {
+      yield* db.update(SessionTable2).set({ time_suspended: null, resume_attempts: 0, time_updated: sql`${SessionTable2.time_updated}` }).where(eq(SessionTable2.id, sessionID)).run().pipe(Effect.orDie);
+    }),
+    releaseChildClaims: Effect.fn("SessionStore.releaseChildClaims")((recoverable) => db.update(SessionTable2).set({ time_suspended: null, resume_attempts: 0, time_updated: sql`${SessionTable2.time_updated}` }).where(and(isNotNull(SessionTable2.time_suspended), isNotNull(SessionTable2.parent_id), recoverable.length > 0 ? notInArray(SessionTable2.id, Array.from(recoverable)) : undefined)).run().pipe(Effect.orDie, Effect.asVoid)),
+    countResume: Effect.fn("SessionStore.countResume")(function* (sessionID) {
+      const row = yield* db.update(SessionTable2).set({
+        resume_attempts: sql`${SessionTable2.resume_attempts} + 1`,
+        time_updated: sql`${SessionTable2.time_updated}`
+      }).where(eq(SessionTable2.id, sessionID)).returning({ attempts: SessionTable2.resume_attempts }).get().pipe(Effect.orDie);
+      return row?.attempts;
+    })
+  });
+}));
+var node64 = makeGlobalNode({ service: Service60, layer, deps: [node84] });
+
+export { ListInput5, Service60, node64, exports_store };

package/dist/chunks/repository-1t2s0wry.js

@@ -0,0 +1,55 @@
+import {
+  isAISDK2,
+  packageName2
+} from "./repository-pye8sh6e.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/plugin/variant.ts
+var exports_variant = {};
+__export(exports_variant, {
+  Plugin: () => Plugin35,
+  VariantPlugin: () => exports_variant,
+  generate: () => generate2
+});
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+import { Model } from "@opencode/schema/model";
+var Plugin35 = define({
+  id: "opencode.variant",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((catalog) => {
+      for (const record of catalog.provider.list()) {
+        for (const model of record.models.values()) {
+          catalog.model.update(model.providerID, model.id, (draft) => {
+            const generated = generate2(draft, record.provider);
+            if (generated.length === 0)
+              return;
+            const variants = draft.variants ?? [];
+            const explicit = new Map(variants.map((variant) => [variant.id, variant]));
+            const generatedIDs = new Set(generated.map((variant) => variant.id));
+            draft.variants = [
+              ...generated.map((variant) => explicit.get(variant.id) ?? variant),
+              ...variants.filter((variant) => !generatedIDs.has(variant.id))
+            ];
+          });
+        }
+      }
+    });
+  })
+});
+function generate2(model, provider) {
+  const packageName = model.package ?? provider?.package;
+  if (!isAISDK2(packageName) || packageName2(packageName) !== "@ai-sdk/openai-compatible")
+    return [];
+  const ids = `${model.id} ${model.modelID ?? ""}`.toLowerCase();
+  if (!["glm-5.2", "glm-5-2", "glm-5p2"].some((name) => ids.includes(name)))
+    return [];
+  return ["high", "max"].map((id) => ({
+    id: Model.VariantID.make(id),
+    settings: { reasoningEffort: id }
+  }));
+}
+
+export { Plugin35, generate2, exports_variant };

package/dist/chunks/repository-1tjfkw5v.js

@@ -0,0 +1,119 @@
+import {
+  Service79
+} from "./repository-8m31s27t.js";
+import {
+  Service78
+} from "./repository-x6rcf4cj.js";
+import {
+  Service52
+} from "./repository-1bvekr7f.js";
+import {
+  RelativePath2
+} from "./repository-922hggd3.js";
+import {
+  ID6,
+  Service47
+} from "./repository-bejabbw1.js";
+import {
+  SessionEvent2
+} from "./repository-ec1grn59.js";
+import {
+  SessionMessage2
+} from "./repository-gftt206x.js";
+import {
+  MessageNotFoundError2
+} from "./repository-3x8gcmrs.js";
+import {
+  SessionMessageTable2
+} from "./repository-a1bz86dw.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/revert.ts
+var exports_revert = {};
+__export(exports_revert, {
+  MessageNotFoundError: () => MessageNotFoundError2,
+  SessionRevert: () => exports_revert,
+  clear: () => clear2,
+  commit: () => commit2,
+  stage: () => stage2
+});
+import { and, asc, eq, gt } from "drizzle-orm";
+import { Effect, Schema } from "effect";
+var stage2 = Effect.fn("SessionRevert.stage")(function* (input) {
+  const instances = yield* Service52;
+  const database = yield* Service79;
+  const bus = yield* Service78;
+  return yield* Effect.gen(function* () {
+    const snapshot = yield* Service47;
+    const original = input.session.revert?.snapshot ? ID6.make(input.session.revert.snapshot) : yield* snapshot.capture();
+    const next = yield* plan(database.db, { sessionID: input.session.id, messageID: input.messageID });
+    const restore = new Map;
+    if (original) {
+      for (const file of input.session.revert?.files ?? [])
+        restore.set(RelativePath2.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(SessionEvent2.RevertEvent.Staged, {
+      sessionID: input.session.id,
+      revert
+    });
+    return revert;
+  }).pipe(instances.provide(input.session));
+});
+var clear2 = Effect.fn("SessionRevert.clear")(function* (session) {
+  const instances = yield* Service52;
+  const bus = yield* Service78;
+  yield* Effect.gen(function* () {
+    const snapshot = yield* Service47;
+    if (!session.revert)
+      return;
+    const original = session.revert.snapshot ? ID6.make(session.revert.snapshot) : undefined;
+    if (original)
+      yield* snapshot.restore({
+        files: new Map((session.revert.files ?? []).map((file) => [RelativePath2.make(file.file), original]))
+      });
+    yield* bus.publish(SessionEvent2.RevertEvent.Cleared, {
+      sessionID: session.id
+    });
+  }).pipe(instances.provide(session));
+});
+var commit2 = Effect.fn("SessionRevert.commit")(function* (bus, session) {
+  if (!session.revert)
+    return;
+  yield* bus.publish(SessionEvent2.RevertEvent.Committed, {
+    sessionID: session.id,
+    to: session.revert.messageID
+  });
+});
+var plan = Effect.fn("SessionRevert.plan")(function* (db, input) {
+  const boundary = yield* db.select({ seq: SessionMessageTable2.seq }).from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, input.sessionID), eq(SessionMessageTable2.id, input.messageID))).get().pipe(Effect.orDie);
+  if (!boundary)
+    return yield* new MessageNotFoundError2(input);
+  const rows = yield* db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, input.sessionID), eq(SessionMessageTable2.type, "assistant"), gt(SessionMessageTable2.seq, boundary.seq))).orderBy(asc(SessionMessageTable2.seq)).all().pipe(Effect.orDie);
+  const decode = Schema.decodeUnknownEffect(SessionMessage2.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, ID6.make(message.snapshot.start));
+  }
+  return files;
+});
+
+export { stage2, clear2, commit2, exports_revert };

package/dist/chunks/repository-20q8k894.js

@@ -0,0 +1,38 @@
+import {
+  Service44
+} from "./repository-smnv2tch.js";
+import {
+  match2
+} from "./repository-y1fvbwt7.js";
+import {
+  observe2
+} from "./repository-qsdy395h.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/plugin/policy.ts
+var exports_policy = {};
+__export(exports_policy, {
+  ConfigPolicyPlugin: () => exports_policy,
+  Plugin: () => Plugin4
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin4 = define({
+  id: "opencode.config.policy",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service44;
+    const loaded = yield* observe2(config, ctx.event, ctx.catalog.reload());
+    yield* ctx.catalog.transform((catalog) => {
+      const policies = loaded.entries.filter((entry) => entry.type === "document").toReversed().flatMap((entry) => entry.info.experimental?.policies ?? []);
+      for (const record of catalog.provider.list()) {
+        const policy = policies.findLast((policy) => match2(record.provider.id, policy.resource));
+        if (policy?.effect === "deny")
+          catalog.provider.remove(record.provider.id);
+      }
+    });
+  })
+});
+
+export { Plugin4, exports_policy };

package/dist/chunks/repository-213v9py0.js

@@ -0,0 +1,71 @@
+import {
+  parseOption2
+} from "./repository-5daktx2q.js";
+import {
+  AbsolutePath2
+} from "./repository-922hggd3.js";
+import {
+  ID5,
+  Name2
+} from "./repository-9xb0s4b9.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/plugin/skill-file.ts
+var exports_skill_file = {};
+__export(exports_skill_file, {
+  SkillFile: () => exports_skill_file,
+  parse: () => parse2
+});
+import path from "path";
+import { Result, Schema, SchemaParser } from "effect";
+var Frontmatter = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  description: Schema.String.pipe(Schema.optional),
+  slash: Schema.Boolean.pipe(Schema.optional),
+  metadata: Schema.Unknown.pipe(Schema.optional)
+});
+var decodeFrontmatter = SchemaParser.decodeUnknownResult(Frontmatter);
+var metadataBoolean = (metadata, key) => {
+  if (metadata === undefined || metadata === null || typeof metadata !== "object" || Array.isArray(metadata)) {
+    return;
+  }
+  const value = Reflect.get(metadata, key);
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value !== "string")
+    return;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true")
+    return true;
+  if (normalized === "false")
+    return false;
+  return;
+};
+function parse2(directory, filepath, content) {
+  const markdown = parseOption2(content);
+  if (!markdown)
+    return { _tag: "Skipped", reason: "markdown" };
+  const decoded = decodeFrontmatter(markdown.data);
+  if (Result.isFailure(decoded))
+    return { _tag: "Skipped", reason: "frontmatter", issue: decoded.failure };
+  const frontmatter = decoded.success;
+  const id = path.dirname(filepath) === directory && path.basename(filepath) !== "SKILL.md" ? path.basename(filepath, ".md") : path.basename(path.dirname(filepath));
+  const slash = metadataBoolean(frontmatter.metadata, "opencode/slash") ?? frontmatter.slash;
+  const autoinvoke = metadataBoolean(frontmatter.metadata, "opencode/autoinvoke");
+  return {
+    _tag: "Parsed",
+    skill: {
+      id: ID5.make(id),
+      name: Name2.make(frontmatter.name ?? id),
+      ...frontmatter.description === undefined ? {} : { description: frontmatter.description },
+      ...slash === undefined ? {} : { slash },
+      ...autoinvoke === undefined ? {} : { autoinvoke },
+      location: AbsolutePath2.make(filepath),
+      content: markdown.content
+    }
+  };
+}
+
+export { parse2, exports_skill_file };

package/dist/chunks/repository-21r38tys.js

@@ -0,0 +1,14 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/v1/config/layout.ts
+var exports_layout = {};
+__export(exports_layout, {
+  ConfigLayoutV1: () => exports_layout,
+  Layout: () => Layout2
+});
+import { Schema } from "effect";
+var Layout2 = Schema.Literals(["auto", "stretch"]).annotate({ identifier: "LayoutConfig" });
+
+export { Layout2, exports_layout };