@opencode-ai/core 0.0.0-dev-18672 → 0.0.0-dev-18677

package/dist/chunks/job-yyjmndg0.js

@@ -0,0 +1,483 @@
+import {
+  exports_projector
+} from "./job-2xxqbh3j.js";
+import {
+  exports_session
+} from "./job-cs1gk7aw.js";
+import {
+  exports_execution
+} from "./job-zjdkpeq1.js";
+import {
+  exports_inbox
+} from "./job-fjvbp1rw.js";
+import {
+  exports_generate
+} from "./job-xgv25zxy.js";
+import {
+  exports_instruction_entry
+} from "./job-0j6yxnr1.js";
+import {
+  exports_supervisor_service
+} from "./job-s33fw6zm.js";
+import {
+  exports_model_transport
+} from "./job-tjrfm0xh.js";
+import {
+  exports_environment
+} from "./job-6ky7rqk7.js";
+import {
+  Slug
+} from "./job-df3v2q6j.js";
+import {
+  exports_skill
+} from "./job-v50dw4p6.js";
+import {
+  exports_command
+} from "./job-jp8kwwgf.js";
+import {
+  exports_app
+} from "./job-50jxp3hw.js";
+import {
+  exports_location_service_map
+} from "./job-zdkg1k91.js";
+import {
+  exports_store
+} from "./job-h9bbwcgd.js";
+import {
+  exports_history
+} from "./job-n5tqbq9v.js";
+import {
+  exports_instruction_state
+} from "./job-hxcd35r2.js";
+import {
+  fromRow
+} from "./job-264e1nfp.js";
+import {
+  AttachmentError,
+  BusyError,
+  CompactionConflictError,
+  ForkEmptyError,
+  InboxConflictError,
+  MessageDecodeError,
+  MessageIncompleteError,
+  MessageNotAssistantError,
+  MessageNotFoundError,
+  MessageToolIncompleteError,
+  NotFoundError,
+  PromptConflictError,
+  SkillNotFoundError,
+  SyntheticConflictError
+} from "./job-cgqn2mrm.js";
+import {
+  SessionMessageTable,
+  SessionTable
+} from "./job-q606pcse.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_location
+} from "./job-dv2qtrbh.js";
+import {
+  exports_project
+} from "./job-587cy5wm.js";
+import {
+  exports_bus
+} from "./job-wcdz88tf.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_session2 = {};
+__export(exports_session2, {
+  node: () => node,
+  SyntheticConflictError: () => SyntheticConflictError,
+  SkillNotFoundError: () => SkillNotFoundError,
+  SessionSchema: () => SessionSchema,
+  Session: () => exports_session2,
+  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, 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 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";
+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 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 }) {
+}
+
+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 sessions = yield* exports_session.make((ref) => locations.get(ref));
+  const admission = yield* exports_inbox.Service;
+  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 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);
+      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: (sessionID) => sessions.forSession(sessionID).get(),
+    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: (input) => sessions.forSession(input.sessionID).view(input),
+    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: (input) => sessions.forSession(input.sessionID).message(input.messageID),
+    updateMessage: (input) => sessions.forSession(input.sessionID).updateMessage(input),
+    context: Effect.fn("Session.context")(function* (sessionID) {
+      yield* result.get(sessionID);
+      return yield* store.context(sessionID);
+    }),
+    inbox: (sessionID) => sessions.forSession(sessionID).inbox(),
+    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))),
+    prompt: (input) => sessions.forSession(input.sessionID).prompt(input),
+    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: (input) => sessions.forSession(input.sessionID).shell(input),
+    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: (input) => sessions.forSession(input.sessionID).switchAgent(input),
+    switchModel: (input) => sessions.forSession(input.sessionID).switchModel(input),
+    rename: (input) => sessions.forSession(input.sessionID).rename(input),
+    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 }))));
+      }));
+      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* admission.admit({
+          id: SessionMessage.ID.create(),
+          sessionID: input.sessionID,
+          item
+        }).pipe(Effect.orDie);
+      }));
+      yield* execution.wake(input.sessionID);
+    }),
+    compact: (input) => sessions.forSession(input.sessionID).compact(input),
+    wait: (sessionID) => sessions.forSession(sessionID).wait(),
+    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: (sessionID) => sessions.forSession(sessionID).resume(),
+    synthetic: (input) => sessions.forSession(input.sessionID).synthetic(input),
+    interrupt: (sessionID, options) => sessions.forSession(sessionID).interrupt(options),
+    revert: {
+      stage: (input) => sessions.forSession(input.sessionID).revert.stage(input),
+      clear: (sessionID) => sessions.forSession(sessionID).revert.clear(),
+      commit: (sessionID) => sessions.forSession(sessionID).revert.commit()
+    }
+  });
+  return result;
+}));
+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_inbox.node,
+    exports_location_service_map.node,
+    exports_projector.node,
+    FSUtil.node,
+    Global.node,
+    exports_app.node
+  ]
+});
+
+export { ListAnchor, ListInput, DestinationNotFoundError, DestinationNotDirectoryError, DestinationUnavailableError, Service, node, exports_session2 as exports_session };

