@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19124

package/dist/chunks/event-logger-6vtbmr7p.js

@@ -0,0 +1,287 @@
+import {
+  AbsolutePath2
+} from "./event-logger-p8qxwesx.js";
+import {
+  WorktreeError2,
+  node82
+} from "./event-logger-jasnfvjs.js";
+import {
+  ID17
+} from "./event-logger-2cvfr09c.js";
+import {
+  Slug2
+} from "./event-logger-gebd4c9n.js";
+import {
+  Service80,
+  node85
+} from "./event-logger-4vtp7hga.js";
+import {
+  Service79,
+  node84
+} from "./event-logger-jbmjz4v3.js";
+import {
+  ProjectTable2
+} from "./event-logger-9qm9egsn.js";
+import {
+  WorktreeTable2
+} from "./event-logger-ajtjthsy.js";
+import {
+  Service75,
+  node80
+} from "./event-logger-00s3pqt3.js";
+import {
+  DirectoryUnavailableError2,
+  canonical2
+} from "./event-logger-93a8yfjt.js";
+import {
+  make11
+} from "./event-logger-t3daf40q.js";
+import {
+  create3
+} from "./event-logger-kg06axw8.js";
+import {
+  __export
+} from "./event-logger-9rqn6x4v.js";
+
+// src/worktree.ts
+var exports_worktree2 = {};
+__export(exports_worktree2, {
+  CreateInput: () => CreateInput3,
+  DestinationExistsError: () => DestinationExistsError2,
+  DirectoryUnavailableError: () => DirectoryUnavailableError2,
+  Event: () => Event6,
+  Info: () => Info4,
+  InvalidDirectoryError: () => InvalidDirectoryError2,
+  List: () => List2,
+  ListEntry: () => ListEntry3,
+  OperationError: () => OperationError2,
+  RefreshResult: () => RefreshResult2,
+  RemoveInput: () => RemoveInput2,
+  Service: () => Service22,
+  SourceDirectoryNotFoundError: () => SourceDirectoryNotFoundError2,
+  StrategyID: () => StrategyID2,
+  StrategyUnavailableError: () => StrategyUnavailableError2,
+  UnsupportedLocationError: () => UnsupportedLocationError2,
+  Worktree: () => exports_worktree2,
+  node: () => node26
+});
+import { Context, Effect, Layer, Schema } from "effect";
+import { and, asc, desc, eq, isNull, sql } from "drizzle-orm";
+import path from "path";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Global } from "@opencode-ai/util/global";
+import { Worktree } from "@opencode-ai/schema/worktree";
+import { AppProcess } from "@opencode-ai/util/process";
+import { ChildProcess } from "effect/unstable/process";
+import { OperationError as OperationError2 } from "@opencode-ai/schema/worktree";
+var StrategyID2 = Worktree.StrategyID;
+var CreateInput3 = Worktree.CreateInput;
+var RemoveInput2 = Worktree.RemoveInput;
+var RefreshResult2 = Schema.Struct({
+  updated: Schema.Array(AbsolutePath2),
+  removed: Schema.Array(AbsolutePath2)
+}).annotate({ identifier: "Worktree.RefreshResult" });
+var Info4 = Worktree.Info;
+var List2 = Worktree.List;
+var ListEntry3 = Worktree.ListEntry;
+
+class SourceDirectoryNotFoundError2 extends Schema.TaggedError()("Worktree.SourceDirectoryNotFoundError", { projectID: ID17, directory: Schema.optional(AbsolutePath2) }) {
+}
+
+class DestinationExistsError2 extends Schema.TaggedError()("Worktree.DestinationExistsError", { directory: AbsolutePath2 }) {
+}
+
+class InvalidDirectoryError2 extends Schema.TaggedError()("Worktree.InvalidDirectoryError", { directory: AbsolutePath2 }) {
+}
+
+class StrategyUnavailableError2 extends Schema.TaggedError()("Worktree.StrategyUnavailableError", { strategy: StrategyID2 }) {
+}
+
+class UnsupportedLocationError2 extends Schema.TaggedError()("Worktree.UnsupportedLocationError", { directory: AbsolutePath2 }) {
+}
+var Event6 = Worktree.Event;
+
+class Service22 extends Context.Service()("@opencode/v2/Worktree") {
+}
+var layer = Layer.effect(Service22, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const database = yield* Service80;
+  const db = database.db;
+  const bus = yield* Service79;
+  const processService = yield* AppProcess.Service;
+  const location = yield* Service75;
+  const global = yield* Global.Service;
+  const projectID = location.project.id;
+  const local = location.workspaceID ? Effect.fail(new UnsupportedLocationError2({ directory: location.directory })) : Effect.void;
+  const gitStrategy = yield* make11;
+  const state = create3({
+    name: "worktree",
+    initial: () => ({
+      directory: AbsolutePath2.make(path.join(global.data, "worktree", projectID.slice(0, 6))),
+      strategies: new Map([[gitStrategy.id, gitStrategy]]),
+      selected: gitStrategy.id
+    }),
+    editor: (value) => ({
+      configure: (settings) => {
+        value.directory = settings.directory;
+      },
+      add: (strategy) => {
+        value.strategies.delete(strategy.id);
+        value.strategies.set(strategy.id, strategy);
+        value.selected = strategy.id;
+      }
+    })
+  });
+  const changed = Effect.fnUntraced(function* (update) {
+    if (update)
+      yield* bus.publish(Event6.Updated, { projectID });
+  });
+  const ops = {
+    list: Effect.fnUntraced(function* () {
+      const rows = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(eq(WorktreeTable2.project_id, projectID)).orderBy(desc(WorktreeTable2.time_created), asc(WorktreeTable2.directory)).all().pipe(Effect.orDie);
+      return rows.map((row) => ({ directory: row.directory, strategy: row.strategy ?? undefined }));
+    }),
+    find: Effect.fnUntraced(function* (directory) {
+      const row = yield* db.select({ directory: WorktreeTable2.directory, strategy: WorktreeTable2.strategy }).from(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).get().pipe(Effect.orDie);
+      return row ? { directory: row.directory, strategy: row.strategy ?? undefined } : undefined;
+    }),
+    create: (input, tx) => (tx ?? db).insert(WorktreeTable2).values({
+      project_id: projectID,
+      directory: input.directory,
+      strategy: input.strategy
+    }).onConflictDoUpdate({
+      target: [WorktreeTable2.project_id, WorktreeTable2.directory],
+      set: {
+        strategy: input.strategy ?? null
+      },
+      setWhere: input.replace ? undefined : input.strategy ? isNull(WorktreeTable2.strategy) : sql`false`
+    }).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined)),
+    remove: (directory, tx) => (tx ?? db).delete(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, projectID), eq(WorktreeTable2.directory, directory))).returning({ directory: WorktreeTable2.directory }).get().pipe(Effect.orDie, Effect.map((row) => row !== undefined))
+  };
+  const source = Effect.fnUntraced(function* (input) {
+    const sourceDirectory = input ?? location.project.directory;
+    const resolved = yield* canonical2(fs, sourceDirectory);
+    if ((yield* ops.find(resolved)) === undefined)
+      return yield* new SourceDirectoryNotFoundError2({ projectID, directory: resolved });
+    return resolved;
+  });
+  const getStrategy = Effect.fnUntraced(function* (id, strategies) {
+    const found = strategies.get(id);
+    if (!found)
+      return yield* new StrategyUnavailableError2({ strategy: id });
+    return found;
+  });
+  const create = Effect.fn("Worktree.create")(function* (input = {}) {
+    yield* local;
+    const current = state.get();
+    const selected = yield* getStrategy(input.strategy ?? current.selected, current.strategies);
+    const directory = input.directory ?? current.directory;
+    const sourceDirectory = yield* source(input.from);
+    yield* fs.makeDirectory(directory, { recursive: true }).pipe(Effect.orDie);
+    const name = input.name ?? Slug2.create();
+    let suffix = 1;
+    let worktreeDirectory = AbsolutePath2.make(path.join(directory, name));
+    while (yield* fs.existsSafe(worktreeDirectory)) {
+      suffix++;
+      if (suffix > 10)
+        return yield* new DestinationExistsError2({ directory: worktreeDirectory });
+      worktreeDirectory = AbsolutePath2.make(path.join(directory, `${name}-${suffix}`));
+    }
+    const created = yield* selected.create({
+      directory: worktreeDirectory,
+      sourceDirectory,
+      branch: input.branch
+    }).pipe(Effect.mapError((error) => operationError(selected.id, "create", error)));
+    const result = { directory: yield* canonical2(fs, created.directory) };
+    if (result.directory !== (yield* canonical2(fs, worktreeDirectory)))
+      return yield* new InvalidDirectoryError2({ directory: result.directory });
+    yield* changed(yield* ops.create({
+      directory: result.directory,
+      strategy: selected.id,
+      replace: true
+    }));
+    const project = yield* db.select({ commands: ProjectTable2.commands }).from(ProjectTable2).where(eq(ProjectTable2.id, projectID)).get().pipe(Effect.orDie);
+    const command = project?.commands?.start?.trim();
+    if (command) {
+      const windows = process.platform === "win32";
+      yield* processService.run(ChildProcess.make(windows ? command : "bash", windows ? [] : ["-lc", command], {
+        cwd: result.directory,
+        env: {
+          OPENCODE_WORKTREE_BASE: sourceDirectory,
+          OPENCODE_WORKTREE_PATH: result.directory
+        },
+        extendEnv: true,
+        stdin: "ignore",
+        shell: windows
+      })).pipe(Effect.flatMap(AppProcess.requireSuccess));
+    }
+    return result;
+  });
+  const remove = Effect.fn("Worktree.remove")(function* (input) {
+    yield* local;
+    const worktreeDirectory = yield* canonical2(fs, input.directory);
+    const stored = yield* ops.find(worktreeDirectory);
+    if (!stored?.strategy)
+      return yield* new InvalidDirectoryError2({ directory: worktreeDirectory });
+    const strategy = yield* getStrategy(StrategyID2.make(stored.strategy), state.get().strategies);
+    yield* strategy.remove({
+      directory: worktreeDirectory,
+      force: input.force
+    }).pipe(Effect.mapError((error) => operationError(strategy.id, "remove", error)));
+    yield* changed(yield* ops.remove(worktreeDirectory));
+  });
+  const refresh = Effect.fn("Worktree.refresh")(function* () {
+    yield* local;
+    const stored = yield* ops.list();
+    const checked = yield* Effect.forEach(stored, (item) => fs.isDir(item.directory).pipe(Effect.map((exists) => ({ ...item, exists }))), { concurrency: "unbounded" });
+    const strategies = Array.from(state.get().strategies.values()).toReversed();
+    const discovered = new Map;
+    if (checked.some((item) => item.directory === location.project.directory && item.exists)) {
+      for (const strategy of strategies) {
+        const entries = yield* strategy.list(location.project.directory).pipe(Effect.mapError((error) => operationError(strategy.id, "list", error)), Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.succeed([])));
+        for (const entry of entries) {
+          const directory = yield* canonical2(fs, entry.directory).pipe(Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.undefined));
+          if (!directory || discovered.has(directory))
+            continue;
+          discovered.set(directory, {
+            directory,
+            strategy: entry.type === "worktree" ? strategy.id : undefined
+          });
+        }
+      }
+    }
+    const removed = checked.filter((item) => !item.exists).map((item) => item.directory);
+    const changes = yield* db.transaction((tx) => Effect.all({
+      updated: Effect.filter(Array.from(discovered.values()), (item) => ops.create(item, tx)).pipe(Effect.map((items) => items.map((item) => item.directory))),
+      removed: Effect.filter(removed, (directory) => ops.remove(directory, tx))
+    })).pipe(Effect.orDie);
+    yield* changed(changes.updated.length > 0 || changes.removed.length > 0);
+    return changes;
+  });
+  return Service22.of({
+    transform: state.transform,
+    reload: state.reload,
+    list: Effect.fn("Worktree.list")(function* () {
+      yield* refresh();
+      return yield* ops.list();
+    }),
+    create,
+    remove,
+    refresh
+  });
+}));
+var node26 = makeLocationNode({
+  service: Service22,
+  layer,
+  deps: [FSUtil.node, node82, node84, node85, AppProcess.node, node80, Global.node]
+});
+function operationError(strategy, operation, error) {
+  if (error instanceof WorktreeError2 || error instanceof DirectoryUnavailableError2 || error instanceof Worktree.OperationError)
+    return error;
+  return new Worktree.OperationError({
+    message: `Worktree strategy ${strategy} failed to ${operation}: ${error instanceof globalThis.Error ? error.message : String(error)}`
+  });
+}
+
+export { StrategyID2, CreateInput3, RemoveInput2, RefreshResult2, Info4, List2, ListEntry3, SourceDirectoryNotFoundError2, DestinationExistsError2, InvalidDirectoryError2, StrategyUnavailableError2, UnsupportedLocationError2, Event6, Service22, node26, exports_worktree2, OperationError2 };

