@opencode-ai/core 0.0.0-next-17335 → 0.0.0-next-17346

package/dist/chunks/plugin-7pgh3ep6.js

@@ -0,0 +1,286 @@
+import {
+  SessionEvent
+} from "./plugin-a83yvq99.js";
+import {
+  SessionInboxTable,
+  SessionMessageTable
+} from "./plugin-9d2xhdr4.js";
+import {
+  exports_message
+} from "./plugin-25pxtba7.js";
+import {
+  exports_schema
+} from "./plugin-y8rs54ne.js";
+import {
+  exports_keyed_mutex
+} from "./plugin-0kvmztkf.js";
+import {
+  __export
+} from "./plugin-rvfvac9x.js";
+
+// src/session/inbox.ts
+var exports_inbox = {};
+__export(exports_inbox, {
+  steer: () => steer,
+  serialized: () => serialized,
+  queue: () => queue,
+  promote: () => promote,
+  projectDeliveryChanged: () => projectDeliveryChanged,
+  projectDelivered: () => projectDelivered,
+  projectCancelled: () => projectCancelled,
+  projectAdmitted: () => projectAdmitted,
+  nextSteer: () => nextSteer,
+  nextQueued: () => nextQueued,
+  list: () => list,
+  has: () => has,
+  find: () => find,
+  equivalent: () => equivalent,
+  cancel: () => cancel,
+  admitCompaction: () => admitCompaction,
+  admit: () => admit,
+  UserPayload: () => UserPayload,
+  User: () => User,
+  SyntheticPayload: () => SyntheticPayload,
+  Synthetic: () => Synthetic,
+  SessionInbox: () => exports_inbox,
+  MovePayload: () => MovePayload,
+  Move: () => Move,
+  LifecycleConflict: () => LifecycleConflict,
+  Item: () => Item,
+  Info: () => Info,
+  Delivery: () => Delivery,
+  CompactionPayload: () => CompactionPayload,
+  Compaction: () => Compaction
+});
+import { and, asc, eq, or } from "drizzle-orm";
+import { DateTime, Effect, Schema } from "effect";
+import {
+  Compaction,
+  CompactionPayload,
+  Delivery,
+  Info,
+  Item,
+  Move,
+  MovePayload,
+  Synthetic,
+  SyntheticPayload,
+  User,
+  UserPayload
+} from "@opencode-ai/schema/session-inbox";
+var decodeUser = Schema.decodeUnknownSync(UserPayload);
+var encodeUser = Schema.encodeSync(UserPayload);
+var decodeSynthetic = Schema.decodeUnknownSync(SyntheticPayload);
+var encodeSynthetic = Schema.encodeSync(SyntheticPayload);
+var decodeCompaction = Schema.decodeUnknownSync(CompactionPayload);
+var encodeCompaction = Schema.encodeSync(CompactionPayload);
+var decodeMove = Schema.decodeUnknownSync(MovePayload);
+var encodeMove = Schema.encodeSync(MovePayload);
+var decodeMessage = Schema.decodeUnknownSync(exports_message.Info);
+var inboxLocks = exports_keyed_mutex.makeUnsafe();
+var serialized = (sessionID, effect) => inboxLocks.withLock(sessionID)(effect);
+
+class LifecycleConflict extends Schema.TaggedErrorClass()("SessionInbox.LifecycleConflict", {
+  id: exports_message.ID
+}) {
+}
+var fromRow = (row) => {
+  const base = {
+    id: exports_message.ID.make(row.id),
+    sessionID: exports_schema.ID.make(row.session_id),
+    timeCreated: DateTime.makeUnsafe(row.time_created)
+  };
+  if (row.type === "compaction")
+    return Compaction.make({
+      ...base,
+      type: "compaction",
+      payload: decodeCompaction(row.payload),
+      delivery: row.delivery
+    });
+  if (row.type === "move")
+    return Move.make({ ...base, type: "move", payload: decodeMove(row.payload), delivery: row.delivery });
+  if (row.type === "user")
+    return User.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(row.payload),
+      delivery: row.delivery
+    });
+  if (row.type === "synthetic")
+    return Synthetic.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(row.payload),
+      delivery: row.delivery
+    });
+  throw new LifecycleConflict({ id: base.id });
+};
+var find = Effect.fn("SessionInbox.find")(function* (db, id) {
+  const row = yield* db.select().from(SessionInboxTable).where(eq(SessionInboxTable.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(SessionMessageTable).where(eq(SessionMessageTable.id, id)).get().pipe(Effect.orDie);
+  if (row === undefined)
+    return;
+  if (row.session_id !== sessionID || row.type !== "user" && row.type !== "synthetic")
+    return yield* Effect.die(new LifecycleConflict({ 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 User.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(message)
+    });
+  if (message.type === "synthetic")
+    return Synthetic.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(message)
+    });
+  return yield* Effect.die(new LifecycleConflict({ id }));
+});
+var admit = Effect.fn("SessionInbox.admit")(function* (db, bus, request) {
+  const existing = yield* find(db, request.id);
+  if (existing !== undefined) {
+    if (existing.type === "compaction")
+      return yield* Effect.die(new LifecycleConflict({ id: request.id }));
+    return existing;
+  }
+  const promoted = yield* promotedFromMessage(db, request.sessionID, request.id, request.item.delivery);
+  if (promoted !== undefined)
+    return promoted;
+  return yield* bus.publish(SessionEvent.InboxEnqueued, {
+    inboxID: request.id,
+    sessionID: request.sessionID,
+    item: request.item
+  }).pipe(Effect.flatMap((event) => {
+    const base = {
+      id: request.id,
+      sessionID: request.sessionID,
+      timeCreated: event.created
+    };
+    return Effect.succeed(Info.make({ ...base, ...request.item }));
+  }), Effect.catchDefect((defect) => find(db, request.id).pipe(Effect.flatMap((stored) => stored?.type === request.item.type ? Effect.succeed(stored) : Effect.die(defect)))));
+});
+var admitCompaction = Effect.fn("SessionInbox.admitCompaction")(function* (db, bus, input) {
+  const admitted = yield* admit(db, bus, {
+    id: input.id,
+    sessionID: input.sessionID,
+    item: Item.make({ type: "compaction", payload: {}, delivery: input.delivery })
+  });
+  if (admitted.type === "compaction")
+    return admitted;
+  return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+});
+var projectAdmitted = Effect.fn("SessionInbox.projectAdmitted")(function* (db, request) {
+  const message = yield* db.select({ id: SessionMessageTable.id }).from(SessionMessageTable).where(eq(SessionMessageTable.id, request.id)).get().pipe(Effect.orDie);
+  if (message !== undefined)
+    return yield* Effect.die(new LifecycleConflict({ id: request.id }));
+  const stored = yield* db.insert(SessionInboxTable).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: DateTime.toEpochMillis(request.timeCreated)
+  }).onConflictDoNothing().returning({ id: SessionInboxTable.id }).get().pipe(Effect.orDie);
+  if (!stored)
+    return yield* Effect.die(new LifecycleConflict({ id: request.id }));
+});
+var projectDelivered = Effect.fn("SessionInbox.projectDelivered")(function* (db, input) {
+  const deleted = yield* db.delete(SessionInboxTable).where(and(eq(SessionInboxTable.id, input.id), eq(SessionInboxTable.session_id, input.sessionID))).returning().get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+  return fromRow(deleted);
+});
+var projectCancelled = Effect.fn("SessionInbox.projectCancelled")(function* (db, input) {
+  const deleted = yield* db.delete(SessionInboxTable).where(and(eq(SessionInboxTable.id, input.id), eq(SessionInboxTable.session_id, input.sessionID), or(eq(SessionInboxTable.delivery, "queue"), eq(SessionInboxTable.delivery, "steer")))).returning({ id: SessionInboxTable.id }).get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+});
+var projectDelivery = Effect.fn("SessionInbox.projectDelivery")(function* (db, input) {
+  const updated = yield* db.update(SessionInboxTable).set({ delivery: input.to }).where(and(eq(SessionInboxTable.id, input.id), eq(SessionInboxTable.session_id, input.sessionID), eq(SessionInboxTable.delivery, input.from))).returning({ id: SessionInboxTable.id }).get().pipe(Effect.orDie);
+  if (!updated)
+    return yield* Effect.die(new LifecycleConflict({ id: input.id }));
+});
+var projectDeliveryChanged = Effect.fn("SessionInbox.projectDeliveryChanged")((db, input) => projectDelivery(db, {
+  ...input,
+  from: input.delivery === "steer" ? "queue" : "steer",
+  to: input.delivery
+}));
+var list = Effect.fn("SessionInbox.list")(function* (db, sessionID) {
+  const rows = yield* db.select().from(SessionInboxTable).where(eq(SessionInboxTable.session_id, sessionID)).orderBy(asc(SessionInboxTable.enqueued_seq)).all().pipe(Effect.orDie);
+  return rows.map(fromRow);
+});
+var nextQueued = Effect.fn("SessionInbox.nextQueued")(function* (db, sessionID) {
+  const row = yield* db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "queue"))).orderBy(asc(SessionInboxTable.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
+  return row ? fromRow(row) : undefined;
+});
+var nextSteer = Effect.fn("SessionInbox.nextSteer")(function* (db, sessionID) {
+  const row = yield* db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "steer"))).orderBy(asc(SessionInboxTable.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
+  return row ? fromRow(row) : undefined;
+});
+var has = Effect.fn("SessionInbox.has")(function* (db, sessionID, scope) {
+  const row = yield* db.select({ id: SessionInboxTable.id }).from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), scope === "any" ? undefined : scope === "input" ? or(eq(SessionInboxTable.delivery, "steer"), eq(SessionInboxTable.delivery, "queue")) : eq(SessionInboxTable.delivery, scope))).limit(1).get().pipe(Effect.orDie);
+  return row !== undefined;
+});
+var equivalent = (input, expected) => {
+  if (input.type !== expected.item.type || input.delivery !== expected.item.delivery || input.sessionID !== expected.sessionID)
+    return false;
+  if (input.type === "user" && expected.item.type === "user")
+    return JSON.stringify(encodeUser(input.payload)) === JSON.stringify(encodeUser(expected.item.payload));
+  if (input.type === "synthetic" && expected.item.type === "synthetic")
+    return JSON.stringify(encodeSynthetic(input.payload)) === JSON.stringify(encodeSynthetic(expected.item.payload));
+  if (input.type === "compaction" && expected.item.type === "compaction")
+    return true;
+  if (input.type === "move" && expected.item.type === "move")
+    return JSON.stringify(encodeMove(input.payload)) === JSON.stringify(encodeMove(expected.item.payload));
+  return false;
+};
+var publishMutation = (input, effect) => serialized(input.sessionID, effect).pipe(Effect.asVoid);
+var cancel = Effect.fn("SessionInbox.cancel")((bus, input) => publishMutation(input, bus.publish(SessionEvent.InboxCancelled, {
+  sessionID: input.sessionID,
+  inboxID: input.id
+})));
+var steer = Effect.fn("SessionInbox.steer")((bus, input) => publishMutation(input, bus.publish(SessionEvent.InboxDeliveryChanged, {
+  sessionID: input.sessionID,
+  inboxID: input.id,
+  delivery: "steer"
+})));
+var queue = Effect.fn("SessionInbox.queue")((bus, input) => publishMutation(input, bus.publish(SessionEvent.InboxDeliveryChanged, {
+  sessionID: input.sessionID,
+  inboxID: input.id,
+  delivery: "queue"
+})));
+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 LifecycleConflict({ id: entry.id }));
+    return bus.publish(SessionEvent.InboxDelivered, {
+      sessionID,
+      inboxID: entry.id
+    }).pipe(Effect.catchDefect((defect) => defect instanceof LifecycleConflict ? promotedFromMessage(db, sessionID, entry.id, entry.delivery).pipe(Effect.flatMap((stored) => stored !== undefined ? Effect.void : Effect.die(defect))) : Effect.die(defect)));
+  }, { discard: true });
+  return rows.length;
+});
+var promote = Effect.fn("SessionInbox.promote")(function* (db, bus, sessionID, scope) {
+  return yield* serialized(sessionID, Effect.gen(function* () {
+    const steers = yield* db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "steer"))).orderBy(asc(SessionInboxTable.enqueued_seq)).all().pipe(Effect.orDie);
+    if (steers.length > 0 || scope === "steer") {
+      const control2 = steers.findIndex((row) => row.type === "compaction" || row.type === "move");
+      return yield* publish(db, bus, sessionID, control2 === -1 ? steers : steers.slice(0, control2));
+    }
+    const queued = yield* db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "queue"))).orderBy(asc(SessionInboxTable.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
+    if (!queued)
+      return 0;
+    const promoted = yield* publish(db, bus, sessionID, [queued]);
+    const arrivedSteers = yield* db.select().from(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "steer"))).orderBy(asc(SessionInboxTable.enqueued_seq)).all().pipe(Effect.orDie);
+    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)));
+  }));
+});
+
+export { Compaction, CompactionPayload, Delivery, Info, Item, Move, MovePayload, Synthetic, SyntheticPayload, User, UserPayload, serialized, LifecycleConflict, find, admit, admitCompaction, projectAdmitted, projectDelivered, projectCancelled, projectDeliveryChanged, list, nextQueued, nextSteer, has, equivalent, cancel, steer, queue, promote, exports_inbox };