package/dist/chunks/{job-1n129eaz.js → job-yypfb467.js}

@@ -1,6 +1,6 @@
 import {
   exports_supervisor
-} from "./job-mw6h1mdq.js";
+} from "./job-910ht18m.js";
 import {
   exports_location_watcher_policy
 } from "./job-6wkzvma0.js";
@@ -9,13 +9,13 @@ import {
 } from "./job-ns0sdez7.js";
 import {
   exports_location
-} from "./job-s6f237ya.js";
+} from "./job-dv2qtrbh.js";
 import {
   exports_git
-} from "./job-dyj7wa6j.js";
+} from "./job-6jx6ecw1.js";
 import {
   exports_bus
-} from "./job-18pyn74f.js";
+} from "./job-wcdz88tf.js";
 import {
   __export
 } from "./job-rvfvac9x.js";

package/dist/chunks/{job-byr8vxta.js → job-z136m2k9.js}

@@ -6,7 +6,7 @@ import {
 } from "./job-g5tvq2z7.js";
 import {
   exports_sdk
-} from "./job-ynndvamt.js";
+} from "./job-g9rvq1b5.js";
 import {
   AbsolutePath
 } from "./job-j07kk359.js";

package/dist/chunks/{job-fvv9e4db.js → job-z3fjxbtv.js}

@@ -1,17 +1,17 @@
 import {
   exports_model
-} from "./job-fr340fdw.js";
+} from "./job-dh8ckpgp.js";
 import {
   exports_integration
-} from "./job-48pk08ny.js";
+} from "./job-dmvhg2kz.js";
 import {
   exports_permission
-} from "./job-hz615c35.js";
+} from "./job-bv2z3evd.js";
 import {
   AgentNotFoundError,
   StepFailedError,
   UserInterruptedError
-} from "./job-fb7nfzf2.js";
+} from "./job-cgqn2mrm.js";
 
 // src/session/to-session-error.ts
 import { AIError, ToolFailure } from "@opencode-ai/ai";

package/dist/chunks/{job-y8zz706c.js → job-z61mvmr2.js}

@@ -2,23 +2,23 @@ import {
   fileDiff
 } from "./job-c77ad0vh.js";
 import {
-  exports_file_mutation
-} from "./job-jhtwpwqf.js";
+  exports_formatter
+} from "./job-khy57ct7.js";
 import {
   exports_location_mutation
-} from "./job-9zvvrfjj.js";
-import {
-  exports_environment1 as exports_environment
-} from "./job-6v09q7yq.js";
+} from "./job-b2jn2z3c.js";
 import {
   exports_permission
-} from "./job-hz615c35.js";
+} from "./job-bv2z3evd.js";
 import {
-  exports_formatter
-} from "./job-a4hq1eed.js";
+  exports_file_mutation
+} from "./job-7s30ncaq.js";
+import {
+  exports_environment1 as exports_environment
+} from "./job-46crkez1.js";
 import {
   exports_location
-} from "./job-s6f237ya.js";
+} from "./job-dv2qtrbh.js";
 import {
   __export
 } from "./job-rvfvac9x.js";

