@opencode-ai/core 0.0.0-dev-18673 → 0.0.0-dev-18680

package/dist/chunks/job-k3b93ktv.js

@@ -1,909 +0,0 @@
-import {
-  exports_supervisor_service
-} from "./job-s33fw6zm.js";
-import {
-  exports_revert
-} from "./job-x7z7742t.js";
-import {
-  exports_execution
-} from "./job-xes8c7na.js";
-import {
-  exports_generate
-} from "./job-xgv25zxy.js";
-import {
-  exports_projector
-} from "./job-dv3yagct.js";
-import {
-  exports_instruction_entry
-} from "./job-0j6yxnr1.js";
-import {
-  exports_inbox
-} from "./job-ecft2zb7.js";
-import {
-  exports_model_transport
-} from "./job-tjrfm0xh.js";
-import {
-  exports_shell
-} from "./job-c48kc6fa.js";
-import {
-  exports_result
-} from "./job-etvrgfqj.js";
-import {
-  exports_environment
-} from "./job-6ky7rqk7.js";
-import {
-  Slug
-} from "./job-df3v2q6j.js";
-import {
-  exports_skill
-} from "./job-sqzywsbq.js";
-import {
-  exports_command
-} from "./job-d64twz5j.js";
-import {
-  exports_app
-} from "./job-50jxp3hw.js";
-import {
-  exports_location_service_map
-} from "./job-zdkg1k91.js";
-import {
-  exports_store
-} from "./job-wvmyfgqa.js";
-import {
-  exports_history
-} from "./job-ngrdkqab.js";
-import {
-  fromRow
-} from "./job-264e1nfp.js";
-import {
-  exports_instruction_state
-} from "./job-hxcd35r2.js";
-import {
-  ForkEmptyError,
-  MessageDecodeError,
-  NotFoundError
-} from "./job-fb7nfzf2.js";
-import {
-  SessionMessageTable,
-  SessionTable
-} from "./job-q606pcse.js";
-import {
-  exports_hooks
-} from "./job-v2wshkax.js";
-import {
-  exports_image
-} from "./job-ryg4g4zw.js";
-import {
-  SessionEvent
-} from "./job-a83yvq99.js";
-import {
-  exports_job
-} from "./job-2hnk029s.js";
-import {
-  SessionMessage
-} from "./job-8rpfd2h6.js";
-import {
-  ID,
-  Info,
-  SessionSchema
-} from "./job-bjwj8hwv.js";
-import {
-  exports_mime
-} from "./job-dhphtf1x.js";
-import {
-  exports_location
-} from "./job-knm8yv8d.js";
-import {
-  exports_project
-} from "./job-9qkcnssy.js";
-import {
-  upsertProject
-} from "./job-c8ya26sa.js";
-import {
-  exports_bus
-} from "./job-j925pnyr.js";
-import {
-  exports_database
-} from "./job-rp954h3j.js";
-import {
-  AbsolutePath,
-  PositiveInt,
-  RelativePath
-} from "./job-j07kk359.js";
-import {
-  __export
-} from "./job-rvfvac9x.js";
-
-// src/session.ts
-var exports_session = {};
-__export(exports_session, {
-  node: () => node,
-  SyntheticConflictError: () => SyntheticConflictError,
-  SkillNotFoundError: () => SkillNotFoundError,
-  SessionSchema: () => SessionSchema,
-  Session: () => exports_session,
-  Service: () => Service,
-  PromptConflictError: () => PromptConflictError,
-  NotFoundError: () => NotFoundError,
-  MessageToolIncompleteError: () => MessageToolIncompleteError,
-  MessageNotFoundError: () => MessageNotFoundError,
-  MessageNotAssistantError: () => MessageNotAssistantError,
-  MessageIncompleteError: () => MessageIncompleteError,
-  MessageDecodeError: () => MessageDecodeError,
-  ListInput: () => ListInput,
-  ListAnchor: () => ListAnchor,
-  Info: () => Info,
-  InboxConflictError: () => InboxConflictError,
-  ID: () => ID,
-  DestinationUnavailableError: () => DestinationUnavailableError,
-  DestinationNotFoundError: () => DestinationNotFoundError,
-  DestinationNotDirectoryError: () => DestinationNotDirectoryError,
-  CompactionConflictError: () => CompactionConflictError,
-  BusyError: () => BusyError,
-  AttachmentError: () => AttachmentError
-});
-import { Cause, Effect, Fiber, Layer, Schema, Context, RcMap, Stream, Scope } from "effect";
-import { ListAnchor } from "@opencode-ai/schema/session";
-import { and, asc, desc, eq, gt, isNull, like, lt, or } from "drizzle-orm";
-import { Workspace } from "@opencode-ai/schema/workspace";
-import { Model } from "@opencode-ai/schema/model";
-import { Base64, FileAttachment, Prompt } from "@opencode-ai/schema/prompt";
-import path from "path";
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
-import { FSUtil } from "@opencode-ai/util/fs-util";
-import { Event } from "@opencode-ai/schema/event";
-import { Global } from "@opencode-ai/util/global";
-import { fileURLToPath } from "url";
-var ListInputBase = {
-  workspaceID: Workspace.ID.pipe(Schema.optional),
-  search: Schema.String.pipe(Schema.optional),
-  limit: PositiveInt.pipe(Schema.optional),
-  order: Schema.Literals(["asc", "desc"]).pipe(Schema.optional),
-  parentID: Schema.NullOr(SessionSchema.ID).pipe(Schema.optional),
-  anchor: ListAnchor.pipe(Schema.optional)
-};
-var ListDirectoryInput = Schema.Struct({
-  ...ListInputBase,
-  directory: AbsolutePath
-});
-var ListProjectInput = Schema.Struct({
-  ...ListInputBase,
-  project: exports_project.ID,
-  subpath: RelativePath.pipe(Schema.optional)
-});
-var ListAllInput = Schema.Struct(ListInputBase);
-var ListInput = Schema.Union([ListDirectoryInput, ListProjectInput, ListAllInput]);
-class PromptConflictError extends Schema.TaggedError()("Session.PromptConflictError", {
-  sessionID: SessionSchema.ID,
-  messageID: SessionMessage.ID
-}) {
-}
-
-class SyntheticConflictError extends Schema.TaggedError()("Session.SyntheticConflictError", {
-  sessionID: SessionSchema.ID,
-  inputID: SessionMessage.ID
-}) {
-}
-
-class AttachmentError extends Schema.TaggedError()("Session.AttachmentError", {
-  uri: Schema.String,
-  message: Schema.String
-}) {
-}
-
-class CompactionConflictError extends Schema.TaggedError()("Session.CompactionConflictError", {
-  sessionID: SessionSchema.ID,
-  inputID: SessionMessage.ID
-}) {
-}
-
-class BusyError extends Schema.TaggedError()("Session.BusyError", {
-  sessionID: SessionSchema.ID
-}) {
-}
-
-class MessageNotAssistantError extends Schema.TaggedError()("Session.MessageNotAssistantError", {
-  sessionID: SessionSchema.ID,
-  messageID: SessionMessage.ID
-}) {
-}
-
-class MessageIncompleteError extends Schema.TaggedError()("Session.MessageIncompleteError", {
-  sessionID: SessionSchema.ID,
-  messageID: SessionMessage.ID
-}) {
-}
-
-class MessageToolIncompleteError extends Schema.TaggedError()("Session.MessageToolIncompleteError", {
-  sessionID: SessionSchema.ID,
-  messageID: SessionMessage.ID
-}) {
-}
-
-class InboxConflictError extends Schema.TaggedError()("Session.InboxConflictError", {
-  sessionID: SessionSchema.ID,
-  inboxID: SessionMessage.ID
-}) {
-}
-
-class SkillNotFoundError extends Schema.TaggedError()("Session.SkillNotFoundError", {
-  skill: exports_skill.ID
-}) {
-}
-
-class DestinationNotFoundError extends Schema.TaggedError()("Session.DestinationNotFoundError", { directory: AbsolutePath }) {
-}
-
-class DestinationNotDirectoryError extends Schema.TaggedError()("Session.DestinationNotDirectoryError", { directory: AbsolutePath }) {
-}
-
-class DestinationUnavailableError extends Schema.TaggedError()("Session.DestinationUnavailableError", { directory: AbsolutePath }) {
-}
-var MessageNotFoundError = exports_revert.MessageNotFoundError;
-
-class Service 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;
-  const db = database.db;
-  const bus = yield* exports_bus.Service;
-  const projects = yield* exports_project.Service;
-  const global = yield* Global.Service;
-  const execution = yield* exports_execution.Service;
-  const store = yield* exports_store.Service;
-  const locations = yield* exports_location_service_map.Service;
-  const fs = yield* FSUtil.Service;
-  const jobs = yield* exports_job.Service;
-  const environments = yield* exports_environment.Service;
-  const scope = yield* Scope.Scope;
-  const closeTransport = Effect.fn("Session.closeTransport")(function* (session) {
-    const location = exports_location.Ref.make({
-      directory: session.location.directory,
-      workspaceID: session.location.workspaceID
-    });
-    if (!(yield* RcMap.has(locations.rcMap, location)))
-      return;
-    yield* exports_model_transport.Service.use((transport) => transport.close(session.id)).pipe(Effect.provide(locations.get(location)));
-  });
-  const isDurableSessionEvent = Schema.is(SessionEvent.Durable);
-  const persistProject = (project) => upsertProject(db, project).pipe(Effect.orDie);
-  const pendingConflict = Effect.fn("Session.pendingConflict")(function* (input) {
-    yield* result.get(input.sessionID);
-    return yield* new InboxConflictError(input);
-  });
-  const mutatePending = (input, mutation, wake = false) => Effect.uninterruptible(Effect.gen(function* () {
-    yield* mutation(bus, { sessionID: input.sessionID, id: input.inboxID }).pipe(Effect.catchDefect((defect) => defect instanceof exports_inbox.LifecycleConflict ? pendingConflict(input) : Effect.die(defect)));
-    if (wake)
-      yield* execution.wake(input.sessionID);
-  }));
-  const result = Service.of({
-    create: Effect.fn("Session.create")(function* (input) {
-      const sessionID = input.id ?? SessionSchema.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 });
-      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);
-      yield* persistProject(project);
-      const projected = yield* bus.publish(SessionEvent.Created, {
-        sessionID,
-        slug: Slug.create(),
-        version: app.version,
-        projectID: project.id,
-        parentID: input.parentID,
-        location,
-        subpath: RelativePath.make(path.relative(project.directory, location.directory).replaceAll("\\", "/")),
-        title: input.title,
-        agent: input.agent,
-        metadata: input.metadata ?? parent?.metadata,
-        model: input.model ? {
-          id: Model.ID.make(input.model.id),
-          providerID: input.model.providerID,
-          variant: input.model.variant
-        } : undefined
-      }, { location }).pipe(Effect.as({ type: "created" }), Effect.catchDefect((defect) => {
-        if (!(defect instanceof exports_projector.SessionAlreadyProjected)) {
-          return Effect.die(defect);
-        }
-        return store.get(sessionID).pipe(Effect.flatMap((session) => session ? Effect.succeed({ type: "existing", session }) : Effect.die(defect)));
-      }));
-      if (projected.type === "existing")
-        return projected.session;
-      return yield* result.get(sessionID).pipe(Effect.orDie);
-    }),
-    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);
-      if (!boundary && input.boundary.type === "before")
-        return yield* new MessageNotFoundError({
-          sessionID: input.sessionID,
-          messageID: input.boundary.messageID
-        });
-      if (!boundary)
-        return yield* new ForkEmptyError({ sessionID: input.sessionID });
-      const sessionID = SessionSchema.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)
-      })).pipe(Effect.orDie);
-      yield* bus.publish(SessionEvent.Forked, {
-        sessionID,
-        parentID: parent.id,
-        boundary: { ...input.boundary, messageID: boundary.id },
-        ...inherited
-      });
-      return yield* result.get(sessionID).pipe(Effect.orDie);
-    }),
-    get: Effect.fn("Session.get")(function* (sessionID) {
-      const session = yield* store.get(sessionID);
-      if (!session)
-        return yield* new NotFoundError({ sessionID });
-      return session;
-    }),
-    environment: Effect.fn("Session.environment")(function* (input) {
-      yield* result.get(input.sessionID);
-      if (input.variables !== undefined)
-        yield* environments.set(input.sessionID, input.variables);
-      return yield* environments.get(input.sessionID);
-    }),
-    view: Effect.fn("Session.view")(function* (input) {
-      const row = yield* db.select({ idle: SessionTable.time_idle, viewed: SessionTable.time_viewed }).from(SessionTable).where(eq(SessionTable.id, input.sessionID)).get().pipe(Effect.orDie);
-      if (!row)
-        return yield* new NotFoundError({ sessionID: input.sessionID });
-      if (row.idle === null || input.idle > row.idle || row.viewed !== null && row.viewed >= input.idle)
-        return yield* Effect.void;
-      yield* bus.publish(SessionEvent.Viewed, { sessionID: input.sessionID, idle: input.idle });
-    }),
-    remove: Effect.fn("Session.remove")(function* (sessionID) {
-      const session = yield* result.get(sessionID);
-      yield* execution.interrupt(sessionID);
-      yield* execution.awaitIdle(sessionID);
-      yield* closeTransport(session);
-      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.remove(sessionID);
-    }),
-    list: Effect.fn("Session.list")(function* (input = {}) {
-      const direction = input.anchor?.direction ?? "next";
-      const requestedOrder = input.order ?? "desc";
-      const order = direction === "previous" ? requestedOrder === "asc" ? "desc" : "asc" : requestedOrder;
-      const sortColumn = SessionTable.time_updated;
-      const conditions = [];
-      if ("directory" in input)
-        conditions.push(eq(SessionTable.directory, input.directory));
-      if (input.workspaceID)
-        conditions.push(eq(SessionTable.workspace_id, input.workspaceID));
-      if ("project" in input)
-        conditions.push(eq(SessionTable.project_id, input.project));
-      if ("project" in input && input.subpath !== undefined)
-        conditions.push(eq(SessionTable.path, input.subpath));
-      if (input.search)
-        conditions.push(like(SessionTable.title, `%${input.search}%`));
-      if (input.parentID !== undefined)
-        conditions.push(input.parentID === null ? isNull(SessionTable.parent_id) : eq(SessionTable.parent_id, input.parentID));
-      if (input.anchor) {
-        conditions.push(order === "asc" ? or(gt(sortColumn, input.anchor.time), and(eq(sortColumn, input.anchor.time), gt(SessionTable.id, input.anchor.id))) : or(lt(sortColumn, input.anchor.time), and(eq(sortColumn, input.anchor.time), lt(SessionTable.id, input.anchor.id))));
-      }
-      const query = db.select().from(SessionTable).where(conditions.length > 0 ? and(...conditions) : undefined).orderBy(order === "asc" ? asc(sortColumn) : desc(sortColumn), order === "asc" ? asc(SessionTable.id) : desc(SessionTable.id));
-      const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(Effect.orDie);
-      return { data: (direction === "previous" ? rows.toReversed() : rows).map((row) => fromRow(row)) };
-    }),
-    messages: Effect.fn("Session.messages")(function* (input) {
-      yield* result.get(input.sessionID);
-      const direction = input.cursor?.direction ?? "next";
-      const requestedOrder = input.order ?? "desc";
-      const order = direction === "previous" ? requestedOrder === "asc" ? "desc" : "asc" : requestedOrder;
-      const anchor = input.cursor ? yield* db.select({ seq: SessionMessageTable.seq }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, input.sessionID), eq(SessionMessageTable.id, input.cursor.id))).get().pipe(Effect.orDie) : undefined;
-      if (input.cursor && !anchor)
-        return [];
-      const boundary = anchor ? order === "asc" ? gt(SessionMessageTable.seq, anchor.seq) : lt(SessionMessageTable.seq, anchor.seq) : undefined;
-      const where = boundary ? and(eq(SessionMessageTable.session_id, input.sessionID), boundary) : eq(SessionMessageTable.session_id, input.sessionID);
-      const query = db.select().from(SessionMessageTable).where(where).orderBy(order === "asc" ? asc(SessionMessageTable.seq) : desc(SessionMessageTable.seq));
-      const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(Effect.orDie);
-      return yield* Effect.forEach(direction === "previous" ? rows.toReversed() : rows, exports_history.decodeMessageRow);
-    }),
-    message: Effect.fn("Session.message")(function* (input) {
-      const stored = yield* store.message(input.messageID);
-      return stored?.sessionID === input.sessionID ? stored.message : undefined;
-    }),
-    updateMessage: Effect.fn("Session.updateMessage")(function* (input) {
-      const ref = { sessionID: input.sessionID, messageID: input.messageID };
-      yield* result.get(ref.sessionID);
-      if ((yield* execution.active).has(ref.sessionID))
-        return yield* new BusyError({ sessionID: ref.sessionID });
-      const message = yield* result.message(ref);
-      if (!message)
-        return yield* new MessageNotFoundError(ref);
-      if (message.type !== "assistant")
-        return yield* new MessageNotAssistantError(ref);
-      if (!message.time.completed)
-        return yield* new MessageIncompleteError(ref);
-      if (input.content.some((content) => content.type === "tool" && (content.state.status === "streaming" || content.state.status === "running")))
-        return yield* new MessageToolIncompleteError(ref);
-      yield* bus.publish(SessionEvent.MessageContentUpdated, {
-        ...ref,
-        content: Schema.encodeSync(Schema.Array(SessionMessage.AssistantContent))(input.content)
-      });
-      const updated = yield* result.message(ref);
-      if (updated?.type !== "assistant")
-        return yield* new MessageNotFoundError(ref);
-      return updated;
-    }),
-    context: Effect.fn("Session.context")(function* (sessionID) {
-      yield* result.get(sessionID);
-      return yield* store.context(sessionID);
-    }),
-    inbox: Effect.fn("Session.inbox")(function* (sessionID) {
-      yield* result.get(sessionID);
-      return yield* exports_inbox.list(db, sessionID);
-    }),
-    cancelInbox: Effect.fn("Session.cancelInbox")((input) => mutatePending(input, exports_inbox.cancel)),
-    steerInbox: Effect.fn("Session.steerInbox")((input) => mutatePending(input, exports_inbox.steer, true)),
-    queueInbox: Effect.fn("Session.queueInbox")((input) => mutatePending(input, exports_inbox.queue)),
-    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))),
-    prompt: Effect.fn("Session.prompt")((input) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
-      const session = yield* result.get(input.sessionID);
-      const messageID = input.id ?? SessionMessage.ID.create();
-      const admitted = yield* Effect.gen(function* () {
-        const existing = yield* exports_inbox.reconcile(db, {
-          id: messageID,
-          sessionID: session.id,
-          delivery: input.delivery ?? "steer"
-        });
-        if (existing)
-          return existing;
-        const item = yield* restore(preparePrompt(input, messageID).pipe(Effect.provide(locations.get(session.location)), Effect.provideService(FSUtil.Service, fs)));
-        if (session.revert)
-          yield* exports_revert.commit(session).pipe(Effect.provideService(exports_bus.Service, bus));
-        return yield* exports_inbox.admit(db, bus, {
-          id: messageID,
-          sessionID: session.id,
-          item
-        });
-      }).pipe(Effect.catchDefect((defect) => defect instanceof exports_inbox.LifecycleConflict ? new PromptConflictError({ sessionID: input.sessionID, messageID }) : Effect.die(defect)));
-      if (admitted.type !== "user" || admitted.sessionID !== input.sessionID)
-        return yield* new PromptConflictError({ sessionID: input.sessionID, messageID });
-      if (input.resume !== false)
-        yield* execution.wake(admitted.sessionID);
-      return admitted;
-    }))),
-    generate: Effect.fn("Session.generate")(function* (input) {
-      const session = yield* result.get(input.sessionID);
-      const generate = yield* exports_generate.Service.pipe(Effect.provide(locations.get(session.location)));
-      return yield* generate.generate(input);
-    }),
-    command: Effect.fn("Session.command")(function* (input) {
-      const session = yield* result.get(input.sessionID);
-      const commands = yield* Effect.gen(function* () {
-        const plugins = yield* exports_supervisor_service.Service;
-        yield* plugins.flush;
-        return yield* exports_command.Service;
-      }).pipe(Effect.provide(locations.get(session.location)));
-      const delivery = input.delivery ?? "steer";
-      yield* commands.execute({
-        name: input.command,
-        invocation: {
-          sessionID: input.sessionID,
-          prompt: {
-            text: input.text,
-            files: input.files,
-            agents: input.agents,
-            skills: input.skills
-          },
-          delivery
-        }
-      });
-    }),
-    shell: Effect.fn("Session.shell")(function* (input) {
-      const session = yield* result.get(input.sessionID);
-      const running = yield* Effect.gen(function* () {
-        const shell = yield* Effect.gen(function* () {
-          const plugins = yield* exports_supervisor_service.Service;
-          yield* plugins.flush;
-          return yield* exports_shell.Service;
-        }).pipe(Effect.provide(locations.get(session.location)));
-        const started = yield* shell.create({
-          command: input.command,
-          cwd: session.location.directory,
-          timeout: 0,
-          metadata: { sessionID: input.sessionID, background: true }
-        }).pipe(Effect.tapError((error) => result.synthetic({
-          sessionID: input.sessionID,
-          text: `User shell command failed to start:
-${input.command}
-
-${error.message}`,
-          description: input.command,
-          metadata: { source: "shell", state: "error" },
-          resume: false
-        })), Effect.orDie);
-        yield* bus.publish(SessionEvent.Shell.Started, {
-          sessionID: input.sessionID,
-          shell: started
-        }, { id: input.id });
-        const terminal = yield* shell.result(started);
-        const preview = yield* shell.output(started.id, { limit: SHELL_MAX_CAPTURE_BYTES }).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed(exports_result.unavailable)));
-        yield* bus.publish(SessionEvent.Shell.Ended, {
-          sessionID: input.sessionID,
-          shell: terminal.info,
-          output: preview
-        });
-        yield* result.synthetic({
-          ...exports_result.userNotification(terminal),
-          sessionID: input.sessionID,
-          resume: false
-        }).pipe(Effect.catchTag("Session.NotFoundError", () => Effect.void), Effect.orDie);
-      }).pipe(Effect.forkIn(scope, { startImmediately: true }));
-      yield* Fiber.join(running);
-    }),
-    skill: Effect.fn("Session.skill")(function* (input) {
-      const session = yield* result.get(input.sessionID);
-      const skills = yield* exports_skill.Service.pipe(Effect.provide(locations.get(session.location)));
-      const skill = yield* skills.get(input.skill);
-      if (!skill)
-        return yield* new SkillNotFoundError({ skill: input.skill });
-      yield* bus.publish(SessionEvent.Skill.Activated, {
-        sessionID: input.sessionID,
-        id: skill.id,
-        name: skill.name,
-        text: skill.content
-      }, { id: input.id ? Event.ID.make(input.id.replace(/^msg_/, "evt_")) : undefined });
-      if (input.resume !== false)
-        yield* execution.resume(input.sessionID).pipe(Effect.ignore, Effect.forkIn(scope, { startImmediately: true }), Effect.asVoid);
-    }),
-    switchAgent: Effect.fn("Session.switchAgent")(function* (input) {
-      const session = yield* result.get(input.sessionID);
-      yield* bus.publish(SessionEvent.AgentSelected, {
-        sessionID: input.sessionID,
-        agent: input.agent,
-        previous: session.agent
-      });
-    }),
-    switchModel: Effect.fn("Session.switchModel")(function* (input) {
-      const session = yield* result.get(input.sessionID);
-      if (session.model?.providerID === input.model.providerID && session.model.id === input.model.id && (session.model.variant ?? "default") === (input.model.variant ?? "default"))
-        return;
-      yield* bus.publish(SessionEvent.ModelSelected, {
-        sessionID: input.sessionID,
-        model: input.model,
-        previous: session.model
-      });
-    }),
-    rename: Effect.fn("Session.rename")(function* (input) {
-      yield* result.get(input.sessionID);
-      yield* bus.publish(SessionEvent.Renamed, {
-        sessionID: input.sessionID,
-        title: input.title
-      });
-    }),
-    move: Effect.fn("Session.move")(function* (input) {
-      const current = yield* result.get(input.sessionID);
-      const value = input.directory.trim();
-      const expanded = value === "~" ? global.home : value.startsWith("~/") ? path.join(global.home, value.slice(2)) : value;
-      const directory = AbsolutePath.make(path.resolve(current.location.directory, expanded));
-      const info = yield* fs.stat(directory).pipe(Effect.orElseSucceed(() => {
-        return;
-      }));
-      if (!info)
-        return yield* new DestinationNotFoundError({ directory });
-      if (info.type !== "Directory")
-        return yield* new DestinationNotDirectoryError({ directory });
-      const project = yield* projects.resolve(directory);
-      const payload = {
-        location: exports_location.Ref.make({ directory, workspaceID: input.workspaceID }),
-        projectID: project.id,
-        subpath: RelativePath.make(path.relative(project.directory, directory).replaceAll("\\", "/"))
-      };
-      yield* exports_location.Service.pipe(Effect.provide(locations.get(payload.location)), Effect.scoped, Effect.catchCause((cause) => {
-        if (Cause.hasInterruptsOnly(cause))
-          return Effect.failCause(cause);
-        return Effect.logWarning("session move destination unavailable", { directory, cause }).pipe(Effect.andThen(Effect.fail(new DestinationUnavailableError({ directory }))));
-      }));
-      yield* persistProject(project);
-      const item = exports_inbox.Item.make({
-        type: "move",
-        payload,
-        delivery: input.delivery ?? "steer"
-      });
-      yield* exports_inbox.serialized(input.sessionID, Effect.gen(function* () {
-        const latest = yield* result.get(input.sessionID);
-        const source = yield* fs.stat(latest.location.directory).pipe(Effect.orElseSucceed(() => {
-          return;
-        }));
-        if (!source || source.type !== "Directory") {
-          const cancellations = (yield* exports_inbox.moveIDs(db, input.sessionID)).map((item2) => [SessionEvent.InboxCancelled, { sessionID: input.sessionID, inboxID: item2.id }]);
-          const moved = [SessionEvent.Moved, { sessionID: input.sessionID, ...payload }];
-          const first = cancellations[0];
-          if (!first)
-            return yield* bus.publish(...moved).pipe(Effect.asVoid);
-          return yield* bus.publishAll([first, ...cancellations.slice(1), moved]);
-        }
-        yield* exports_inbox.admit(db, bus, {
-          id: SessionMessage.ID.create(),
-          sessionID: input.sessionID,
-          item
-        });
-      }));
-      yield* execution.wake(input.sessionID);
-    }),
-    compact: Effect.fn("Session.compact")(function* (input) {
-      yield* result.get(input.sessionID);
-      const inputID = input.id ?? SessionMessage.ID.create();
-      const admitted = yield* exports_inbox.admitCompaction(db, bus, {
-        id: inputID,
-        sessionID: input.sessionID,
-        delivery: input.delivery ?? "steer"
-      }).pipe(Effect.catchDefect((defect) => defect instanceof exports_inbox.LifecycleConflict ? new CompactionConflictError({ sessionID: input.sessionID, inputID }) : Effect.die(defect)));
-      yield* execution.wake(input.sessionID);
-      return admitted;
-    }),
-    wait: Effect.fn("Session.wait")(function* (sessionID) {
-      yield* result.get(sessionID);
-      yield* execution.awaitIdle(sessionID);
-    }),
-    active: execution.active,
-    background: Effect.fn("Session.background")(function* (sessionID) {
-      yield* result.get(sessionID);
-      const backgrounded = yield* jobs.backgroundAll({ sessionID });
-      if (backgrounded.length === 0)
-        return;
-      yield* result.synthetic({
-        sessionID,
-        text: [
-          "User requested that active blocking work be moved to the background.",
-          "",
-          "Backgrounded work:",
-          ...backgrounded.map((job) => `- ${job.type}: ${job.title && job.title.length > 0 ? job.title : job.id}`),
-          "",
-          "The backgrounded work is still unfinished. Move on to other work if you can. If there is nothing else useful to do, finish your response. Do not wait, sleep, poll, or report the backgrounded work as complete until a later completion notification is added to the conversation."
-        ].join(`
-`)
-      }).pipe(Effect.catchTag("Session.SyntheticConflictError", Effect.die));
-    }),
-    resume: Effect.fn("Session.resume")(function* (sessionID) {
-      yield* result.get(sessionID);
-      yield* execution.resume(sessionID);
-    }),
-    synthetic: Effect.fn("Session.synthetic")((input) => Effect.uninterruptible(Effect.gen(function* () {
-      yield* result.get(input.sessionID);
-      const inputID = input.id ?? SessionMessage.ID.create();
-      const admittedInput = exports_inbox.Item.make({
-        type: "synthetic",
-        payload: {
-          text: input.text,
-          description: input.description,
-          metadata: input.metadata
-        },
-        delivery: input.delivery ?? "steer"
-      });
-      const admitted = yield* exports_inbox.admit(db, bus, {
-        id: inputID,
-        sessionID: input.sessionID,
-        item: admittedInput
-      }).pipe(Effect.catchDefect((defect) => defect instanceof exports_inbox.LifecycleConflict ? new SyntheticConflictError({ sessionID: input.sessionID, inputID }) : Effect.die(defect)));
-      if (admitted.type !== "synthetic" || admitted.sessionID !== input.sessionID)
-        return yield* new SyntheticConflictError({ sessionID: input.sessionID, inputID });
-      if (input.resume !== false && !(yield* result.get(input.sessionID)).revert)
-        yield* execution.wake(input.sessionID);
-      return admitted;
-    }))),
-    interrupt: Effect.fn("Session.interrupt")((sessionID, options) => Effect.uninterruptible(execution.interrupt(sessionID, options))),
-    revert: {
-      stage: Effect.fn("Session.revert.stage")(function* (input) {
-        const session = yield* result.get(input.sessionID);
-        if ((yield* execution.active).has(input.sessionID))
-          return yield* new BusyError({ sessionID: input.sessionID });
-        return yield* Effect.gen(function* () {
-          const plugins = yield* exports_supervisor_service.Service;
-          yield* plugins.flush;
-          return yield* exports_revert.stage({ session, messageID: input.messageID, files: input.files }).pipe(Effect.provideService(exports_database.Service, database), Effect.provideService(exports_bus.Service, bus));
-        }).pipe(Effect.provide(locations.get(session.location)));
-      }),
-      clear: Effect.fn("Session.revert.clear")(function* (sessionID) {
-        const session = yield* result.get(sessionID);
-        if ((yield* execution.active).has(sessionID))
-          return yield* new BusyError({ sessionID });
-        const revert = yield* Effect.gen(function* () {
-          const plugins = yield* exports_supervisor_service.Service;
-          yield* plugins.flush;
-          return yield* exports_revert.clear(session).pipe(Effect.provideService(exports_bus.Service, bus));
-        }).pipe(Effect.provide(locations.get(session.location)));
-        yield* execution.wake(sessionID);
-        return revert;
-      }),
-      commit: Effect.fn("Session.revert.commit")(function* (sessionID) {
-        const session = yield* result.get(sessionID);
-        if ((yield* execution.active).has(sessionID))
-          return yield* new BusyError({ sessionID });
-        return yield* exports_revert.commit(session).pipe(Effect.provideService(exports_bus.Service, bus));
-      })
-    }
-  });
-  return result;
-}));
-var preparePrompt = Effect.fn("Session.preparePrompt")(function* (request, messageID) {
-  const plugins = yield* exports_supervisor_service.Service;
-  yield* plugins.flush;
-  const hooks = yield* exports_hooks.Service;
-  const event = yield* hooks.trigger("session", "prompt", {
-    sessionID: request.sessionID,
-    messageID,
-    prompt: structuredClone({
-      text: request.text,
-      files: request.files?.slice(),
-      agents: request.agents?.slice(),
-      skills: request.skills?.slice()
-    }),
-    metadata: structuredClone(request.metadata),
-    delivery: request.delivery ?? "steer"
-  });
-  const input = event.prompt;
-  const fs = yield* FSUtil.Service;
-  const files = input.files ? yield* Effect.forEach(input.files, (file) => materializeAttachment(fs, file), { concurrency: 8 }) : undefined;
-  const requested = input.skills;
-  const selected = yield* Effect.gen(function* () {
-    if (!requested?.length)
-      return;
-    const skillService = yield* exports_skill.Service;
-    const prepared = new Map;
-    return yield* Effect.forEach(requested, (attachment) => Effect.gen(function* () {
-      const name = prepared.get(attachment.id);
-      if (name !== undefined)
-        return { id: attachment.id, name, mention: attachment.mention };
-      const skill = yield* skillService.get(attachment.id);
-      if (!skill)
-        return yield* new SkillNotFoundError({ skill: attachment.id });
-      prepared.set(skill.id, skill.name);
-      return {
-        id: skill.id,
-        name: skill.name,
-        text: (yield* exports_skill.prepare(fs, skill).pipe(Effect.orDie)).output,
-        mention: attachment.mention
-      };
-    }));
-  });
-  return exports_inbox.Item.make({
-    type: "user",
-    payload: {
-      ...Prompt.make({
-        text: input.text,
-        agents: input.agents,
-        files,
-        skills: selected?.length ? selected : undefined
-      }),
-      metadata: event.metadata
-    },
-    delivery: event.delivery
-  });
-});
-var MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
-var materializeAttachment = Effect.fn("Session.materializeAttachment")(function* (fs, input) {
-  const resolved = input.uri.startsWith("data:") ? {
-    bytes: yield* decodeDataURL(input.uri),
-    source: { type: "inline" },
-    start: undefined,
-    end: undefined,
-    name: undefined,
-    mime: undefined
-  } : yield* readFileAttachment(fs, input.uri);
-  if (resolved.bytes.byteLength > MAX_ATTACHMENT_BYTES)
-    return yield* new AttachmentError({
-      uri: input.uri,
-      message: `Attachment exceeds the ${MAX_ATTACHMENT_BYTES} byte limit: ${input.uri}`
-    });
-  const mime = resolved.mime ?? exports_mime.detect(resolved.bytes);
-  const content = mime === "text/plain" && resolved.start !== undefined ? Buffer.from(Buffer.from(resolved.bytes).toString("utf8").split(`
-`).slice(resolved.start - 1, resolved.end).join(`
-`)) : resolved.bytes;
-  const normalized = yield* normalizeImageAttachment(input, Buffer.from(content).toString("base64"), mime);
-  return FileAttachment.create({
-    data: normalized.data,
-    mime: normalized.mime,
-    source: resolved.source,
-    name: input.name ?? resolved.name,
-    description: input.description,
-    mention: input.mention
-  });
-});
-var normalizeImageAttachment = Effect.fn("Session.normalizeImageAttachment")(function* (input, data, mime) {
-  if (!mime.startsWith("image/"))
-    return { data: Base64.make(data), mime };
-  const service = yield* exports_image.Service;
-  const label = input.name ?? (input.uri.startsWith("data:") ? "inline attachment" : input.uri);
-  const content = { uri: label, content: data, encoding: "base64", mime };
-  const normalized = yield* service.normalize(label, content).pipe(Effect.catchTag("Image.ResizerUnavailableError", () => Effect.succeed(content)), Effect.mapError((error) => new AttachmentError({ uri: label, message: error.message })));
-  return { data: Base64.make(normalized.content), mime: normalized.mime };
-});
-var readFileAttachment = Effect.fn("Session.readFileAttachment")(function* (fs, uri) {
-  const url = yield* Effect.try({
-    try: () => new URL(uri),
-    catch: () => new AttachmentError({ uri, message: `Invalid attachment URI: ${uri}` })
-  });
-  if (url.protocol !== "file:")
-    return yield* new AttachmentError({ uri, message: `Unsupported attachment URI: ${uri}` });
-  const start = positiveInt(url.searchParams.get("start"));
-  const end = positiveInt(url.searchParams.get("end"));
-  const target = yield* Effect.try({
-    try: () => {
-      url.search = "";
-      url.hash = "";
-      return fileURLToPath(url);
-    },
-    catch: () => new AttachmentError({ uri, message: `Invalid file URI: ${uri}` })
-  });
-  const info = yield* fs.stat(target).pipe(Effect.mapError(() => new AttachmentError({ uri, message: `Unable to read attachment: ${uri}` })));
-  if (info.type === "Directory") {
-    const entries = yield* fs.readDirectoryEntries(target).pipe(Effect.mapError(() => new AttachmentError({ uri, message: `Unable to read attachment: ${uri}` })));
-    return {
-      bytes: Buffer.from(entries.filter((entry) => entry.type === "file" || entry.type === "directory").sort((a, b) => a.type === b.type ? a.name.localeCompare(b.name) : a.type === "directory" ? -1 : 1).map((entry) => entry.name + (entry.type === "directory" ? path.sep : "")).join(`
-`)),
-      source: { type: "uri", uri },
-      start: undefined,
-      end: undefined,
-      name: path.basename(target),
-      mime: "application/x-directory"
-    };
-  }
-  if (info.type !== "File")
-    return yield* new AttachmentError({ uri, message: `Attachment is not a file: ${uri}` });
-  if (Number(info.size) > MAX_ATTACHMENT_BYTES)
-    return yield* new AttachmentError({
-      uri,
-      message: `Attachment exceeds the ${MAX_ATTACHMENT_BYTES} byte limit: ${uri}`
-    });
-  const bytes = yield* fs.readFile(target).pipe(Effect.mapError(() => new AttachmentError({ uri, message: `Unable to read attachment: ${uri}` })));
-  return { bytes, source: { type: "uri", uri }, start, end, name: path.basename(target), mime: undefined };
-});
-function decodeDataURL(uri) {
-  return Effect.try({
-    try: () => {
-      const comma = uri.indexOf(",");
-      if (comma === -1)
-        throw new Error("Invalid data URL");
-      const metadata = uri.slice(5, comma);
-      const payload = uri.slice(comma + 1);
-      if (!metadata.split(";").some((part) => part.toLowerCase() === "base64"))
-        return Buffer.from(decodeURIComponent(payload));
-      const bytes = Buffer.from(payload, "base64");
-      if (bytes.toString("base64") !== payload)
-        throw new Error("Non-canonical base64");
-      return bytes;
-    },
-    catch: () => new AttachmentError({ uri, message: "Invalid attachment data URL" })
-  });
-}
-function positiveInt(value) {
-  if (value === null)
-    return;
-  const parsed = Number(value);
-  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
-}
-var SHELL_MAX_CAPTURE_BYTES = 1024 * 1024;
-var node = makeGlobalNode({
-  service: Service,
-  layer,
-  deps: [
-    exports_job.node,
-    exports_environment.node,
-    exports_database.node,
-    exports_bus.node,
-    exports_project.node,
-    exports_execution.node,
-    exports_store.node,
-    exports_location_service_map.node,
-    exports_projector.node,
-    FSUtil.node,
-    Global.node,
-    exports_app.node
-  ]
-});
-
-export { ListAnchor, ListInput, PromptConflictError, SyntheticConflictError, AttachmentError, CompactionConflictError, BusyError, MessageNotAssistantError, MessageIncompleteError, MessageToolIncompleteError, InboxConflictError, SkillNotFoundError, DestinationNotFoundError, DestinationNotDirectoryError, DestinationUnavailableError, MessageNotFoundError, Service, node, exports_session };