package/dist/chunks/{app-7wcmqxrc.js → plugin-7wcmqxrc.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./plugin-rvfvac9x.js";
 
 // src/config/markdown.ts
 var exports_markdown = {};

package/dist/chunks/{app-h0cv54ja.js → plugin-80n80hmh.js}

@@ -1,12 +1,12 @@
 import {
   exports_config
-} from "./app-x621qyqy.js";
+} from "./plugin-b020en46.js";
 import {
   exports_provider
-} from "./app-d6vvk673.js";
+} from "./plugin-d6vvk673.js";
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./plugin-rvfvac9x.js";
 
 // src/config/plugin/provider.ts
 var exports_provider2 = {};

package/dist/chunks/{app-857g7h76.js → plugin-857g7h76.js}

@@ -1,6 +1,6 @@
 import {
   exports_provider
-} from "./app-d6vvk673.js";
+} from "./plugin-d6vvk673.js";
 
 // src/plugin/provider/sap-ai-core.ts
 import { Effect } from "effect";

package/dist/chunks/{app-88jbfw8z.js → plugin-88jbfw8z.js}

@@ -1,10 +1,10 @@
 import {
   absoluteArrayColumn,
   absoluteColumn
-} from "./app-zbqqnp0n.js";
+} from "./plugin-zbqqnp0n.js";
 import {
   Timestamps
-} from "./app-sem2g21k.js";
+} from "./plugin-sem2g21k.js";
 
 // src/project/sql.ts
 import { isNotNull, isNull, ne, or } from "drizzle-orm";

