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

package/dist/chunks/{schema-k8b45nas.js → event-logger-emrn6kk6.js}

@@ -7,13 +7,13 @@ import { Subquery } from "drizzle-orm/subquery";
 import { Table, getTableName } from "drizzle-orm/table";
 import { ViewBaseConfig } from "drizzle-orm/view-common";
 var TableSymbol = Table.Symbol;
-function getTableColumnsRuntime(table) {
+function getTableColumnsRuntime2(table) {
   return table[TableSymbol.Columns];
 }
-function getViewSelectedFieldsRuntime(view) {
+function getViewSelectedFieldsRuntime2(view) {
   return view[ViewBaseConfig];
 }
-function jitCompatCheck(isEnabled) {
+function jitCompatCheck2(isEnabled) {
   if (!isEnabled)
     return false;
   try {
@@ -22,7 +22,7 @@ function jitCompatCheck(isEnabled) {
     return false;
   }
 }
-function orderSelectedFields(fields, pathPrefix) {
+function orderSelectedFields2(fields, pathPrefix) {
   return Object.entries(fields).flatMap(([name, field]) => {
     const path = pathPrefix ? [...pathPrefix, name] : [name];
     if (is(field, Column))
@@ -34,11 +34,11 @@ function orderSelectedFields(fields, pathPrefix) {
     if (is(field, Subquery))
       return [{ path, field, fieldType: "Subquery" }];
     if (is(field, Table))
-      return orderSelectedFields(getTableColumnsRuntime(field), path);
-    return orderSelectedFields(field, path);
+      return orderSelectedFields2(getTableColumnsRuntime2(field), path);
+    return orderSelectedFields2(field, path);
   });
 }
-function resolveNullableObjectPaths(columns, joinsNotNullableMap) {
+function resolveNullableObjectPaths2(columns, joinsNotNullableMap) {
   if (!joinsNotNullableMap)
     return;
   const tableOf = columns.filter((column) => column.path.length > 1 && column.fieldType === "Column").reduce((result, column) => {
@@ -50,16 +50,16 @@ function resolveNullableObjectPaths(columns, joinsNotNullableMap) {
   }, {});
   return Object.entries(tableOf).filter(([, tableName]) => typeof tableName === "string" && !joinsNotNullableMap[tableName]).map(([key]) => key);
 }
-function mapUpdateSet(table, values) {
+function mapUpdateSet2(table, values) {
   const entries = Object.entries(values).filter(([, value]) => value !== undefined);
   if (entries.length === 0)
     throw new Error("No values to set");
   return Object.fromEntries(entries.map(([key, value]) => [
     key,
-    is(value, SQL) || is(value, Column) ? value : new Param(value, getTableColumnsRuntime(table)[key])
+    is(value, SQL) || is(value, Column) ? value : new Param(value, getTableColumnsRuntime2(table)[key])
   ]));
 }
-function mapResultRow(columns, row, joinsNotNullableMap) {
+function mapResultRow2(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = {};
   columns.forEach((column, columnIndex) => {
@@ -87,14 +87,14 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
   });
   return result;
 }
-function getTableLikeName(table) {
+function getTableLikeName2(table) {
   if (is(table, Subquery))
     return table._.alias;
   if (is(table, SQLiteViewBase))
-    return getViewSelectedFieldsRuntime(table).name;
+    return getViewSelectedFieldsRuntime2(table).name;
   if (is(table, SQL))
     return;
   return table[table[TableSymbol.IsAlias] ? TableSymbol.Name : TableSymbol.BaseName];
 }
 
-export { getTableColumnsRuntime, getViewSelectedFieldsRuntime, jitCompatCheck, orderSelectedFields, resolveNullableObjectPaths, mapUpdateSet, mapResultRow, getTableLikeName };
+export { getTableColumnsRuntime2, getViewSelectedFieldsRuntime2, jitCompatCheck2, orderSelectedFields2, resolveNullableObjectPaths2, mapUpdateSet2, mapResultRow2, getTableLikeName2 };

package/dist/chunks/{schema-dkkkrjgz.js → event-logger-erw4kpzp.js}

@@ -1,15 +1,15 @@
 import {
-  exports_environment1 as exports_environment
-} from "./schema-qa1y9c59.js";
+  Service65
+} from "./event-logger-22drdanb.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/mcp/stdio.ts
 var exports_stdio = {};
 __export(exports_stdio, {
   McpStdio: () => exports_stdio,
-  make: () => make
+  make: () => make2
 });
 import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
 import { Cause, Duration, Effect, Queue, Scope, Stream } from "effect";
@@ -18,8 +18,8 @@ var CLOSE_GRACE = Duration.seconds(2);
 var FORCE_KILL_AFTER = Duration.seconds(2);
 var OUTGOING_CAPACITY = 64;
 var MAX_FRAME_BYTES = 16 * 1024 * 1024;
-var make = Effect.fnUntraced(function* (options) {
-  const environment = yield* exports_environment.Service;
+var make2 = Effect.fnUntraced(function* (options) {
+  const environment = yield* Service65;
   const scope = yield* Effect.scope;
   const outgoing = yield* Queue.bounded(OUTGOING_CAPACITY);
   const buffer = new ReadBuffer;
@@ -111,4 +111,4 @@ var make = Effect.fnUntraced(function* (options) {
   return transport;
 });
 
-export { make, exports_stdio };
+export { make2, exports_stdio };

package/dist/chunks/{schema-zwp7atcb.js → event-logger-f03pjn97.js}

@@ -1,25 +1,33 @@
 import {
-  exports_skill
-} from "./schema-tbzs2pmr.js";
+  Key4,
+  removed2,
+  empty3,
+  make20,
+  diffByKey2
+} from "./event-logger-1z80kc63.js";
 import {
-  exports_instructions
-} from "./schema-c54e84vp.js";
+  ID6,
+  Name2,
+  available2,
+  Service56,
+  node59
+} from "./event-logger-28nhnrpr.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/skill/instructions.ts
-var exports_instructions2 = {};
-__export(exports_instructions2, {
-  Service: () => Service,
-  SkillInstructions: () => exports_instructions2,
-  node: () => node
+var exports_instructions5 = {};
+__export(exports_instructions5, {
+  Service: () => Service35,
+  SkillInstructions: () => exports_instructions5,
+  node: () => node38
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
 var Summary = Schema.Struct({
-  id: exports_skill.ID,
-  name: exports_skill.Name,
+  id: ID6,
+  name: Name2,
   description: Schema.String
 });
 var entries = (skills) => skills.flatMap((skill) => [
@@ -36,7 +44,7 @@ var render = (skills) => [
 ].join(`
 `);
 var update = (previous, current) => {
-  const diff = exports_instructions.diffByKey(previous, current, (skill) => skill.id, (before, after) => before.name !== after.name || before.description !== after.description);
+  const diff = diffByKey2(previous, current, (skill) => skill.id, (before, after) => before.name !== after.name || before.description !== after.description);
   if (diff.changed.length > 0 || diff.added.length === 0 && diff.removed.length === 0)
     return [
       "The available skills have changed. This list supersedes the previous available skills list.",
@@ -52,20 +60,20 @@ var update = (previous, current) => {
 `);
 };
 
-class Service extends Context.Service()("@opencode/SkillInstructions") {
+class Service35 extends Context.Service()("@opencode/SkillInstructions") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const skills = yield* exports_skill.Service;
-  return Service.of({
+var layer = Layer.effect(Service35, Effect.gen(function* () {
+  const skills = yield* Service56;
+  return Service35.of({
     load: Effect.fn("SkillInstructions.load")(function* (selection) {
       const agent = selection.info;
       if (!agent)
-        return exports_instructions.empty;
-      const available = exports_skill.available(yield* skills.list(), agent).flatMap((skill) => skill.description === undefined || skill.autoinvoke === false ? [] : [{ id: skill.id, name: skill.name, description: skill.description }]).toSorted((a, b) => a.id.localeCompare(b.id));
-      return exports_instructions.make({
-        key: exports_instructions.Key.make("core/skill-guidance"),
+        return empty3;
+      const available = available2(yield* skills.list(), agent).flatMap((skill) => skill.description === undefined || skill.autoinvoke === false ? [] : [{ id: skill.id, name: skill.name, description: skill.description }]).toSorted((a, b) => a.id.localeCompare(b.id));
+      return make20({
+        key: Key4.make("core/skill-guidance"),
         codec: Schema.toCodecJson(Schema.Array(Summary)),
-        read: Effect.succeed(available.length === 0 ? exports_instructions.removed : available),
+        read: Effect.succeed(available.length === 0 ? removed2 : available),
         render: {
           initial: render,
           changed: update,
@@ -75,6 +83,6 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     })
   });
 }));
-var node = makeLocationNode({ service: Service, layer, deps: [exports_skill.node] });
+var node38 = makeLocationNode({ service: Service35, layer, deps: [node59] });
 
-export { Service, node, exports_instructions2 as exports_instructions };
+export { Service35, node38, exports_instructions5 };

package/dist/chunks/{schema-0f48qthw.js → event-logger-f0mxakyp.js}

@@ -9,7 +9,7 @@ function buildSQLiteCount(source, filters) {
   return sql`select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters}`;
 }
 
-class SQLiteEffectCountBuilder extends SQL {
+class SQLiteEffectCountBuilder2 extends SQL {
   static [entityKind] = "SQLiteEffectCountBuilder";
   sql;
   session;
@@ -27,6 +27,6 @@ class SQLiteEffectCountBuilder extends SQL {
     }).execute(placeholderValues);
   }
 }
-applyEffectWrapper(SQLiteEffectCountBuilder);
+applyEffectWrapper(SQLiteEffectCountBuilder2);
 
-export { SQLiteEffectCountBuilder };
+export { SQLiteEffectCountBuilder2 };

package/dist/chunks/{schema-q1h731cc.js → event-logger-f4kct4fj.js}

@@ -1,176 +1,190 @@
 import {
-  exports_generate
-} from "./schema-5djqxq12.js";
+  ID15,
+  Info28,
+  SessionSchema2
+} from "./event-logger-mq9r6drf.js";
 import {
-  DestinationNotDirectoryError,
-  DestinationNotFoundError,
-  DestinationUnavailableError,
-  exports_move
-} from "./schema-axwdyrw6.js";
+  RelativePath2
+} from "./event-logger-p8qxwesx.js";
 import {
-  exports_projector
-} from "./schema-a6mq1kfm.js";
+  Service80,
+  node85
+} from "./event-logger-4vtp7hga.js";
 import {
-  exports_command
-} from "./schema-jrpamtww.js";
+  isSynced2,
+  Service79,
+  node84
+} from "./event-logger-jbmjz4v3.js";
 import {
-  exports_session
-} from "./schema-4hbpra3r.js";
+  Service76,
+  node81
+} from "./event-logger-kfyw9f0s.js";
 import {
-  exports_execution
-} from "./schema-r9srg7kj.js";
+  Service33,
+  node36
+} from "./event-logger-yhtqjkzd.js";
 import {
-  exports_inbox
-} from "./schema-3rcd4hwd.js";
+  SessionEvent2
+} from "./event-logger-mntxs535.js";
 import {
-  exports_model_transport
-} from "./schema-rpa95wsa.js";
+  SessionMessageTable2
+} from "./event-logger-hrvm11jt.js";
 import {
-  exports_instruction_entry
-} from "./schema-p0ye3rhn.js";
+  node33
+} from "./event-logger-aymbgepw.js";
 import {
-  exports_service
-} from "./schema-6bxzghb6.js";
+  current2
+} from "./event-logger-9969c03r.js";
 import {
-  llmClient
-} from "./schema-326j4s6w.js";
+  snapshot2
+} from "./event-logger-92g85qkt.js";
 import {
-  exports_job
-} from "./schema-dt5yw4ma.js";
+  Slug2
+} from "./event-logger-gebd4c9n.js";
 import {
-  exports_store
-} from "./schema-a4wk7wxx.js";
+  SessionAlreadyProjected2,
+  node29
+} from "./event-logger-df0c2mh7.js";
 import {
-  AttachmentError,
-  BusyError,
-  CompactionConflictError,
-  ForkEmptyError,
-  InboxConflictError,
-  MessageDecodeError,
-  MessageIncompleteError,
-  MessageNotAssistantError,
-  MessageNotFoundError,
-  MessageToolIncompleteError,
-  NotFoundError,
-  PromptConflictError,
-  SkillNotFoundError,
-  SyntheticConflictError
-} from "./schema-2sqw2jjm.js";
+  Metadata2,
+  node62
+} from "./event-logger-fd84j5ds.js";
 import {
-  exports_instruction_state
-} from "./schema-8c5xq4gn.js";
+  NotFoundError9,
+  MessageNotFoundError2,
+  MessageNotAssistantError2,
+  MessageIncompleteError2,
+  MessageToolIncompleteError2,
+  ForkEmptyError2,
+  MessageDecodeError2,
+  PromptConflictError2,
+  SyntheticConflictError2,
+  AttachmentError2,
+  CompactionConflictError2,
+  BusyError2,
+  InboxConflictError2,
+  SkillNotFoundError2
+} from "./event-logger-n6wnzfnt.js";
 import {
-  SessionMessageTable
-} from "./schema-q606pcse.js";
+  ListInput4,
+  Service72,
+  node77
+} from "./event-logger-xf2wyvfy.js";
 import {
-  SessionEvent
-} from "./schema-a83yvq99.js";
+  Service44,
+  node47
+} from "./event-logger-c2khgprk.js";
 import {
-  Slug
-} from "./schema-df3v2q6j.js";
+  Service27,
+  node32
+} from "./event-logger-65rxya3j.js";
 import {
-  exports_app
-} from "./schema-hs51b0fc.js";
+  llmClient2
+} from "./event-logger-0e0xafbb.js";
 import {
-  exports_environment
-} from "./schema-zn935gjz.js";
+  Service39,
+  node42
+} from "./event-logger-082zmtg6.js";
 import {
-  ID,
-  Info,
-  SessionSchema
-} from "./schema-bjwj8hwv.js";
+  generate3
+} from "./event-logger-31rwmws4.js";
 import {
-  exports_project
-} from "./schema-2g4twk0n.js";
+  execute2
+} from "./event-logger-x6bh0d7a.js";
 import {
-  RelativePath
-} from "./schema-j07kk359.js";
+  DestinationNotFoundError2,
+  DestinationNotDirectoryError2,
+  DestinationUnavailableError2,
+  Service24,
+  node28
+} from "./event-logger-9s6t48vc.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  Service47,
+  node50
+} from "./event-logger-wf1mfr52.js";
 import {
-  exports_database
-} from "./schema-8scqw7rh.js";
+  make12
+} from "./event-logger-2h6s9956.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/session.ts
-var exports_session2 = {};
-__export(exports_session2, {
-  AttachmentError: () => AttachmentError,
-  BusyError: () => BusyError,
-  CompactionConflictError: () => CompactionConflictError,
-  DestinationNotDirectoryError: () => DestinationNotDirectoryError,
-  DestinationNotFoundError: () => DestinationNotFoundError,
-  DestinationUnavailableError: () => DestinationUnavailableError,
-  ID: () => ID,
-  InboxConflictError: () => InboxConflictError,
-  Info: () => Info,
-  ListAnchor: () => ListAnchor,
-  ListInput: () => ListInput,
-  MessageDecodeError: () => MessageDecodeError,
-  MessageIncompleteError: () => MessageIncompleteError,
-  MessageNotAssistantError: () => MessageNotAssistantError,
-  MessageNotFoundError: () => MessageNotFoundError,
-  MessageToolIncompleteError: () => MessageToolIncompleteError,
-  NotFoundError: () => NotFoundError,
-  PromptConflictError: () => PromptConflictError,
-  Service: () => Service,
-  Session: () => exports_session2,
-  SessionSchema: () => SessionSchema,
-  SkillNotFoundError: () => SkillNotFoundError,
-  SyntheticConflictError: () => SyntheticConflictError,
-  node: () => node
+var exports_session = {};
+__export(exports_session, {
+  AttachmentError: () => AttachmentError2,
+  BusyError: () => BusyError2,
+  CompactionConflictError: () => CompactionConflictError2,
+  DestinationNotDirectoryError: () => DestinationNotDirectoryError2,
+  DestinationNotFoundError: () => DestinationNotFoundError2,
+  DestinationUnavailableError: () => DestinationUnavailableError2,
+  ID: () => ID15,
+  InboxConflictError: () => InboxConflictError2,
+  Info: () => Info28,
+  ListAnchor: () => ListAnchor2,
+  ListInput: () => ListInput3,
+  MessageDecodeError: () => MessageDecodeError2,
+  MessageIncompleteError: () => MessageIncompleteError2,
+  MessageNotAssistantError: () => MessageNotAssistantError2,
+  MessageNotFoundError: () => MessageNotFoundError2,
+  MessageToolIncompleteError: () => MessageToolIncompleteError2,
+  NotFoundError: () => NotFoundError9,
+  PromptConflictError: () => PromptConflictError2,
+  Service: () => Service23,
+  Session: () => exports_session,
+  SessionSchema: () => SessionSchema2,
+  SkillNotFoundError: () => SkillNotFoundError2,
+  SyntheticConflictError: () => SyntheticConflictError2,
+  node: () => node27
 });
 import { Effect, Layer, Schema, Context, Stream } from "effect";
 import { LLMClient } from "@opencode-ai/ai";
-import { ListAnchor } from "@opencode-ai/schema/session";
+import { ListAnchor as ListAnchor2 } from "@opencode-ai/schema/session";
 import { and, desc, eq } from "drizzle-orm";
 import { Model } from "@opencode-ai/schema/model";
 import path from "path";
 import { Node } from "@opencode-ai/util/effect/app-node";
 import { FSUtil } from "@opencode-ai/util/fs-util";
-var ListInput = exports_store.ListInput;
-class Service extends Context.Service()("@opencode/Session") {
+var ListInput3 = ListInput4;
+class Service23 extends Context.Service()("@opencode/Session") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const app = yield* exports_app.Metadata;
-  const database = yield* exports_database.Service;
+var layer = Layer.effect(Service23, Effect.gen(function* () {
+  const app = yield* Metadata2;
+  const database = yield* Service80;
   const db = database.db;
-  const bus = yield* exports_bus.Service;
-  const projects = yield* exports_project.Service;
-  const execution = yield* exports_execution.Service;
+  const bus = yield* Service79;
+  const projects = yield* Service76;
+  const execution = yield* Service27;
   const llm = yield* LLMClient.Service;
-  const transport = yield* exports_model_transport.Service;
-  const store = yield* exports_store.Service;
-  const instances = yield* exports_service.Service;
-  const moves = yield* exports_move.Service;
-  const jobs = yield* exports_job.Service;
-  const environments = yield* exports_environment.Service;
-  const sessions = yield* exports_session.make();
-  const isDurableSessionEvent = Schema.is(SessionEvent.Durable);
-  const result = Service.of({
+  const transport = yield* Service39;
+  const store = yield* Service72;
+  const instances = yield* Service33;
+  const moves = yield* Service24;
+  const jobs = yield* Service44;
+  const environments = yield* Service47;
+  const sessions = yield* make12();
+  const isDurableSessionEvent = Schema.is(SessionEvent2.Durable);
+  const result = Service23.of({
     create: Effect.fn("Session.create")(function* (input) {
-      const sessionID = input.id ?? SessionSchema.ID.create();
+      const sessionID = input.id ?? SessionSchema2.ID.create();
       const recorded = yield* store.get(sessionID);
       if (recorded)
         return recorded;
       const parent = input.parentID ? yield* store.get(input.parentID) : undefined;
       if (input.parentID && parent === undefined)
-        return yield* new NotFoundError({ sessionID: input.parentID });
+        return yield* new NotFoundError9({ sessionID: input.parentID });
       const location = parent?.location ?? input.location;
       if (location === undefined)
         return yield* Effect.die(new Error("Session.create requires either location or an existing parentID"));
       const project = yield* projects.resolve(location.directory);
-      const projected = yield* bus.publish(SessionEvent.Created, {
+      const projected = yield* bus.publish(SessionEvent2.Created, {
         sessionID,
-        slug: Slug.create(),
+        slug: Slug2.create(),
         version: app.version,
         projectID: project.id,
         parentID: input.parentID,
         location,
-        subpath: RelativePath.make(path.relative(project.directory, location.directory).replaceAll("\\", "/")),
+        subpath: RelativePath2.make(path.relative(project.directory, location.directory).replaceAll("\\", "/")),
         title: input.title,
         agent: input.agent,
         metadata: input.metadata ?? parent?.metadata,
@@ -180,7 +194,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           variant: input.model.variant
         } : undefined
       }, { location }).pipe(Effect.as({ type: "created" }), Effect.catchDefect((defect) => {
-        if (!(defect instanceof exports_projector.SessionAlreadyProjected)) {
+        if (!(defect instanceof SessionAlreadyProjected2)) {
           return Effect.die(defect);
         }
         return store.get(sessionID).pipe(Effect.flatMap((session) => session ? Effect.succeed({ type: "existing", session }) : Effect.die(defect)));
@@ -191,20 +205,20 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     }),
     fork: Effect.fn("Session.fork")(function* (input) {
       const parent = yield* result.get(input.sessionID);
-      const boundary = yield* db.select({ id: SessionMessageTable.id }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, input.sessionID), input.boundary.type === "before" ? eq(SessionMessageTable.id, input.boundary.messageID) : undefined)).orderBy(desc(SessionMessageTable.seq)).limit(1).get().pipe(Effect.orDie);
+      const boundary = yield* db.select({ id: SessionMessageTable2.id }).from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, input.sessionID), input.boundary.type === "before" ? eq(SessionMessageTable2.id, input.boundary.messageID) : undefined)).orderBy(desc(SessionMessageTable2.seq)).limit(1).get().pipe(Effect.orDie);
       if (!boundary && input.boundary.type === "before")
-        return yield* new MessageNotFoundError({
+        return yield* new MessageNotFoundError2({
           sessionID: input.sessionID,
           messageID: input.boundary.messageID
         });
       if (!boundary)
-        return yield* new ForkEmptyError({ sessionID: input.sessionID });
-      const sessionID = SessionSchema.ID.create();
+        return yield* new ForkEmptyError2({ sessionID: input.sessionID });
+      const sessionID = SessionSchema2.ID.create();
       const inherited = yield* db.transaction(() => Effect.all({
-        instructions: exports_instruction_state.current(db, parent.id),
-        instructionEntries: exports_instruction_entry.snapshot(db, parent.id)
+        instructions: current2(db, parent.id),
+        instructionEntries: snapshot2(db, parent.id)
       })).pipe(Effect.orDie);
-      yield* bus.publish(SessionEvent.Forked, {
+      yield* bus.publish(SessionEvent2.Forked, {
         sessionID,
         parentID: parent.id,
         boundary: { ...input.boundary, messageID: boundary.id },
@@ -228,7 +242,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const children = yield* result.list({ parentID: sessionID });
       yield* Effect.forEach(children.data, (child) => result.remove(child.id), { concurrency: 1, discard: true });
       yield* environments.clear(sessionID);
-      yield* bus.publish(SessionEvent.Deleted, { sessionID });
+      yield* bus.publish(SessionEvent2.Deleted, { sessionID });
       yield* bus.remove(sessionID);
     }),
     list: Effect.fn("Session.list")(function* (input) {
@@ -248,15 +262,15 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     cancelInbox: (input) => sessions.forSession(input.sessionID).cancelInbox(input.inboxID),
     steerInbox: (input) => sessions.forSession(input.sessionID).steerInbox(input.inboxID),
     queueInbox: (input) => sessions.forSession(input.sessionID).queueInbox(input.inboxID),
-    log: (input) => Stream.unwrap(result.get(input.sessionID).pipe(Effect.as(bus.log({ aggregateID: input.sessionID, after: input.after, follow: input.follow })))).pipe(Stream.filter((item) => exports_bus.isSynced(item) || isDurableSessionEvent(item))),
+    log: (input) => Stream.unwrap(result.get(input.sessionID).pipe(Effect.as(bus.log({ aggregateID: input.sessionID, after: input.after, follow: input.follow })))).pipe(Stream.filter((item) => isSynced2(item) || isDurableSessionEvent(item))),
     prompt: (input) => sessions.forSession(input.sessionID).prompt(input),
     generate: Effect.fn("Session.generate")(function* (input) {
       const session = yield* result.get(input.sessionID);
-      return yield* exports_generate.generate({ session, prompt: input.prompt }).pipe(Effect.provideService(exports_service.Service, instances), Effect.provideService(exports_database.Service, database), Effect.provideService(LLMClient.Service, llm));
+      return yield* generate3({ session, prompt: input.prompt }).pipe(Effect.provideService(Service33, instances), Effect.provideService(Service80, database), Effect.provideService(LLMClient.Service, llm));
     }),
     command: Effect.fn("Session.command")(function* (input) {
       const session = yield* result.get(input.sessionID);
-      return yield* exports_command.execute({ ...input, session }).pipe(Effect.provideService(exports_service.Service, instances));
+      return yield* execute2({ ...input, session }).pipe(Effect.provideService(Service33, instances));
     }),
     shell: (input) => sessions.forSession(input.sessionID).shell(input),
     skill: (input) => sessions.forSession(input.sessionID).skill(input),
@@ -296,26 +310,26 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
   return result;
 }));
-var node = Node.makeGlobalNode({
-  service: Service,
+var node27 = Node.makeGlobalNode({
+  service: Service23,
   layer,
   deps: [
-    exports_job.node,
-    exports_environment.node,
-    exports_database.node,
-    exports_bus.node,
-    exports_project.node,
-    exports_execution.node,
-    exports_model_transport.node,
-    llmClient,
-    exports_store.node,
-    exports_service.node,
-    exports_inbox.node,
-    exports_move.node,
-    exports_projector.node,
+    node47,
+    node50,
+    node85,
+    node84,
+    node81,
+    node32,
+    node42,
+    llmClient2,
+    node77,
+    node36,
+    node33,
+    node28,
+    node29,
     FSUtil.node,
-    exports_app.node
+    node62
   ]
 });
 
-export { ListAnchor, ListInput, Service, node, exports_session2 as exports_session };
+export { ListAnchor2, ListInput3, Service23, node27, exports_session };

package/dist/chunks/{schema-61ek4hj9.js → event-logger-faypxj3z.js}

@@ -1,6 +1,6 @@
 // src/workspace/sql.ts
 import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
-var WorkspaceTable = sqliteTable("workspace", {
+var WorkspaceTable2 = sqliteTable("workspace", {
   id: text().$type().primaryKey(),
   provider: text().notNull(),
   binding: text({ mode: "json" }).$type(),
@@ -8,4 +8,4 @@ var WorkspaceTable = sqliteTable("workspace", {
   last_used_at: integer().notNull()
 });
 
-export { WorkspaceTable };
+export { WorkspaceTable2 };