package/dist/chunks/{job-t8avpjr7.js → job-zjdkpeq1.js}

@@ -1,36 +1,36 @@
-import {
-  exports_run_coordinator
-} from "./job-7khw64yh.js";
 import {
   exports_runner
 } from "./job-2m0hgr65.js";
 import {
   exports_inbox
-} from "./job-ecft2zb7.js";
+} from "./job-fjvbp1rw.js";
+import {
+  exports_run_coordinator
+} from "./job-41qzzbpz.js";
 import {
   toSessionError
-} from "./job-fvv9e4db.js";
+} from "./job-z3fjxbtv.js";
+import {
+  exports_location_service_map
+} from "./job-zdkg1k91.js";
 import {
   exports_store
-} from "./job-qhne0bfz.js";
+} from "./job-h9bbwcgd.js";
 import {
   UserInterruptedError
-} from "./job-fb7nfzf2.js";
+} from "./job-cgqn2mrm.js";
 import {
   SessionEvent
 } from "./job-a83yvq99.js";
-import {
-  exports_location_service_map
-} from "./job-zdkg1k91.js";
 import {
   exports_job
-} from "./job-d7tex8vw.js";
+} from "./job-2hnk029s.js";
 import {
   exports_bus
-} from "./job-18pyn74f.js";
+} from "./job-wcdz88tf.js";
 import {
   exports_database
-} from "./job-hs06t8ty.js";
+} from "./job-rp954h3j.js";
 import {
   __export
 } from "./job-rvfvac9x.js";
@@ -105,6 +105,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
   return Service.of({
     active: coordinator.active,
+    isActive: coordinator.isActive,
     interrupt: (sessionID, options) => Effect.gen(function* () {
       const interrupted = yield* coordinator.interrupt(sessionID, "user");
       if (!options?.continue)
@@ -128,6 +129,7 @@ var node = makeGlobalNode({
 });
 var noopLayer = Layer.succeed(Service, Service.of({
   active: Effect.succeed(new Set),
+  isActive: () => Effect.succeed(false),
   resume: () => Effect.void,
   wake: () => Effect.void,
   interrupt: () => Effect.succeed(false),

package/dist/chunks/{job-jw46cgkj.js → job-zq3dpz3n.js}

@@ -1,6 +1,6 @@
 import {
   exports_skill
-} from "./job-pm83fkmc.js";
+} from "./job-v50dw4p6.js";
 import {
   exports_instructions
 } from "./job-ec8vrfw5.js";

package/dist/chunks/{job-xz4ftad6.js → job-zr6va574.js}

@@ -6,10 +6,10 @@ import {
 } from "./job-bbhffenw.js";
 import {
   exports_config
-} from "./job-zg4nw3xx.js";
+} from "./job-pkn40a12.js";
 import {
   exports_location
-} from "./job-s6f237ya.js";
+} from "./job-dv2qtrbh.js";
 import {
   __export
 } from "./job-rvfvac9x.js";

package/dist/chunks/{job-ph8sywta.js → job-zrccwvnf.js}

@@ -1,9 +1,9 @@
+import {
+  configuredSettings
+} from "./job-jr5hd5p5.js";
 import {
   iife
 } from "./job-ehj9csmv.js";
-import {
-  configuredSettings
-} from "./job-fzbykpt4.js";
 import {
   exports_app
 } from "./job-50jxp3hw.js";