package/dist/chunks/{app-rr93phqw.js → plugin-890sy7db.js}

@@ -1,23 +1,23 @@
 import {
   exports_tool
-} from "./app-yz0wm9s3.js";
+} from "./plugin-yz0wm9s3.js";
 import {
   definition,
   execute,
   normalizeContent
-} from "./app-d6s8p2vk.js";
+} from "./plugin-d6s8p2vk.js";
 import {
-  exports_image
-} from "./app-00r41jbj.js";
+  exports_hooks
+} from "./plugin-t2j2ttmx.js";
 import {
   exports_wildcard
-} from "./app-y67x6rf6.js";
+} from "./plugin-y67x6rf6.js";
 import {
-  exports_hooks
-} from "./app-t2j2ttmx.js";
+  exports_image
+} from "./plugin-w60xp8cd.js";
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./plugin-rvfvac9x.js";
 
 // src/tool.ts
 var exports_tool2 = {};
@@ -28,11 +28,12 @@ __export(exports_tool2, {
   Service: () => Service,
   RegistrationError: () => RegistrationError,
   FileContent: () => FileContent,
-  Error: () => Error,
+  Error: () => Error2,
   Content: () => Content,
   CallID: () => CallID
 });
-import { CallID, Content, Error, FileContent, TextContent } from "@opencode-ai/schema/tool";
+import { CallID, Content, Error as Error2, FileContent, TextContent } from "@opencode-ai/schema/tool";
+import { ToolDefinition } from "@opencode-ai/ai";
 import { Tool } from "@opencode-ai/schema/tool";
 import { Context, Effect, Layer, Schema, Semaphore } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
