@opencode-ai/core 0.0.0-dev-19092 → 0.0.0-dev-19094

package/dist/chunks/command-32m8x2r5.js

@@ -0,0 +1,321 @@
+import {
+  Service80,
+  node84
+} from "./command-mh85gtv1.js";
+import {
+  makeUnsafe2
+} from "./command-jwcy2c2z.js";
+import {
+  Service79,
+  node83
+} from "./command-pdae5shs.js";
+import {
+  SessionEvent2
+} from "./command-mntxs535.js";
+import {
+  SessionMessage2
+} from "./command-982e01ww.js";
+import {
+  SessionSchema2
+} from "./command-5rw6je3s.js";
+import {
+  SessionMessageTable2,
+  SessionInboxTable2
+} from "./command-hrvm11jt.js";
+import {
+  __export
+} from "./command-9rqn6x4v.js";
+
+// src/session/inbox.ts
+var exports_inbox = {};
+__export(exports_inbox, {
+  Compaction: () => Compaction2,
+  CompactionPayload: () => CompactionPayload2,
+  Delivery: () => Delivery2,
+  Info: () => Info5,
+  Item: () => Item2,
+  LifecycleConflict: () => LifecycleConflict2,
+  Move: () => Move2,
+  MovePayload: () => MovePayload2,
+  Service: () => Service31,
+  SessionInbox: () => exports_inbox,
+  Synthetic: () => Synthetic2,
+  SyntheticPayload: () => SyntheticPayload2,
+  User: () => User2,
+  UserPayload: () => UserPayload2,
+  find: () => find2,
+  has: () => has2,
+  layer: () => layer14,
+  list: () => list3,
+  make: () => make15,
+  moveIDs: () => moveIDs2,
+  nextPromotable: () => nextPromotable2,
+  node: () => node34,
+  projectAdmitted: () => projectAdmitted2,
+  projectCancelled: () => projectCancelled2,
+  projectDelivered: () => projectDelivered2,
+  projectDeliveryChanged: () => projectDeliveryChanged2,
+  promote: () => promote2,
+  serialized: () => serialized2
+});
+import { and, asc, eq, or } from "drizzle-orm";
+import { Context, DateTime, Effect, Layer, Schema } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import {
+  Compaction as Compaction2,
+  CompactionPayload as CompactionPayload2,
+  Delivery as Delivery2,
+  Info as Info5,
+  Item as Item2,
+  Move as Move2,
+  MovePayload as MovePayload2,
+  Synthetic as Synthetic2,
+  SyntheticPayload as SyntheticPayload2,
+  User as User2,
+  UserPayload as UserPayload2
+} from "@opencode-ai/schema/session-inbox";
+var decodeUser = Schema.decodeUnknownSync(UserPayload2);
+var encodeUser = Schema.encodeSync(UserPayload2);
+var decodeSynthetic = Schema.decodeUnknownSync(SyntheticPayload2);
+var encodeSynthetic = Schema.encodeSync(SyntheticPayload2);
+var decodeCompaction = Schema.decodeUnknownSync(CompactionPayload2);
+var encodeCompaction = Schema.encodeSync(CompactionPayload2);
+var decodeMove = Schema.decodeUnknownSync(MovePayload2);
+var encodeMove = Schema.encodeSync(MovePayload2);
+var decodeMessage = Schema.decodeUnknownSync(SessionMessage2.Info);
+var inboxLocks = makeUnsafe2();
+var serialized2 = (sessionID, effect) => inboxLocks.withLock(sessionID)(effect);
+
+class LifecycleConflict2 extends Schema.TaggedError()("SessionInbox.LifecycleConflict", {
+  id: SessionMessage2.ID
+}) {
+}
+function matches(stored, request) {
+  return stored.sessionID === request.sessionID && stored.type === request.type;
+}
+var fromRow = (row) => {
+  const base = {
+    id: SessionMessage2.ID.make(row.id),
+    sessionID: SessionSchema2.ID.make(row.session_id),
+    timeCreated: DateTime.makeUnsafe(row.time_created)
+  };
+  if (row.type === "compaction")
+    return Compaction2.make({
+      ...base,
+      type: "compaction",
+      payload: decodeCompaction(row.payload),
+      delivery: row.delivery
+    });
+  if (row.type === "move")
+    return Move2.make({ ...base, type: "move", payload: decodeMove(row.payload), delivery: row.delivery });
+  if (row.type === "user")
+    return User2.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(row.payload),
+      delivery: row.delivery
+    });
+  if (row.type === "synthetic")
+    return Synthetic2.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(row.payload),
+      delivery: row.delivery
+    });
+  throw new LifecycleConflict2({ id: base.id });
+};
+var find2 = Effect.fn("SessionInbox.find")(function* (db, id) {
+  const row = yield* db.select().from(SessionInboxTable2).where(eq(SessionInboxTable2.id, id)).get().pipe(Effect.orDie);
+  return row === undefined ? undefined : fromRow(row);
+});
+var promotedFromMessage = Effect.fn("SessionInbox.promotedFromMessage")(function* (db, sessionID, id, delivery) {
+  const row = yield* db.select().from(SessionMessageTable2).where(eq(SessionMessageTable2.id, id)).get().pipe(Effect.orDie);
+  if (row === undefined)
+    return;
+  if (row.session_id !== sessionID || row.type !== "user" && row.type !== "synthetic")
+    return yield* new LifecycleConflict2({ id });
+  const message = decodeMessage({ ...row.data, id: row.id, type: row.type });
+  const base = { id, sessionID, timeCreated: message.time.created, delivery };
+  if (message.type === "user")
+    return User2.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(message)
+    });
+  if (message.type === "synthetic")
+    return Synthetic2.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(message)
+    });
+  return yield* new LifecycleConflict2({ id });
+});
+
+class Service31 extends Context.Service()("@opencode/SessionInbox") {
+}
+var make15 = Effect.fn("SessionInbox.make")(function* () {
+  const database = yield* Service80;
+  const db = database.db;
+  const bus = yield* Service79;
+  const reconcile = Effect.fn("SessionInbox.reconcile")(function* (request) {
+    const existing = (yield* find2(db, request.id)) ?? (yield* promotedFromMessage(db, request.sessionID, request.id, request.delivery));
+    if (existing === undefined)
+      return;
+    if (existing.type === "compaction" || !matches(existing, request))
+      return yield* new LifecycleConflict2({ id: request.id });
+    return existing;
+  });
+  const admit = Effect.fn("SessionInbox.admit")(function* (request) {
+    const existing = yield* reconcile({ ...request, type: request.item.type, delivery: request.item.delivery });
+    if (existing !== undefined)
+      return existing;
+    const admitted = yield* bus.publish(SessionEvent2.InboxEnqueued, {
+      inboxID: request.id,
+      sessionID: request.sessionID,
+      item: request.item
+    }).pipe(Effect.map((event) => Info5.make({
+      id: request.id,
+      sessionID: request.sessionID,
+      timeCreated: DateTime.makeUnsafe(event.created),
+      ...request.item
+    })), Effect.catchDefect((defect) => defect instanceof LifecycleConflict2 ? find2(db, request.id).pipe(Effect.flatMap((stored) => stored === undefined ? Effect.fail(defect) : Effect.succeed(stored))) : Effect.die(defect)));
+    if (!matches(admitted, { ...request, type: request.item.type }))
+      return yield* new LifecycleConflict2({ id: request.id });
+    return admitted;
+  });
+  const admitCompaction = Effect.fn("SessionInbox.admitCompaction")(function* (input) {
+    return yield* serialized2(input.sessionID, Effect.gen(function* () {
+      const exact = yield* find2(db, input.id);
+      if (exact) {
+        if (exact.type === "compaction" && exact.sessionID === input.sessionID)
+          return exact;
+        return yield* new LifecycleConflict2({ id: input.id });
+      }
+      if (yield* promotedFromMessage(db, input.sessionID, input.id, input.delivery))
+        return yield* new LifecycleConflict2({ id: input.id });
+      const pending = (yield* list3(db, input.sessionID)).find((item) => item.type === "compaction");
+      if (pending)
+        return pending;
+      return yield* admit({
+        id: input.id,
+        sessionID: input.sessionID,
+        item: { type: "compaction", payload: {}, delivery: Delivery2.make(input.delivery) }
+      });
+    }));
+  });
+  const cancel = Effect.fn("SessionInbox.cancel")((input) => publishMutation(input, bus.publish(SessionEvent2.InboxCancelled, {
+    sessionID: input.sessionID,
+    inboxID: input.id
+  })));
+  const steer = Effect.fn("SessionInbox.steer")((input) => publishMutation(input, bus.publish(SessionEvent2.InboxDeliveryChanged, {
+    sessionID: input.sessionID,
+    inboxID: input.id,
+    delivery: "steer"
+  })));
+  const queue = Effect.fn("SessionInbox.queue")((input) => publishMutation(input, bus.publish(SessionEvent2.InboxDeliveryChanged, {
+    sessionID: input.sessionID,
+    inboxID: input.id,
+    delivery: "queue"
+  })));
+  return {
+    list: (sessionID) => list3(db, sessionID),
+    reconcile,
+    admit,
+    admitCompaction,
+    cancel,
+    steer,
+    queue
+  };
+});
+var layer14 = Layer.effect(Service31, make15());
+var node34 = makeGlobalNode({ service: Service31, layer: layer14, deps: [node84, node83] });
+var projectAdmitted2 = Effect.fn("SessionInbox.projectAdmitted")(function* (db, request) {
+  const message = yield* db.select({ id: SessionMessageTable2.id }).from(SessionMessageTable2).where(eq(SessionMessageTable2.id, request.id)).get().pipe(Effect.orDie);
+  if (message !== undefined)
+    return yield* Effect.die(new LifecycleConflict2({ id: request.id }));
+  const stored = yield* db.insert(SessionInboxTable2).values({
+    id: request.id,
+    session_id: request.sessionID,
+    type: request.item.type,
+    payload: request.item.type === "user" ? encodeUser(request.item.payload) : request.item.type === "synthetic" ? encodeSynthetic(request.item.payload) : request.item.type === "compaction" ? encodeCompaction(request.item.payload) : encodeMove(request.item.payload),
+    delivery: request.item.delivery,
+    enqueued_seq: request.enqueuedSeq,
+    time_created: request.timeCreated
+  }).onConflictDoNothing().returning({ id: SessionInboxTable2.id }).get().pipe(Effect.orDie);
+  if (!stored)
+    return yield* Effect.die(new LifecycleConflict2({ id: request.id }));
+});
+var projectDelivered2 = Effect.fn("SessionInbox.projectDelivered")(function* (db, input) {
+  const deleted = yield* db.delete(SessionInboxTable2).where(and(eq(SessionInboxTable2.id, input.id), eq(SessionInboxTable2.session_id, input.sessionID))).returning().get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict2({ id: input.id }));
+  return fromRow(deleted);
+});
+var projectCancelled2 = Effect.fn("SessionInbox.projectCancelled")(function* (db, input) {
+  const deleted = yield* db.delete(SessionInboxTable2).where(and(eq(SessionInboxTable2.id, input.id), eq(SessionInboxTable2.session_id, input.sessionID), or(eq(SessionInboxTable2.delivery, "queue"), eq(SessionInboxTable2.delivery, "steer")))).returning({ id: SessionInboxTable2.id }).get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict2({ id: input.id }));
+});
+var projectDelivery = Effect.fn("SessionInbox.projectDelivery")(function* (db, input) {
+  const updated = yield* db.update(SessionInboxTable2).set({ delivery: input.to }).where(and(eq(SessionInboxTable2.id, input.id), eq(SessionInboxTable2.session_id, input.sessionID), eq(SessionInboxTable2.delivery, input.from))).returning({ id: SessionInboxTable2.id }).get().pipe(Effect.orDie);
+  if (!updated)
+    return yield* Effect.die(new LifecycleConflict2({ id: input.id }));
+});
+var projectDeliveryChanged2 = Effect.fn("SessionInbox.projectDeliveryChanged")((db, input) => projectDelivery(db, {
+  ...input,
+  from: input.delivery === "steer" ? "queue" : "steer",
+  to: input.delivery
+}));
+var list3 = Effect.fn("SessionInbox.list")(function* (db, sessionID) {
+  const rows = yield* db.select().from(SessionInboxTable2).where(eq(SessionInboxTable2.session_id, sessionID)).orderBy(asc(SessionInboxTable2.enqueued_seq)).all().pipe(Effect.orDie);
+  return rows.map(fromRow);
+});
+var moveIDs2 = Effect.fn("SessionInbox.moveIDs")(function* (db, sessionID) {
+  return yield* db.select({ id: SessionInboxTable2.id }).from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.type, "move"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).all().pipe(Effect.orDie);
+});
+var nextPromotable2 = Effect.fn("SessionInbox.nextPromotable")(function* (db, sessionID, promotable) {
+  const next = (delivery) => db.select().from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.delivery, delivery))).orderBy(asc(SessionInboxTable2.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
+  const steer = yield* next("steer");
+  if (steer)
+    return fromRow(steer);
+  if (promotable !== "input")
+    return;
+  const queued = yield* next("queue");
+  return queued ? fromRow(queued) : undefined;
+});
+var has2 = Effect.fn("SessionInbox.has")(function* (db, sessionID, scope) {
+  const row = yield* db.select({ id: SessionInboxTable2.id }).from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), scope === "input" ? or(eq(SessionInboxTable2.delivery, "steer"), eq(SessionInboxTable2.delivery, "queue")) : eq(SessionInboxTable2.delivery, scope))).limit(1).get().pipe(Effect.orDie);
+  return row !== undefined;
+});
+var publishMutation = (input, effect) => serialized2(input.sessionID, effect).pipe(Effect.asVoid, Effect.catchDefect((defect) => defect instanceof LifecycleConflict2 ? Effect.fail(defect) : Effect.die(defect)));
+var publish = Effect.fn("SessionInbox.publish")(function* (db, bus, sessionID, rows) {
+  yield* Effect.forEach(rows, (row) => {
+    const entry = fromRow(row);
+    if (entry.type === "compaction")
+      return Effect.die(new LifecycleConflict2({ id: entry.id }));
+    return bus.publish(SessionEvent2.InboxDelivered, {
+      sessionID,
+      inboxID: entry.id
+    }).pipe(Effect.catchDefect((defect) => defect instanceof LifecycleConflict2 ? promotedFromMessage(db, sessionID, entry.id, entry.delivery).pipe(Effect.flatMap((stored) => stored !== undefined ? Effect.void : Effect.die(defect)), Effect.orDie) : Effect.die(defect)));
+  }, { discard: true });
+  return rows.length;
+});
+var promote2 = Effect.fn("SessionInbox.promote")(function* (db, bus, sessionID, scope) {
+  return yield* serialized2(sessionID, Effect.gen(function* () {
+    const steers = yield* pendingSteers(db, sessionID);
+    if (steers.length > 0 || scope === "steer") {
+      const control = steers.findIndex((row) => row.type === "compaction" || row.type === "move");
+      return yield* publish(db, bus, sessionID, control === -1 ? steers : steers.slice(0, control));
+    }
+    const queued = yield* db.select().from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.delivery, "queue"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
+    if (!queued)
+      return 0;
+    const promoted = yield* publish(db, bus, sessionID, [queued]);
+    const arrivedSteers = yield* pendingSteers(db, sessionID);
+    const control = arrivedSteers.findIndex((row) => row.type === "compaction" || row.type === "move");
+    return promoted + (yield* publish(db, bus, sessionID, control === -1 ? arrivedSteers : arrivedSteers.slice(0, control)));
+  }));
+});
+var pendingSteers = (db, sessionID) => db.select().from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.delivery, "steer"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).all().pipe(Effect.orDie);
+
+export { Compaction2, CompactionPayload2, Delivery2, Info5, Item2, Move2, MovePayload2, Synthetic2, SyntheticPayload2, User2, UserPayload2, serialized2, LifecycleConflict2, find2, Service31, make15, layer14, node34, projectAdmitted2, projectDelivered2, projectCancelled2, projectDeliveryChanged2, list3, moveIDs2, nextPromotable2, has2, promote2, exports_inbox };

