@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-rr5phte9.js

@@ -0,0 +1,777 @@
+import {
+  exports_execution
+} from "./permission-e2mxwc51.js";
+import {
+  exports_generate
+} from "./permission-xgv25zxy.js";
+import {
+  exports_projector
+} from "./permission-015h7azv.js";
+import {
+  exports_revert
+} from "./permission-t1xz8esh.js";
+import {
+  exports_pending
+} from "./permission-vz49gck1.js";
+import {
+  Slug
+} from "./permission-df3v2q6j.js";
+import {
+  exports_shell
+} from "./permission-qde5933h.js";
+import {
+  exports_command
+} from "./permission-d4a2h60z.js";
+import {
+  exports_job
+} from "./permission-vynn1k31.js";
+import {
+  exports_mime
+} from "./permission-dhphtf1x.js";
+import {
+  exports_location_service_map
+} from "./permission-zdkg1k91.js";
+import {
+  exports_app
+} from "./permission-50jxp3hw.js";
+import {
+  exports_image
+} from "./permission-f0sqeedm.js";
+import {
+  exports_skill
+} from "./permission-zr271bqv.js";
+import {
+  exports_store
+} from "./permission-2zyawa45.js";
+import {
+  ForkEmptyError,
+  MessageDecodeError,
+  NotFoundError
+} from "./permission-s6by3cc4.js";
+import {
+  exports_instruction_state
+} from "./permission-bha9y19b.js";
+import {
+  fromRow
+} from "./permission-mya790jh.js";
+import {
+  exports_message
+} from "./permission-25pxtba7.js";
+import {
+  SessionMessageTable,
+  SessionTable
+} from "./permission-zvvp2xr4.js";
+import {
+  SessionEvent
+} from "./permission-a83yvq99.js";
+import {
+  exports_agent
+} from "./permission-0c101nc9.js";
+import {
+  ID,
+  Info,
+  exports_schema
+} from "./permission-y8rs54ne.js";
+import {
+  exports_workspace
+} from "./permission-n6t016aw.js";
+import {
+  exports_model
+} from "./permission-xfd1xnk3.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  exports_project
+} from "./permission-j2hktz7g.js";
+import {
+  upsertProject
+} from "./permission-88jbfw8z.js";
+import {
+  exports_database
+} from "./permission-8w2n8x74.js";
+import {
+  exports_keyed_mutex
+} from "./permission-0kvmztkf.js";
+import {
+  AbsolutePath,
+  PositiveInt,
+  RelativePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session.ts
+var exports_session = {};
+__export(exports_session, {
+  node: () => node,
+  SyntheticConflictError: () => SyntheticConflictError,
+  SkillNotFoundError: () => SkillNotFoundError,
+  SessionSchema: () => exports_schema,
+  Session: () => exports_session,
+  Service: () => Service,
+  PromptConflictError: () => PromptConflictError,
+  PendingInputConflictError: () => PendingInputConflictError,
+  NotFoundError: () => NotFoundError,
+  MessageNotFoundError: () => MessageNotFoundError,
+  MessageDecodeError: () => MessageDecodeError,
+  ListInput: () => ListInput,
+  ListAnchor: () => ListAnchor,
+  Info: () => Info,
+  ID: () => ID,
+  DestinationNotFoundError: () => DestinationNotFoundError,
+  DestinationNotDirectoryError: () => DestinationNotDirectoryError,
+  CompactionConflictError: () => CompactionConflictError,
+  BusyError: () => BusyError,
+  AttachmentError: () => AttachmentError
+});
+import { Effect, Layer, Schema, Context, 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 { 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: exports_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(exports_schema.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.TaggedErrorClass()("Session.PromptConflictError", {
+  sessionID: exports_schema.ID,
+  messageID: exports_message.ID
+}) {
+}
+
+class SyntheticConflictError extends Schema.TaggedErrorClass()("Session.SyntheticConflictError", {
+  sessionID: exports_schema.ID,
+  inputID: exports_message.ID
+}) {
+}
+
+class AttachmentError extends Schema.TaggedErrorClass()("Session.AttachmentError", {
+  uri: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CompactionConflictError extends Schema.TaggedErrorClass()("Session.CompactionConflictError", {
+  sessionID: exports_schema.ID,
+  inputID: exports_message.ID
+}) {
+}
+
+class BusyError extends Schema.TaggedErrorClass()("Session.BusyError", {
+  sessionID: exports_schema.ID
+}) {
+}
+
+class PendingInputConflictError extends Schema.TaggedErrorClass()("Session.PendingInputConflictError", {
+  sessionID: exports_schema.ID,
+  inputID: exports_message.ID
+}) {
+}
+
+class SkillNotFoundError extends Schema.TaggedErrorClass()("Session.SkillNotFoundError", {
+  skill: exports_skill.ID
+}) {
+}
+
+class DestinationNotFoundError extends Schema.TaggedErrorClass()("Session.DestinationNotFoundError", { directory: AbsolutePath }) {
+}
+
+class DestinationNotDirectoryError extends Schema.TaggedErrorClass()("Session.DestinationNotDirectoryError", { 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 scope = yield* Scope.Scope;
+  const activeShells = new Set;
+  const shellLocks = exports_keyed_mutex.makeUnsafe();
+  const decodeMessage = Schema.decodeUnknownEffect(exports_message.Info);
+  const isDurableSessionEvent = Schema.is(SessionEvent.Durable);
+  const persistProject = (project) => upsertProject(db, project).pipe(Effect.orDie);
+  const decode = (row) => decodeMessage({ ...row.data, id: row.id, type: row.type }).pipe(Effect.mapError(() => new MessageDecodeError({
+    sessionID: exports_schema.ID.make(row.session_id),
+    messageID: exports_message.ID.make(row.id)
+  })));
+  const pendingConflict = Effect.fn("Session.pendingConflict")(function* (input) {
+    yield* result.get(input.sessionID);
+    return yield* new PendingInputConflictError(input);
+  });
+  const mutatePending = (input, mutation, wake = false) => Effect.uninterruptible(Effect.gen(function* () {
+    yield* mutation(bus, { sessionID: input.sessionID, id: input.inputID }).pipe(Effect.catchDefect((defect) => defect instanceof exports_pending.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 ?? exports_schema.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,
+        model: input.model ? {
+          id: exports_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 = exports_schema.ID.create();
+      yield* bus.publish(SessionEvent.Forked, {
+        sessionID,
+        parentID: parent.id,
+        boundary: { ...input.boundary, messageID: boundary.id },
+        instructions: yield* exports_instruction_state.current(db, parent.id)
+      });
+      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;
+    }),
+    remove: Effect.fn("Session.remove")(function* (sessionID) {
+      yield* result.get(sessionID);
+      yield* execution.interrupt(sessionID);
+      yield* execution.awaitIdle(sessionID);
+      const children = yield* result.list({ parentID: sessionID });
+      yield* Effect.forEach(children.data, (child) => result.remove(child.id), { concurrency: 1, discard: true });
+      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, decode);
+    }),
+    message: Effect.fn("Session.message")(function* (input) {
+      const stored = yield* store.message(input.messageID);
+      return stored?.sessionID === input.sessionID ? stored.message : undefined;
+    }),
+    context: Effect.fn("Session.context")(function* (sessionID) {
+      yield* result.get(sessionID);
+      return yield* store.context(sessionID);
+    }),
+    pending: Effect.fn("Session.pending")(function* (sessionID) {
+      yield* result.get(sessionID);
+      return yield* exports_pending.list(db, sessionID);
+    }),
+    cancelPending: Effect.fn("Session.cancelPending")((input) => mutatePending(input, exports_pending.cancel)),
+    steerPending: Effect.fn("Session.steerPending")((input) => mutatePending(input, exports_pending.steer, true)),
+    queuePending: Effect.fn("Session.queuePending")((input) => mutatePending(input, exports_pending.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.uninterruptible(Effect.gen(function* () {
+      const session = yield* result.get(input.sessionID);
+      if (session.revert)
+        yield* exports_revert.commit(session).pipe(Effect.provideService(exports_bus.Service, bus));
+      const image = exports_image.Service.pipe(Effect.provide(locations.get(session.location)));
+      const skills = exports_skill.Service.pipe(Effect.provide(locations.get(session.location)));
+      const prompt = yield* resolvePrompt({ text: input.text, files: input.files, agents: input.agents, skills: input.skills }, image, skills).pipe(Effect.provideService(FSUtil.Service, fs));
+      const messageID = input.id ?? exports_message.ID.create();
+      const admittedInput = exports_pending.Message.make({
+        type: "user",
+        data: { ...prompt, metadata: input.metadata },
+        delivery: input.delivery ?? "steer"
+      });
+      const admitted = yield* exports_pending.admit(db, bus, {
+        id: messageID,
+        sessionID: input.sessionID,
+        input: admittedInput
+      }).pipe(Effect.catchDefect((defect) => defect instanceof exports_pending.LifecycleConflict ? new PromptConflictError({ sessionID: input.sessionID, messageID }) : Effect.die(defect)));
+      if (admitted.type !== "user" || !exports_pending.equivalent(admitted, { sessionID: input.sessionID, input: admittedInput }))
+        return yield* new PromptConflictError({ sessionID: input.sessionID, messageID });
+      if (input.resume !== false) {
+        if (activeShells.has(admitted.sessionID))
+          return admitted;
+        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* exports_command.Service.pipe(Effect.provide(locations.get(session.location)));
+      const command = yield* commands.get(input.command);
+      if (!command)
+        return yield* new exports_command.NotFoundError({
+          command: input.command,
+          message: `Command not found: ${input.command}`
+        });
+      const evaluated = yield* commands.evaluate({ name: input.command, arguments: input.arguments });
+      const agent = command.agent ?? input.agent;
+      const commandAgent = yield* Effect.gen(function* () {
+        if (!command.agent)
+          return;
+        const agents = yield* exports_agent.Service.pipe(Effect.provide(locations.get(session.location)));
+        return yield* agents.get(exports_agent.ID.make(command.agent));
+      });
+      const model = command.model ?? commandAgent?.model ?? input.model;
+      if (agent !== undefined && session.agent !== exports_agent.ID.make(agent))
+        yield* result.switchAgent({ sessionID: input.sessionID, agent: exports_agent.ID.make(agent) });
+      if (model !== undefined)
+        yield* result.switchModel({ sessionID: input.sessionID, model });
+      return yield* result.prompt({
+        id: input.id,
+        sessionID: input.sessionID,
+        text: evaluated.text,
+        files: input.files,
+        agents: input.agents,
+        skills: input.skills,
+        delivery: input.delivery,
+        resume: input.resume
+      });
+    }),
+    shell: Effect.fn("Session.shell")(function* (input) {
+      const session = yield* result.get(input.sessionID);
+      yield* shellLocks.withLock(input.sessionID)(Effect.gen(function* () {
+        activeShells.add(input.sessionID);
+        yield* execution.awaitIdle(input.sessionID);
+        const started = yield* Effect.gen(function* () {
+          const shell = yield* exports_shell.Service;
+          return yield* shell.create({ command: input.command, cwd: session.location.directory, timeout: 0 });
+        }).pipe(Effect.provide(locations.get(session.location)));
+        yield* bus.publish(SessionEvent.Shell.Started, {
+          sessionID: input.sessionID,
+          shell: started
+        }, { id: input.id });
+        const completed = yield* Effect.gen(function* () {
+          const shell = yield* exports_shell.Service;
+          const terminal = yield* shell.wait(started.id).pipe(Effect.map((info) => ({ info, retained: true })), Effect.catchTag("Shell.NotFoundError", () => Effect.succeed({ info: synthesizeTerminalShellInfo(started), retained: false })));
+          const output = terminal.retained ? yield* shell.output(started.id, { limit: SHELL_MAX_CAPTURE_BYTES }).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed(missingShellOutput()))) : missingShellOutput();
+          return { shell: terminal.info, output };
+        }).pipe(Effect.provide(locations.get(session.location)));
+        yield* bus.publish(SessionEvent.Shell.Ended, {
+          sessionID: input.sessionID,
+          shell: completed.shell,
+          output: completed.output
+        });
+      }).pipe(Effect.ensuring(Effect.gen(function* () {
+        activeShells.delete(input.sessionID);
+        yield* execution.wake(input.sessionID);
+      }))));
+    }),
+    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.list()).find((item) => item.id === 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.catch(() => Effect.succeed(undefined)));
+      if (!info)
+        return yield* new DestinationNotFoundError({ directory });
+      if (info.type !== "Directory")
+        return yield* new DestinationNotDirectoryError({ directory });
+      if (current.location.directory === directory && current.location.workspaceID === input.workspaceID)
+        return;
+      const project = yield* projects.resolve(directory);
+      yield* persistProject(project);
+      if ((yield* execution.active).has(input.sessionID)) {
+        yield* execution.interrupt(input.sessionID);
+        yield* execution.awaitIdle(input.sessionID);
+      }
+      yield* bus.publish(SessionEvent.Moved, {
+        sessionID: input.sessionID,
+        location: exports_location.Ref.make({ directory, workspaceID: input.workspaceID }),
+        projectID: project.id,
+        subpath: RelativePath.make(path.relative(project.directory, directory).replaceAll("\\", "/"))
+      }, { location: current.location });
+    }),
+    compact: Effect.fn("Session.compact")(function* (input) {
+      yield* result.get(input.sessionID);
+      const inputID = input.id ?? exports_message.ID.create();
+      const admitted = yield* exports_pending.admitCompaction(db, bus, {
+        id: inputID,
+        sessionID: input.sessionID
+      }).pipe(Effect.catchDefect((defect) => defect instanceof exports_pending.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 ?? exports_message.ID.create();
+      const admittedInput = exports_pending.Message.make({
+        type: "synthetic",
+        data: {
+          text: input.text,
+          description: input.description,
+          metadata: input.metadata
+        },
+        delivery: input.delivery ?? "steer"
+      });
+      const admitted = yield* exports_pending.admit(db, bus, {
+        id: inputID,
+        sessionID: input.sessionID,
+        input: admittedInput
+      }).pipe(Effect.catchDefect((defect) => defect instanceof exports_pending.LifecycleConflict ? new SyntheticConflictError({ sessionID: input.sessionID, inputID }) : Effect.die(defect)));
+      if (admitted.type !== "synthetic" || !exports_pending.equivalent(admitted, { sessionID: input.sessionID, input: admittedInput }))
+        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(Effect.gen(function* () {
+      yield* execution.interrupt(sessionID);
+      if (options?.continue && (yield* exports_pending.has(db, sessionID, "any")))
+        yield* execution.wake(sessionID);
+    }))),
+    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* exports_revert.stage({ session, messageID: input.messageID, files: input.files }).pipe(Effect.provideService(exports_database.Service, database), Effect.provideService(exports_bus.Service, bus), 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* exports_revert.clear(session).pipe(Effect.provideService(exports_bus.Service, bus), 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;
+}));
+function missingShellOutput() {
+  const output = "Shell command output is no longer available.";
+  return {
+    output,
+    cursor: Buffer.byteLength(output),
+    size: Buffer.byteLength(output),
+    truncated: false
+  };
+}
+function synthesizeTerminalShellInfo(started) {
+  return {
+    ...started,
+    status: "killed",
+    time: { ...started.time, completed: Date.now() }
+  };
+}
+var resolvePrompt = Effect.fn("Session.resolvePrompt")(function* (input, image, skills) {
+  const fs = yield* FSUtil.Service;
+  const files = input.files ? yield* Effect.forEach(input.files, (file) => materializeAttachment(fs, file, image), { concurrency: 8 }) : undefined;
+  const requested = input.skills;
+  const selected = yield* Effect.gen(function* () {
+    if (!requested?.length)
+      return;
+    const available = yield* (yield* skills).list();
+    return yield* Effect.forEach(requested, (attachment) => {
+      const skill = available.find((item) => item.id === attachment.id);
+      if (!skill)
+        return Effect.fail(new SkillNotFoundError({ skill: attachment.id }));
+      return Effect.succeed({
+        id: skill.id,
+        name: skill.name,
+        text: exports_skill.toModelOutput(skill, []),
+        mention: attachment.mention
+      });
+    });
+  });
+  return Prompt.make({ text: input.text, agents: input.agents, files, skills: selected?.length ? selected : undefined });
+});
+var MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+var materializeAttachment = Effect.fn("Session.materializeAttachment")(function* (fs, input, image) {
+  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, image);
+  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, image) {
+  if (!mime.startsWith("image/"))
+    return { data: Base64.make(data), mime };
+  const service = yield* image;
+  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: layer.pipe(Layer.orDie),
+  deps: [
+    exports_job.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, PendingInputConflictError, SkillNotFoundError, DestinationNotFoundError, DestinationNotDirectoryError, MessageNotFoundError, Service, node, exports_session };