@@ -140,6 +141,13 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       }));
     if (entries.length === 0)
       return;
+    yield* Effect.forEach(entries, (entry) => Effect.try({
+      try: () => ToolDefinition.make(definition(entry.tool)),
+      catch: (error) => new RegistrationError({
+        name: entry.key,
+        message: `Invalid tool definition ${entry.key}: ${error instanceof Error ? error.message : String(error)}`
+      })
+    }), { discard: true });
     yield* Effect.uninterruptible(lock.withPermit(Effect.gen(function* () {
       const token = {};
       for (const entry of entries)
@@ -220,4 +228,4 @@ var node = makeLocationNode({
   deps: [exports_hooks.node, exports_image.node]
 });
 
-export { RegistrationError, Service, node, exports_tool2 as exports_tool, CallID, Content, Error, FileContent, TextContent };
+export { RegistrationError, Service, node, exports_tool2 as exports_tool, CallID, Content, Error2 as Error, FileContent, TextContent };

package/dist/chunks/{app-8ywqk2j9.js → plugin-8ywqk2j9.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./plugin-rvfvac9x.js";
 
 // src/session/usage.ts
 var exports_usage = {};

package/dist/chunks/{app-93qdgxxd.js → plugin-93qdgxxd.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./plugin-rvfvac9x.js";
 
 // src/session/model-http.ts
 var exports_model_http = {};

package/dist/chunks/{app-qhsy44x4.js → plugin-9816vz7t.js}

@@ -1,9 +1,9 @@
 import {
   exports_integration
-} from "./app-16hvwqqz.js";
+} from "./plugin-65ezx8mc.js";
 import {
   exports_provider
-} from "./app-d6vvk673.js";
+} from "./plugin-d6vvk673.js";
 
 // src/plugin/provider/llmgateway.ts
 import { Effect } from "effect";

package/dist/chunks/{app-999qd968.js → plugin-999qd968.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./plugin-rvfvac9x.js";
 
 // src/v1/config/lsp.ts
 var exports_lsp = {};

package/dist/chunks/{app-zvvp2xr4.js → plugin-9d2xhdr4.js}

@@ -1,13 +1,13 @@
 import {
   ProjectTable
-} from "./app-88jbfw8z.js";
+} from "./plugin-88jbfw8z.js";
 import {
   directoryColumn,
   pathColumn
-} from "./app-zbqqnp0n.js";
+} from "./plugin-zbqqnp0n.js";
 import {
   Timestamps
-} from "./app-sem2g21k.js";
+} from "./plugin-sem2g21k.js";
 
 // src/session/sql.ts
 import { sqliteTable, text, integer, index, primaryKey, real, uniqueIndex } from "drizzle-orm/sqlite-core";
@@ -77,6 +77,18 @@ var SessionPendingTable = sqliteTable("session_pending", {
   uniqueIndex("session_pending_session_compaction_idx").on(table.session_id).where(sql`${table.type} = 'compaction'`),
   uniqueIndex("session_pending_session_admitted_seq_idx").on(table.session_id, table.admitted_seq)
 ]);
+var SessionInboxTable = sqliteTable("session_inbox", {
+  id: text().$type().primaryKey(),
+  session_id: text().$type().notNull().references(() => SessionTable.id, { onDelete: "cascade" }),
+  type: text().$type().notNull(),
+  payload: text({ mode: "json" }).$type().notNull(),
+  delivery: text().$type().notNull(),
+  enqueued_seq: integer().notNull(),
+  time_created: integer().notNull().$default(() => Date.now())
+}, (table) => [
+  index("session_inbox_session_delivery_seq_idx").on(table.session_id, table.delivery, table.enqueued_seq),
+  uniqueIndex("session_inbox_session_enqueued_seq_idx").on(table.session_id, table.enqueued_seq)
+]);
 var InstructionEntryTable = sqliteTable("instruction_entry", {
   session_id: text().$type().notNull().references(() => SessionTable.id, { onDelete: "cascade" }),
   key: text().notNull(),
@@ -96,4 +108,4 @@ var InstructionStateTable = sqliteTable("instruction_state", {
   current_values: text({ mode: "json" }).notNull().$type()
 });
 
-export { SessionTable, SessionMessageTable, SessionPendingTable, InstructionEntryTable, InstructionBlobTable, InstructionStateTable };
+export { SessionTable, SessionMessageTable, SessionPendingTable, SessionInboxTable, InstructionEntryTable, InstructionBlobTable, InstructionStateTable };

package/dist/chunks/{app-9f0rnpkn.js → plugin-9f0rnpkn.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./plugin-rvfvac9x.js";
 
 // src/v1/config/plugin.ts
 var exports_plugin = {};

package/dist/chunks/{app-9q1hedyj.js → plugin-9q1hedyj.js}

@@ -1,9 +1,9 @@
 import {
   exports_usage
-} from "./app-8ywqk2j9.js";
+} from "./plugin-8ywqk2j9.js";
 import {
   SessionEvent
-} from "./app-a83yvq99.js";
+} from "./plugin-a83yvq99.js";
 
 // src/session/runner/publish-llm-event.ts
 import { Effect } from "effect";

package/dist/chunks/{app-9r0qzhnf.js → plugin-9r0qzhnf.js}

@@ -1,9 +1,9 @@
 import {
   exports_provider
-} from "./app-d6vvk673.js";
+} from "./plugin-d6vvk673.js";
 import {
   __require
-} from "./app-rvfvac9x.js";
+} from "./plugin-rvfvac9x.js";
 
 // src/plugin/provider/vercel.ts
 import { Effect } from "effect";

package/dist/chunks/{app-eyz27an3.js → plugin-9tf9cx6w.js}

@@ -1,60 +1,60 @@
 import {
   exports_instruction_entry
-} from "./app-jee929nm.js";
+} from "./plugin-abs4hrf7.js";
 import {
-  exports_instructions as exports_instructions3
-} from "./app-tyh0a1hs.js";
+  exports_supervisor
+} from "./plugin-0fc9cerp.js";
 import {
-  exports_builtins
-} from "./app-k1fd56f5.js";
+  exports_instructions as exports_instructions2
+} from "./plugin-mgdg92mf.js";
+import {
+  exports_instructions as exports_instructions3
+} from "./plugin-tyh0a1hs.js";
 import {
   exports_instructions as exports_instructions4
-} from "./app-swj91yr9.js";
+} from "./plugin-f7e4a9yp.js";
 import {
   exports_mcp
-} from "./app-a6wcc54f.js";
-import {
-  exports_instructions as exports_instructions2
-} from "./app-3ep6e3ar.js";
+} from "./plugin-ba49gtzz.js";
 import {
   exports_instructions as exports_instructions5
-} from "./app-gq874kak.js";
-import {
-  exports_supervisor
-} from "./app-65jpn00m.js";
+} from "./plugin-1r5g0chd.js";
 import {
-  exports_model
-} from "./app-gfkf25t4.js";
+  exports_builtins
+} from "./plugin-rp0ghwk5.js";
 import {
   exports_instruction_discovery
-} from "./app-6mhfmmqr.js";
+} from "./plugin-stbhjv87.js";
 import {
   exports_tool
-} from "./app-rr93phqw.js";
+} from "./plugin-890sy7db.js";
+import {
+  exports_model
+} from "./plugin-a2ta2hx3.js";
 import {
   exports_store
-} from "./app-qbcccd0j.js";
+} from "./plugin-t2x6yxj4.js";
 import {
   exports_history
-} from "./app-07879qbe.js";
+} from "./plugin-vsfj499p.js";
 import {
   AgentNotFoundError
-} from "./app-s6by3cc4.js";
-import {
-  exports_agent
-} from "./app-nkhdtsyw.js";
+} from "./plugin-s6by3cc4.js";
 import {
   exports_instructions
-} from "./app-q4r4pzs4.js";
+} from "./plugin-q4r4pzs4.js";
+import {
+  exports_agent
+} from "./plugin-n57t1s0k.js";
 import {
   exports_location
-} from "./app-x8422b88.js";
+} from "./plugin-4kb49531.js";
 import {
   exports_database
-} from "./app-8ccp6vnz.js";
+} from "./plugin-2er1z1cy.js";
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./plugin-rvfvac9x.js";
 
 // src/session/context.ts
 var exports_context = {};