package/dist/chunks/{integration-akgzz1c2.js → command-332w5sq1.js}

@@ -1,30 +1,30 @@
 import {
-  exports_compaction
-} from "./integration-rh3bqjrw.js";
+  Service57
+} from "./command-tr5yhgb5.js";
 import {
-  exports_entry_observer
-} from "./integration-mnyszbxc.js";
+  Service10
+} from "./command-3wbgnpam.js";
 import {
-  exports_config
-} from "./integration-q3j0tvwr.js";
+  observe2
+} from "./command-qsdy395h.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/config/plugin/compaction.ts
-var exports_compaction2 = {};
-__export(exports_compaction2, {
-  ConfigCompactionPlugin: () => exports_compaction2,
-  Plugin: () => Plugin
+var exports_compaction = {};
+__export(exports_compaction, {
+  ConfigCompactionPlugin: () => exports_compaction,
+  Plugin: () => Plugin17
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";
-var Plugin = define({
+var Plugin17 = define({
   id: "opencode.config.compaction",
   effect: Effect.fn(function* (ctx) {
-    const config = yield* exports_config.Service;
-    const compaction = yield* exports_compaction.Service;
-    const loaded = yield* exports_entry_observer.observe(config, ctx.event, compaction.reload());
+    const config = yield* Service57;
+    const compaction = yield* Service10;
+    const loaded = yield* observe2(config, ctx.event, compaction.reload());
     yield* compaction.transform((editor) => {
       for (const entry of loaded.entries) {
         if (entry.type !== "document" || !entry.info.compaction)
@@ -39,4 +39,4 @@ var Plugin = define({
   })
 });
 
-export { Plugin, exports_compaction2 as exports_compaction };
+export { Plugin17, exports_compaction };

package/dist/chunks/{integration-m8cbvarh.js → command-3asan66x.js}

@@ -1,5 +1,5 @@
 // src/github-copilot/responses/map-openai-responses-finish-reason.ts
-function mapOpenAIResponseFinishReason({
+function mapOpenAIResponseFinishReason2({
   finishReason,
   hasFunctionCall
 }) {
@@ -16,4 +16,4 @@ function mapOpenAIResponseFinishReason({
   }
 }
 
-export { mapOpenAIResponseFinishReason };
+export { mapOpenAIResponseFinishReason2 };

package/dist/chunks/{integration-rr7wbarq.js → command-3fc6dm20.js}

@@ -1,18 +1,18 @@
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/codemode/catalog.ts
 var exports_catalog = {};
 __export(exports_catalog, {
   CodeModeCatalog: () => exports_catalog,
-  Summary: () => Summary,
-  Tool: () => Tool,
-  namespaceLine: () => namespaceLine,
-  summarize: () => summarize
+  Summary: () => Summary2,
+  Tool: () => Tool2,
+  namespaceLine: () => namespaceLine2,
+  summarize: () => summarize2
 });
 import { Schema } from "effect";
-var Tool = Schema.Struct({
+var Tool2 = Schema.Struct({
   type: Schema.Literal("tool"),
   name: Schema.String,
   description: Schema.String,
@@ -29,7 +29,7 @@ var NamespaceSummary = Schema.Struct({
   count: Schema.Number,
   entries: Schema.Array(Listing)
 });
-var Summary = Schema.Struct({
+var Summary2 = Schema.Struct({
   total: Schema.Number,
   shown: Schema.Number,
   namespaces: Schema.Array(NamespaceSummary)
@@ -37,7 +37,7 @@ var Summary = Schema.Struct({
 var DESCRIPTION_LIMIT = 120;
 var CHARACTERS_PER_TOKEN = 4;
 var INLINE_BUDGET = 2000;
-function summarize(inventory, options = {}) {
+function summarize2(inventory, options = {}) {
   const budget = options.budget ?? INLINE_BUDGET;
   const flattened = flatten(inventory.tools);
   const namespaces = [...Map.groupBy(flattened.tools, (tool) => tool.path.split(".", 1)[0] ?? tool.path)].sort(([left], [right]) => {
@@ -51,8 +51,8 @@ function summarize(inventory, options = {}) {
     const listings = namespaceEntries.map((entry) => {
       const firstLine = entry.description.split(`
 `, 1)[0]?.trim() ?? "";
-      const description2 = firstLine.length > DESCRIPTION_LIMIT ? firstLine.slice(0, DESCRIPTION_LIMIT - 3) + "..." : firstLine;
-      const suffix = description2.length === 0 ? "" : ` // ${description2}`;
+      const description = firstLine.length > DESCRIPTION_LIMIT ? firstLine.slice(0, DESCRIPTION_LIMIT - 3) + "..." : firstLine;
+      const suffix = description.length === 0 ? "" : ` // ${description}`;
       return { path: entry.path, line: `  - ${entry.signature}${suffix}` };
     }).toSorted((left, right) => {
       if (left.path < right.path)
@@ -73,7 +73,7 @@ function summarize(inventory, options = {}) {
     };
   });
   const active = new Set(namespaces);
-  let remaining = budget - namespaces.reduce((total, namespace) => total + cost(namespaceLine({
+  let remaining = budget - namespaces.reduce((total, namespace) => total + cost(namespaceLine2({
     name: namespace.name,
     ...namespace.description === undefined ? {} : { description: namespace.description },
     count: namespace.listings.length,
@@ -128,7 +128,7 @@ function flatten(entries, path = []) {
   }
   return { tools, namespaces };
 }
-function namespaceLine(namespace) {
+function namespaceLine2(namespace) {
   const count = namespace.count === 1 ? "1 tool" : `${namespace.count} tools`;
   const label = namespace.entries.length === namespace.count ? count : namespace.entries.length === 0 ? `${count}, none shown` : `${count}, ${namespace.entries.length} shown`;
   return `- ${namespace.name} (${label})${namespace.description === undefined ? "" : ` // ${namespace.description}`}`;
@@ -148,4 +148,4 @@ function cost(text) {
   return Math.round(text.length / CHARACTERS_PER_TOKEN);
 }
 
-export { Tool, Summary, summarize, namespaceLine, exports_catalog };
+export { Tool2, Summary2, summarize2, namespaceLine2, exports_catalog };

package/dist/chunks/{integration-wmxdh12w.js → command-3hepkmqq.js}

@@ -1,13 +1,13 @@
 import {
-  Timestamps
-} from "./integration-sem2g21k.js";
+  Timestamps2
+} from "./command-qfa1cgps.js";
 
 // src/kv/sql.ts
 import { sqliteTable, text } from "drizzle-orm/sqlite-core";
-var KVTable = sqliteTable("kv", {
+var KVTable2 = sqliteTable("kv", {
   key: text().primaryKey(),
   value: text({ mode: "json" }).$type().notNull(),
-  ...Timestamps
+  ...Timestamps2
 });
 
-export { KVTable };
+export { KVTable2 };

package/dist/chunks/{integration-e3dx4kza.js → command-3jwbxfdj.js}

@@ -1,76 +1,83 @@
 import {
-  exports_location_mutation
-} from "./integration-m7ggyfe0.js";
+  typeFollowing2
+} from "./command-2a5m3afh.js";
 import {
-  exports_filesystem
-} from "./integration-warbtngd.js";
+  RelativePath2
+} from "./command-p8qxwesx.js";
 import {
-  exports_ripgrep
-} from "./integration-knk175w9.js";
+  Service68
+} from "./command-4jcgzkct.js";
 import {
-  exports_permission
-} from "./integration-44nx66ev.js";
+  Service55
+} from "./command-4y9deqpk.js";
 import {
-  exports_environment1 as exports_environment
-} from "./integration-xckxf18q.js";
+  Service54
+} from "./command-58dzf215.js";
 import {
-  exports_location
-} from "./integration-gpa7n6yh.js";
+  DEFAULT_SEARCH_LIMIT2,
+  DEFAULT_SEARCH_TIMEOUT_MS2,
+  GlobInput2,
+  Entry2
+} from "./command-avf2gxwn.js";
 import {
-  RelativePath
-} from "./integration-j07kk359.js";
+  externalDirectoryPermission2,
+  Service13
+} from "./command-zpgxjj6y.js";
+import {
+  Service42
+} from "./command-nkpkrkfc.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/tool/plugin/glob.ts
 var exports_glob = {};
 __export(exports_glob, {
   GlobTool: () => exports_glob,
-  Input: () => Input,
-  Output: () => Output,
-  Plugin: () => Plugin,
-  name: () => name,
-  toModelContent: () => toModelContent
+  Input: () => Input12,
+  Output: () => Output8,
+  Plugin: () => Plugin43,
+  name: () => name12,
+  toModelContent: () => toModelContent6
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Effect, Schema } from "effect";
 import path from "path";
-var name = "glob";
-var Input = Schema.Struct({
-  pattern: exports_filesystem.GlobInput.fields.pattern.annotate({ description: "Glob pattern to match files against" }),
-  path: Schema.optionalKey(RelativePath).annotate({
+var name12 = "glob";
+var Input12 = Schema.Struct({
+  pattern: GlobInput2.fields.pattern.annotate({ description: "Glob pattern to match files against" }),
+  path: Schema.optionalKey(RelativePath2).annotate({
     description: "Directory to search. Defaults to the current working directory."
   }),
-  hidden: exports_filesystem.GlobInput.fields.hidden.annotate({
+  hidden: GlobInput2.fields.hidden.annotate({
     description: "Include hidden files and directories (default: false)."
   }),
-  limit: exports_filesystem.GlobInput.fields.limit.annotate({
-    description: `Maximum number of matching files to return (default: ${exports_filesystem.DEFAULT_SEARCH_LIMIT})`
+  limit: GlobInput2.fields.limit.annotate({
+    description: `Maximum number of matching files to return (default: ${DEFAULT_SEARCH_LIMIT2})`
   })
 });
-var Output = Schema.Array(exports_filesystem.Entry);
-var toModelContent = (entries, truncated = false) => {
+var Output8 = Schema.Array(Entry2);
+var toModelContent6 = (entries, truncated = false) => {
   const lines = entries.length === 0 ? ["No files found"] : entries.map((item) => item.path);
   if (truncated)
     lines.push("", `(Results are truncated: showing first ${entries.length} results. Consider using a more specific path or pattern.)`);
   return lines.join(`
 `);
 };
-var Plugin = {
+var Plugin43 = {
   id: "opencode.tool.glob",
   effect: Effect.fn("GlobTool.Plugin")(function* (ctx) {
-    const environment = yield* exports_environment.Service;
-    const ripgrep = yield* exports_ripgrep.Service;
-    const location = yield* exports_location.Service;
-    const mutation = yield* exports_location_mutation.Service;
-    const permission = yield* exports_permission.Service;
+    const environment = yield* Service55;
+    const ripgrep = yield* Service54;
+    const location = yield* Service68;
+    const mutation = yield* Service13;
+    const permission = yield* Service42;
     yield* ctx.tool.transform((editor) => editor.add({
-      name,
+      name: name12,
       options: { codemode: false },
       description: 'Search file paths using a glob pattern (examples: "**/*.ts", "src/**/*.tsx").',
-      input: Input,
-      output: Output,
+      input: Input12,
+      output: Output8,
       execute: (input, context) => Effect.gen(function* () {
         const searchPath = input.path === "undefined" || input.path === "null" ? undefined : input.path;
         const source = { type: "tool", messageID: context.messageID, id: context.id };
@@ -78,13 +85,13 @@ var Plugin = {
         const external = target.externalDirectory;
         if (external)
           yield* permission.assert({
-            ...exports_location_mutation.externalDirectoryPermission(external),
+            ...externalDirectoryPermission2(external),
             sessionID: context.sessionID,
             agent: context.agent,
             source
           });
         yield* permission.assert({
-          action: name,
+          action: name12,
           resources: [input.pattern],
           save: ["*"],
           metadata: {
@@ -97,33 +104,33 @@ var Plugin = {
           agent: context.agent,
           source
         });
-        const type = yield* exports_environment.typeFollowing(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${searchPath ?? "."}` }))));
+        const type = yield* typeFollowing2(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${searchPath ?? "."}` }))));
         if (type !== "directory")
           return yield* Effect.fail(new ToolFailure({ message: `Search path is not a directory: ${searchPath ?? "."}` }));
         const root = target.absolute;
-        const limit = input.limit ?? exports_filesystem.DEFAULT_SEARCH_LIMIT;
+        const limit = input.limit ?? DEFAULT_SEARCH_LIMIT2;
         const entries = yield* ripgrep.glob({
           cwd: root,
           pattern: input.pattern,
           hidden: input.hidden,
           limit: limit + 1
         }).pipe(Effect.timeoutOrElse({
-          duration: exports_filesystem.DEFAULT_SEARCH_TIMEOUT_MS,
+          duration: DEFAULT_SEARCH_TIMEOUT_MS2,
           orElse: () => Effect.fail(new ToolFailure({
-            message: `Search timed out after ${exports_filesystem.DEFAULT_SEARCH_TIMEOUT_MS / 1000} seconds. Consider using a more specific path or pattern.`
+            message: `Search timed out after ${DEFAULT_SEARCH_TIMEOUT_MS2 / 1000} seconds. Consider using a more specific path or pattern.`
           }))
-        }), Effect.map((result) => result.map((entry) => exports_filesystem.Entry.make({
+        }), Effect.map((result) => result.map((entry) => Entry2.make({
           ...entry,
-          path: RelativePath.make(path.relative(location.directory, path.resolve(root, entry.path)))
+          path: RelativePath2.make(path.relative(location.directory, path.resolve(root, entry.path)))
         }))));
         return { entries: entries.slice(0, limit), truncated: entries.length > limit };
       }).pipe(Effect.map((result) => ({
         output: result.entries,
-        content: toModelContent(result.entries.map((entry) => ({ ...entry, path: path.resolve(location.directory, entry.path) })), result.truncated),
+        content: toModelContent6(result.entries.map((entry) => ({ ...entry, path: path.resolve(location.directory, entry.path) })), result.truncated),
         metadata: { count: result.entries.length, truncated: result.truncated }
       })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to find files matching ${input.pattern}`, error })))
     })).pipe(Effect.orDie);
   })
 };
 
-export { name, Input, Output, toModelContent, Plugin, exports_glob };
+export { name12, Input12, Output8, toModelContent6, Plugin43, exports_glob };