package/dist/chunks/{schema-etbnsc4s.js → event-logger-6z5bwd8g.js}

@@ -1,22 +1,22 @@
 import {
-  collectBoundedResponseBody
-} from "./schema-jve7t217.js";
+  collectBoundedResponseBody2
+} from "./event-logger-3v8g72cx.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/plugin/websearch/mcp.ts
 var exports_mcp = {};
 __export(exports_mcp, {
-  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES,
+  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES2,
   WebSearchMcp: () => exports_mcp,
-  call: () => call,
-  parseResponse: () => parseResponse
+  call: () => call2,
+  parseResponse: () => parseResponse2
 });
 import { Duration, Effect, Schema } from "effect";
 import { HttpClient, HttpClientRequest } from "effect/unstable/http";
-var MAX_RESPONSE_BYTES = 256 * 1024;
-var parseResponse = (body, result) => {
+var MAX_RESPONSE_BYTES2 = 256 * 1024;
+var parseResponse2 = (body, result) => {
   const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ result })));
   const parse = (payload) => {
     const trimmed = payload.trim();
@@ -39,7 +39,7 @@ var parseResponse = (body, result) => {
     }
   });
 };
-var call = (http, url, tool, schema, value, headers = {}) => Effect.gen(function* () {
+var call2 = (http, url, tool, schema, value, headers = {}) => Effect.gen(function* () {
   const request = yield* HttpClientRequest.post(url).pipe(HttpClientRequest.accept("application/json, text/event-stream"), HttpClientRequest.setHeaders(headers), HttpClientRequest.schemaBodyJson(Schema.Struct({
     jsonrpc: Schema.Literal("2.0"),
     id: Schema.Literal(1),
@@ -53,12 +53,12 @@ var call = (http, url, tool, schema, value, headers = {}) => Effect.gen(function
   }));
   return yield* Effect.gen(function* () {
     const response = yield* HttpClient.filterStatusOk(http).execute(request);
-    const body = yield* collectBoundedResponseBody(response, MAX_RESPONSE_BYTES, () => new Error(`${tool} response exceeded ${MAX_RESPONSE_BYTES} bytes`));
-    return yield* parseResponse(body.toString("utf8"), schema.output);
+    const body = yield* collectBoundedResponseBody2(response, MAX_RESPONSE_BYTES2, () => new Error(`${tool} response exceeded ${MAX_RESPONSE_BYTES2} bytes`));
+    return yield* parseResponse2(body.toString("utf8"), schema.output);
   }).pipe(Effect.timeoutOrElse({
     duration: Duration.seconds(25),
     orElse: () => Effect.fail(new Error(`${tool} request timed out`))
   }));
 });
 
-export { MAX_RESPONSE_BYTES, parseResponse, call, exports_mcp };
+export { MAX_RESPONSE_BYTES2, parseResponse2, call2, exports_mcp };

package/dist/chunks/{schema-xdb88cdw.js → event-logger-711hfp6y.js}

@@ -1,19 +1,19 @@
 import {
-  PositiveInt
-} from "./schema-j07kk359.js";
+  PositiveInt2
+} from "./event-logger-p8qxwesx.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/v1/config/server.ts
 var exports_server = {};
 __export(exports_server, {
   ConfigServerV1: () => exports_server,
-  Server: () => Server
+  Server: () => Server2
 });
 import { Schema } from "effect";
-var Server = Schema.Struct({
-  port: Schema.optional(PositiveInt).annotate({
+var Server2 = Schema.Struct({
+  port: Schema.optional(PositiveInt2).annotate({
     description: "Port to listen on"
   }),
   hostname: Schema.optional(Schema.String).annotate({ description: "Hostname to listen on" }),
@@ -26,4 +26,4 @@ var Server = Schema.Struct({
   })
 }).annotate({ identifier: "ServerConfig" });
 
-export { Server, exports_server };
+export { Server2, exports_server };

package/dist/chunks/{schema-hgr9y616.js → event-logger-7bmhse3q.js}

@@ -1,8 +1,8 @@
 import {
-  getTableColumnsRuntime,
-  mapUpdateSet,
-  orderSelectedFields
-} from "./schema-k8b45nas.js";
+  getTableColumnsRuntime2,
+  orderSelectedFields2,
+  mapUpdateSet2
+} from "./event-logger-emrn6kk6.js";
 
 // src/database/drizzle/sqlite-core/effect/insert.ts
 import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
@@ -11,7 +11,7 @@ import { SQL, sql } from "drizzle-orm/sql/sql";
 import { extractUsedTable } from "drizzle-orm/sqlite-core/utils";
 import { haveSameKeys } from "drizzle-orm/utils";
 import { QueryBuilder } from "drizzle-orm/sqlite-core/query-builders/query-builder";
-class SQLiteEffectInsertBuilder {
+class SQLiteEffectInsertBuilder2 {
   table;
   session;
   dialect;
@@ -28,18 +28,18 @@ class SQLiteEffectInsertBuilder {
     if (values.length === 0) {
       throw new Error("values() must be called with at least one value");
     }
-    return new SQLiteEffectInsertBase(this.table, values, this.session, this.dialect, this.withList);
+    return new SQLiteEffectInsertBase2(this.table, values, this.session, this.dialect, this.withList);
   }
   select(selectQuery) {
     const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder) : selectQuery;
-    if (!is(select, SQL) && !haveSameKeys(getTableColumnsRuntime(this.table), select._.selectedFields)) {
+    if (!is(select, SQL) && !haveSameKeys(getTableColumnsRuntime2(this.table), select._.selectedFields)) {
       throw new Error("Insert select error: selected fields are not the same or are in a different order compared to the table definition");
     }
-    return new SQLiteEffectInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
+    return new SQLiteEffectInsertBase2(this.table, select, this.session, this.dialect, this.withList, true);
   }
 }
 
-class SQLiteEffectInsertBase {
+class SQLiteEffectInsertBase2 {
   effectSession;
   effectDialect;
   static [entityKind] = "SQLiteEffectInsert";
@@ -49,8 +49,8 @@ class SQLiteEffectInsertBase {
     this.effectDialect = effectDialect;
     this.config = { table, values, withList, select };
   }
-  returning(fields = getTableColumnsRuntime(this.config.table)) {
-    this.config.returning = orderSelectedFields(fields);
+  returning(fields = getTableColumnsRuntime2(this.config.table)) {
+    this.config.returning = orderSelectedFields2(fields);
     return this;
   }
   onConflictDoNothing(config = {}) {
@@ -75,7 +75,7 @@ class SQLiteEffectInsertBase {
     const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : undefined;
     const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : undefined;
     const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
-    const setSql = this.effectDialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
+    const setSql = this.effectDialect.buildUpdateSet(this.config.table, mapUpdateSet2(this.config.table, config.set));
     this.config.onConflict.push(sql` on conflict ${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`);
     return this;
   }
@@ -113,6 +113,6 @@ class SQLiteEffectInsertBase {
     return this;
   }
 }
-applyEffectWrapper(SQLiteEffectInsertBase);
+applyEffectWrapper(SQLiteEffectInsertBase2);
 
-export { SQLiteEffectInsertBuilder, SQLiteEffectInsertBase };
+export { SQLiteEffectInsertBuilder2, SQLiteEffectInsertBase2 };

package/dist/chunks/{schema-c55cgmsp.js → event-logger-7ekmjv5k.js}

@@ -1,18 +1,19 @@
 import {
-  exports_provider
-} from "./schema-68yag814.js";
+  mergeOverlay2,
+  mergeHeaders2
+} from "./event-logger-rwbhhn1p.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/aisdk-native.ts
 var exports_aisdk_native = {};
 __export(exports_aisdk_native, {
   AISDKNative: () => exports_aisdk_native,
-  map: () => map
+  map: () => map2
 });
 import { isRecord } from "@opencode-ai/ai/utils/record";
-function map(input) {
+function map2(input) {
   const baseSettings = mapBaseSettings(input.settings);
   switch (input.packageName) {
     case "@ai-sdk/anthropic":
@@ -191,7 +192,7 @@ function mapBedrockRequest(input) {
   const display = typeof reasoning?.display === "string" ? reasoning.display : undefined;
   const betas = Array.isArray(settings.anthropicBeta) ? settings.anthropicBeta.filter((item) => typeof item === "string") : [];
   const existingBetas = Array.isArray(additional.anthropic_beta) ? additional.anthropic_beta.filter((item) => typeof item === "string") : [];
-  const fields = exports_provider.mergeOverlay(additional, {
+  const fields = mergeOverlay2(additional, {
     ...betas.length > 0 ? { anthropic_beta: [...existingBetas, ...betas] } : {},
     ...anthropic && type === "enabled" && budget !== undefined ? { thinking: { type: "enabled", budget_tokens: budget } } : {},
     ...anthropic && type === "adaptive" ? { thinking: { type: "adaptive", ...display === undefined ? {} : { display } } } : {},
@@ -289,7 +290,7 @@ function mapGoogleOptions(settings) {
   return { providerOptions: options };
 }
 function mapOpenRouter(settings, baseSettings) {
-  const headers = exports_provider.mergeHeaders({
+  const headers = mergeHeaders2({
     ...typeof settings.appName === "string" ? { "X-OpenRouter-Title": settings.appName } : {},
     ...typeof settings.appUrl === "string" ? { "HTTP-Referer": settings.appUrl } : {},
     ...isStringRecord(settings.api_keys) && Object.keys(settings.api_keys).length > 0 ? { "X-Provider-API-Keys": JSON.stringify(settings.api_keys) } : {}
@@ -335,4 +336,4 @@ function mapXAIOptions(settings) {
   return { providerOptions: options };
 }
 
-export { map, exports_aisdk_native };
+export { map2, exports_aisdk_native };

package/dist/chunks/{schema-eyr78tzb.js → event-logger-7fh311k0.js}

@@ -1,25 +1,28 @@
 import {
-  exports_store
-} from "./schema-a4wk7wxx.js";
+  Service79,
+  node84
+} from "./event-logger-jbmjz4v3.js";
 import {
-  SessionEvent
-} from "./schema-a83yvq99.js";
+  Service75,
+  node80
+} from "./event-logger-00s3pqt3.js";
 import {
-  exports_location
-} from "./schema-9kt3hna5.js";
+  SessionEvent2
+} from "./event-logger-mntxs535.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  Service72,
+  node77
+} from "./event-logger-xf2wyvfy.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/session/instructions.ts
 var exports_instructions = {};
 __export(exports_instructions, {
-  Service: () => Service,
+  Service: () => Service6,
   SessionInstructions: () => exports_instructions,
-  node: () => node
+  node: () => node9
 });
 import { relative } from "path";
 import { Context, Effect, Layer, Option, Ref, Schema } from "effect";
@@ -29,13 +32,13 @@ var InjectedMetadata = Schema.Struct({
   instruction: Schema.Struct({ paths: Schema.Array(Schema.String) })
 });
 
-class Service extends Context.Service()("@opencode/SessionInstructions") {
+class Service6 extends Context.Service()("@opencode/SessionInstructions") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
+var layer = Layer.effect(Service6, Effect.gen(function* () {
+  const bus = yield* Service79;
   const fs = yield* FSUtil.Service;
-  const store = yield* exports_store.Service;
-  const location = yield* exports_location.Service;
+  const store = yield* Service72;
+  const location = yield* Service75;
   const root = yield* fs.resolve(location.project.directory);
   const inFlight = yield* Ref.make(new Map);
   const load = Effect.fn("SessionInstructions.load")(function* (input) {
@@ -59,7 +62,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const readable = files.filter((file) => file !== undefined);
       if (readable.length === 0)
         return;
-      yield* bus.publish(SessionEvent.Synthetic, {
+      yield* bus.publish(SessionEvent2.Synthetic, {
         sessionID: input.sessionID,
         text: readable.map((file) => `Instructions from: ${file.path}
 ${file.content}`).join(`
@@ -81,7 +84,7 @@ ${file.content}`).join(`
       return next;
     })));
   });
-  return Service.of({ load });
+  return Service6.of({ load });
 }));
 function previouslyInjected(store, sessionID) {
   return Effect.gen(function* () {
@@ -92,10 +95,10 @@ function previouslyInjected(store, sessionID) {
 function describePath(root, path) {
   return FSUtil.contains(root, path) ? relative(root, path) : path;
 }
-var node = makeLocationNode({
+var node9 = makeLocationNode({
   name: "session-instructions",
   layer,
-  deps: [exports_bus.node, FSUtil.node, exports_location.node, exports_store.node]
+  deps: [node84, FSUtil.node, node80, node77]
 });
 
-export { Service, node, exports_instructions };
+export { Service6, node9, exports_instructions };

package/dist/chunks/{schema-2c5k0n78.js → event-logger-7mx8k0q7.js}

@@ -1,21 +1,22 @@
 import {
-  exports_markdown
-} from "./schema-p5gyct0y.js";
+  parseOption2
+} from "./event-logger-5daktx2q.js";
 import {
-  exports_skill
-} from "./schema-tbzs2pmr.js";
+  AbsolutePath2
+} from "./event-logger-p8qxwesx.js";
 import {
-  AbsolutePath
-} from "./schema-j07kk359.js";
+  ID6,
+  Name2
+} from "./event-logger-28nhnrpr.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/config/plugin/skill-file.ts
 var exports_skill_file = {};
 __export(exports_skill_file, {
   SkillFile: () => exports_skill_file,
-  parse: () => parse
+  parse: () => parse2
 });
 import path from "path";
 import { Result, Schema, SchemaParser } from "effect";
@@ -42,8 +43,8 @@ var metadataBoolean = (metadata, key) => {
     return false;
   return;
 };
-function parse(directory, filepath, content) {
-  const markdown = exports_markdown.parseOption(content);
+function parse2(directory, filepath, content) {
+  const markdown = parseOption2(content);
   if (!markdown)
     return { _tag: "Skipped", reason: "markdown" };
   const decoded = decodeFrontmatter(markdown.data);
@@ -56,15 +57,15 @@ function parse(directory, filepath, content) {
   return {
     _tag: "Parsed",
     skill: {
-      id: exports_skill.ID.make(id),
-      name: exports_skill.Name.make(frontmatter.name ?? id),
+      id: ID6.make(id),
+      name: Name2.make(frontmatter.name ?? id),
       ...frontmatter.description === undefined ? {} : { description: frontmatter.description },
       ...slash === undefined ? {} : { slash },
       ...autoinvoke === undefined ? {} : { autoinvoke },
-      location: AbsolutePath.make(filepath),
+      location: AbsolutePath2.make(filepath),
       content: markdown.content
     }
   };
 }
 
-export { parse, exports_skill_file };
+export { parse2, exports_skill_file };