package/dist/chunks/{app-y3fchm6z.js → plugin-9xx5a70w.js}

@@ -1,15 +1,15 @@
 import {
   PermissionTable
-} from "./app-nesb2rcz.js";
+} from "./plugin-nesb2rcz.js";
 import {
   exports_project
-} from "./app-3wtzjxz9.js";
+} from "./plugin-k7z41gkz.js";
 import {
   exports_database
-} from "./app-8ccp6vnz.js";
+} from "./plugin-2er1z1cy.js";
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./plugin-rvfvac9x.js";
 
 // src/permission/saved.ts
 var exports_saved = {};

package/dist/chunks/{app-7enhmwwz.js → plugin-a027tm0y.js}

@@ -1,19 +1,19 @@
 import {
   exports_protected
-} from "./app-kg1345f7.js";
+} from "./plugin-kg1345f7.js";
 import {
   exports_ripgrep
-} from "./app-fky33s4r.js";
+} from "./plugin-wjk1568y.js";
 import {
   exports_location
-} from "./app-x8422b88.js";
+} from "./plugin-4kb49531.js";
 import {
   PositiveInt,
   RelativePath
-} from "./app-j07kk359.js";
+} from "./plugin-j07kk359.js";
 import {
   __export
-} from "./app-rvfvac9x.js";
+} from "./plugin-rvfvac9x.js";
 
 // src/filesystem/search.ts
 var exports_search = {};