@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-h1rn3ct5.js

@@ -0,0 +1,214 @@
+import {
+  Service79,
+  node84
+} from "./repository-8m31s27t.js";
+import {
+  Service66,
+  node70
+} from "./repository-6wjjjhy6.js";
+import {
+  ID9,
+  Service61,
+  node65
+} from "./repository-b5n11jz6.js";
+import {
+  AgentNotFoundError2
+} from "./repository-3x8gcmrs.js";
+import {
+  combine2
+} from "./repository-rhjbct0v.js";
+import {
+  provenance2
+} from "./repository-msq0jde0.js";
+import {
+  entriesForRunner2
+} from "./repository-j8g7a3j8.js";
+import {
+  Service60,
+  node64
+} from "./repository-1n274c67.js";
+import {
+  merge2
+} from "./repository-ykpr0q7c.js";
+import {
+  Service73,
+  node77
+} from "./repository-gtm8txn9.js";
+import {
+  make14
+} from "./repository-w96k05dy.js";
+import {
+  Service39,
+  node43
+} from "./repository-q8rd9qhs.js";
+import {
+  Service38,
+  node42
+} from "./repository-a8ygtzbq.js";
+import {
+  Service41,
+  node46
+} from "./repository-39fveamk.js";
+import {
+  Service30,
+  node35
+} from "./repository-zr3d0gxg.js";
+import {
+  Service29,
+  node34
+} from "./repository-eprkdeyt.js";
+import {
+  Service32,
+  node37
+} from "./repository-ext3js1z.js";
+import {
+  Service33,
+  node38
+} from "./repository-2m84dfka.js";
+import {
+  Service35,
+  node40
+} from "./repository-pctvcs1g.js";
+import {
+  Service34,
+  node39
+} from "./repository-g0dr00md.js";
+import {
+  Service51,
+  node55
+} from "./repository-y973e7aq.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/context.ts
+var exports_context = {};
+__export(exports_context, {
+  Service: () => Service28,
+  SessionContext: () => exports_context,
+  node: () => node33
+});
+import { Model } from "@opencode/schema/model";
+import { Context, Effect, Layer } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+class Service28 extends Context.Service()("@opencode/SessionContext") {
+}
+var layer = Layer.effect(Service28, Effect.gen(function* () {
+  const agents = yield* Service61;
+  const builtins = yield* Service38;
+  const catalog = yield* Service73;
+  const db = (yield* Service79).db;
+  const discovery = yield* Service39;
+  const entries = yield* Service35;
+  const location = yield* Service66;
+  const mcpInstructions = yield* Service29;
+  const mcpTools = yield* Service30;
+  const models = yield* Service51;
+  const request = yield* Service34;
+  const referenceInstructions = yield* Service32;
+  const skillInstructions = yield* Service33;
+  const store = yield* Service60;
+  const registry = yield* Service41;
+  const resolveModel = (session) => models.resolve(session, catalog.model.available);
+  const selectTitle = Effect.fn("SessionContext.selectTitle")(function* (session) {
+    const agent = yield* agents.get(ID9.make("title"));
+    if (!agent)
+      return;
+    const primary = yield* resolveModel(session).pipe(Effect.orElseSucceed(() => {
+      return;
+    }));
+    const info = yield* Effect.gen(function* () {
+      if (agent.model)
+        return yield* catalog.model.get(agent.model.providerID, agent.model.id);
+      if (!primary)
+        return;
+      return yield* catalog.model.small(primary.ref.providerID);
+    });
+    const variant = agent.model?.variant ?? MINIMAL_REASONING_VARIANTS.find((id) => info?.variants.some((item) => item.id === id));
+    const preferred = info && (yield* resolveModel({
+      ...session,
+      model: Model.Ref.make({
+        providerID: info.providerID,
+        id: info.id,
+        ...variant ? { variant } : {}
+      })
+    }).pipe(Effect.orElseSucceed(() => {
+      return;
+    })));
+    const selected = preferred ?? primary;
+    if (!selected)
+      return;
+    return { agent, primary, selected };
+  });
+  const select = Effect.fn("SessionContext.select")(function* (sessionID) {
+    const session = yield* store.get(sessionID);
+    if (!session)
+      return yield* Effect.die(new Error(`Session not found: ${sessionID}`));
+    if (session.location.directory !== location.directory || session.location.workspaceID !== location.workspaceID)
+      return yield* Effect.interrupt;
+    yield* mcpTools.flush;
+    const agent = yield* agents.select(session.agent);
+    if (!agent.info)
+      return yield* new AgentNotFoundError2({ sessionID: session.id, agent: session.agent ?? agent.id });
+    const loaded = yield* Effect.all({
+      tools: registry.snapshot(merge2(agent.info.permissions, session.permissions ?? [])),
+      builtins: builtins.load(sessionID),
+      discovery: discovery.load(),
+      skills: skillInstructions.load(agent),
+      references: referenceInstructions.load(),
+      mcp: mcpInstructions.load(agent),
+      entries: entries.load(sessionID)
+    }, { concurrency: "unbounded" });
+    return {
+      session,
+      agent: { ...agent, info: agent.info },
+      instructions: combine2([
+        loaded.builtins,
+        make14(loaded.tools.codeModeCatalog),
+        loaded.discovery,
+        loaded.skills,
+        loaded.references,
+        loaded.mcp,
+        loaded.entries
+      ]),
+      tools: loaded.tools
+    };
+  });
+  const load = Effect.fn("SessionContext.load")(function* (selection) {
+    const model = yield* resolveModel(selection.session);
+    const history = yield* entriesForRunner2(db, selection.session.id, selection.instructions, provenance2(model) ?? "local");
+    return {
+      session: selection.session,
+      agent: selection.agent,
+      model,
+      initial: history.initial,
+      messages: history.entries.map((entry) => entry.message),
+      tools: selection.tools
+    };
+  });
+  return Service28.of({ select, load, resolveModel, selectTitle, request });
+}));
+var MINIMAL_REASONING_VARIANTS = ["none", "minimal", "low"].map((id) => Model.VariantID.make(id));
+var node33 = makeLocationNode({
+  service: Service28,
+  layer,
+  deps: [
+    node65,
+    node77,
+    node84,
+    node42,
+    node43,
+    node40,
+    node70,
+    node34,
+    node35,
+    node37,
+    node55,
+    node39,
+    node64,
+    node38,
+    node46
+  ]
+});
+
+export { Service28, node33, exports_context };

package/dist/chunks/repository-h4e6z68e.js

@@ -0,0 +1,51 @@
+import {
+  AbsolutePath2
+} from "./repository-922hggd3.js";
+import {
+  Service66
+} from "./repository-6wjjjhy6.js";
+import {
+  Service44
+} from "./repository-smnv2tch.js";
+import {
+  Service18
+} from "./repository-cedwm630.js";
+import {
+  observe2
+} from "./repository-qsdy395h.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/plugin/worktree.ts
+var exports_worktree = {};
+__export(exports_worktree, {
+  ConfigWorktreePlugin: () => exports_worktree,
+  Plugin: () => Plugin16
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+import path from "path";
+import { Global } from "@opencode/util/global";
+var Plugin16 = define({
+  id: "opencode.config.worktree",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service44;
+    const location = yield* Service66;
+    const global = yield* Global.Service;
+    const worktrees = yield* Service18;
+    const loaded = yield* observe2(config, ctx.event, worktrees.reload());
+    yield* worktrees.transform((editor) => {
+      for (const entry of loaded.entries) {
+        if (entry.type !== "document" || !entry.info.worktree)
+          continue;
+        const directory = entry.info.worktree.directory;
+        editor.configure({
+          directory: AbsolutePath2.make(directory.startsWith("~/") ? path.join(global.home, directory.slice(2)) : path.resolve(location.project.canonical, directory))
+        });
+      }
+    });
+  })
+});
+
+export { Plugin16, exports_worktree };

package/dist/chunks/repository-h6vf3j39.js

@@ -0,0 +1,14 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/util/token.ts
+var exports_token = {};
+__export(exports_token, {
+  Token: () => exports_token,
+  estimate: () => estimate2
+});
+var CHARS_PER_TOKEN = 4;
+var estimate2 = (input) => Math.max(0, Math.round(input.length / CHARS_PER_TOKEN));
+
+export { estimate2, exports_token };

package/dist/chunks/repository-h71w788e.js

@@ -0,0 +1,54 @@
+import {
+  makeUnsafe2
+} from "./repository-y71avatq.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/plugin/update.ts
+var exports_update = {};
+__export(exports_update, {
+  PluginUpdate: () => exports_update,
+  Service: () => Service6,
+  node: () => node8
+});
+import { Clock, Context, Effect, Exit, Layer, Option, PubSub, Stream } from "effect";
+import { Npm } from "@opencode/util/npm";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+var interval = 24 * 60 * 60 * 1000;
+
+class Service6 extends Context.Service()("@opencode/PluginUpdate") {
+}
+var layer = Layer.effect(Service6, Effect.gen(function* () {
+  const npm = yield* Npm.Service;
+  const locks = makeUnsafe2();
+  const status = new Map;
+  const changes = yield* PubSub.unbounded();
+  return Service6.of({
+    check: (target, options) => locks.withLock(target)(Effect.gen(function* () {
+      const checkedAt = yield* Clock.currentTimeMillis;
+      const current = status.get(target);
+      if (!options?.refresh && current && checkedAt - current.checkedAt < interval)
+        return current.outdated;
+      const outdated = yield* npm.check(target).pipe(Effect.tapCause((cause) => Effect.logWarning("failed to check plugin update", { target, cause })), Effect.option);
+      const value = Option.getOrElse(outdated, () => current?.outdated ?? false);
+      status.set(target, { outdated: value, checkedAt });
+      if ((current?.outdated ?? false) !== value)
+        yield* PubSub.publish(changes, { target, outdated: value, updating: false });
+      return value;
+    })),
+    update: (target) => locks.withLock(target)(Effect.gen(function* () {
+      const outdated = status.get(target)?.outdated ?? false;
+      yield* PubSub.publish(changes, { target, outdated, updating: true });
+      yield* npm.update(target).pipe(Effect.tap(() => Effect.sync(() => status.delete(target))), Effect.onExit((exit) => PubSub.publish(changes, {
+        target,
+        outdated: Exit.isSuccess(exit) ? false : outdated,
+        updating: false
+      })));
+    })),
+    changes: () => Stream.fromPubSub(changes)
+  });
+}));
+var node8 = makeGlobalNode({ service: Service6, layer, deps: [Npm.node] });
+
+export { Service6, node8, exports_update };

package/dist/chunks/repository-h90k734v.js

@@ -0,0 +1,33 @@
+import {
+  Service52
+} from "./repository-1bvekr7f.js";
+import {
+  awaitActivation2
+} from "./repository-jqh9b0xq.js";
+import {
+  SkillNotFoundError2
+} from "./repository-3x8gcmrs.js";
+import {
+  Service40
+} from "./repository-9xb0s4b9.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/skill.ts
+var exports_skill4 = {};
+__export(exports_skill4, {
+  SessionSkill: () => exports_skill4,
+  get: () => get4
+});
+import { Effect } from "effect";
+var get4 = Effect.fn("SessionSkill.get")(function* (input) {
+  const instances = yield* Service52;
+  const skills = yield* awaitActivation2.pipe(Effect.andThen(Service40), instances.provide(input.session));
+  const skill = yield* skills.get(input.skill);
+  if (!skill)
+    return yield* new SkillNotFoundError2({ skill: input.skill });
+  return skill;
+});
+
+export { get4, exports_skill4 };

package/dist/chunks/repository-haj0byqn.js

@@ -0,0 +1,61 @@
+import {
+  useragent2
+} from "./repository-j4z2qnee.js";
+import {
+  ID16
+} from "./repository-pye8sh6e.js";
+
+// src/plugin/provider/gitlab.ts
+import os from "os";
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var GitLabPlugin2 = define({
+  id: "opencode.provider.gitlab",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "gitlab-ai-provider")
+        return;
+      const mod = yield* Effect.promise(() => import("gitlab-ai-provider"));
+      evt.sdk = mod.createGitLab({
+        ...evt.options,
+        instanceUrl: typeof evt.options.instanceUrl === "string" ? evt.options.instanceUrl : process.env.GITLAB_INSTANCE_URL ?? "https://gitlab.com",
+        apiKey: typeof evt.options.apiKey === "string" ? evt.options.apiKey : process.env.GITLAB_TOKEN,
+        aiGatewayHeaders: {
+          "User-Agent": `${useragent2(ctx.app)} gitlab-ai-provider/${mod.VERSION} (${os.platform()} ${os.release()}; ${os.arch()})`,
+          "anthropic-beta": "context-1m-2025-08-07",
+          ...evt.options.aiGatewayHeaders
+        },
+        featureFlags: {
+          duo_agent_platform_agentic_chat: true,
+          duo_agent_platform: true,
+          ...evt.options.featureFlags
+        }
+      });
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== ID16.gitlab)
+        return;
+      const featureFlags = typeof evt.options.featureFlags === "object" && evt.options.featureFlags ? evt.options.featureFlags : {};
+      const id = evt.model.modelID ?? evt.model.id;
+      if (id.startsWith("duo-workflow-")) {
+        const gitlab = yield* Effect.promise(() => import("gitlab-ai-provider"));
+        const workflowRef = typeof evt.model.settings?.workflowRef === "string" ? evt.model.settings.workflowRef : undefined;
+        const workflowDefinition = typeof evt.model.settings?.workflowDefinition === "string" ? evt.model.settings.workflowDefinition : undefined;
+        const language = evt.sdk.workflowChat(gitlab.isWorkflowModel(id) ? id : "duo-workflow", {
+          featureFlags,
+          workflowDefinition
+        });
+        if (workflowRef)
+          language.selectedModelRef = workflowRef;
+        evt.language = language;
+        return;
+      }
+      evt.language = evt.sdk.agenticChat(id, {
+        aiGatewayHeaders: evt.options.aiGatewayHeaders,
+        featureFlags
+      });
+    }));
+  })
+});
+
+export { GitLabPlugin2 };

package/dist/chunks/repository-he3792rk.js

@@ -0,0 +1,157 @@
+import {
+  typeFollowing2
+} from "./repository-2a5m3afh.js";
+import {
+  RelativePath2
+} from "./repository-922hggd3.js";
+import {
+  Service66
+} from "./repository-6wjjjhy6.js";
+import {
+  Service65
+} from "./repository-3mdgf1e2.js";
+import {
+  InvalidPatternError2,
+  Service25
+} from "./repository-ztky2hbm.js";
+import {
+  DEFAULT_SEARCH_LIMIT2,
+  DEFAULT_SEARCH_TIMEOUT_MS2,
+  GrepInput2,
+  Entry2,
+  Match2
+} from "./repository-j38hs89b.js";
+import {
+  Service58
+} from "./repository-ykpr0q7c.js";
+import {
+  Service19
+} from "./repository-pvp1cs2e.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/tool/plugin/grep.ts
+var exports_grep = {};
+__export(exports_grep, {
+  GrepTool: () => exports_grep,
+  Input: () => Input10,
+  Output: () => Output6,
+  Plugin: () => Plugin27,
+  name: () => name10,
+  toModelContent: () => toModelContent4
+});
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema } from "effect";
+import path from "path";
+var name10 = "grep";
+var Input10 = Schema.Struct({
+  pattern: GrepInput2.fields.pattern.check(Schema.isMinLength(1, { message: "Pattern must not be empty" })).annotate({
+    description: "Regular expression or literal text to match in file contents."
+  }),
+  path: Schema.optionalKey(RelativePath2).annotate({
+    description: "File or directory to search. Defaults to the current working directory."
+  }),
+  include: GrepInput2.fields.include.annotate({
+    description: 'Glob pattern to filter files (for example, "*.js" or "*.{ts,tsx}")'
+  }),
+  literal: GrepInput2.fields.literal.annotate({
+    description: "Treat `pattern` as exact text instead of a regular expression (default: false)."
+  }),
+  caseSensitive: GrepInput2.fields.caseSensitive.annotate({
+    description: "Use case-sensitive matching (default: true)."
+  }),
+  limit: GrepInput2.fields.limit.annotate({
+    description: `Maximum number of matching lines to return (default: ${DEFAULT_SEARCH_LIMIT2})`
+  })
+});
+var Output6 = Schema.Array(Match2);
+var toModelContent4 = (matches, truncated = false) => {
+  const lines = matches.length === 0 ? ["No matches found"] : [`Found ${matches.length} matches`];
+  let current = "";
+  for (const match of matches) {
+    if (current !== match.entry.path) {
+      if (current)
+        lines.push("");
+      current = match.entry.path;
+      lines.push(`${match.entry.path}:`);
+    }
+    lines.push(`  Line ${match.line}: ${match.text}`);
+  }
+  if (truncated)
+    lines.push("", `(Results are truncated: showing first ${matches.length} results. Consider using a more specific path or pattern.)`);
+  return lines.join(`
+`);
+};
+var Plugin27 = {
+  id: "opencode.tool.grep",
+  effect: Effect.fn("GrepTool.Plugin")(function* (ctx) {
+    const environment = yield* Service65;
+    const ripgrep = yield* Service25;
+    const location = yield* Service66;
+    const access = yield* Service19;
+    const permission = yield* Service58;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name10,
+      options: { codemode: false },
+      description: "Search file contents using ripgrep's regular expression syntax or literal text matching. Use it to locate specific code, symbols, or text patterns, and narrow searches with `path` or `include`. Returns matching file paths, line numbers, and line previews.",
+      input: Input10,
+      output: Output6,
+      execute: (input, context) => Effect.gen(function* () {
+        const source = { type: "tool", messageID: context.messageID, id: context.id };
+        const target = yield* access.resolve({ path: input.path ?? "." });
+        yield* access.authorizeExternal([target], context);
+        yield* permission.assert({
+          action: name10,
+          resources: [input.pattern],
+          save: ["*"],
+          metadata: {
+            root: ".",
+            path: input.path,
+            include: input.include,
+            literal: input.literal,
+            caseSensitive: input.caseSensitive,
+            limit: input.limit
+          },
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+        const root = target.absolute;
+        const type = yield* typeFollowing2(environment.files, root).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${input.path ?? "."}` }))));
+        const cwd = type === "directory" ? root : path.dirname(root);
+        const limit = input.limit ?? DEFAULT_SEARCH_LIMIT2;
+        const matches = yield* ripgrep.grep({
+          cwd,
+          pattern: input.pattern,
+          file: type === "file" ? path.basename(root) : undefined,
+          include: input.include,
+          literal: input.literal,
+          caseSensitive: input.caseSensitive,
+          limit: limit + 1
+        }).pipe(Effect.timeoutOrElse({
+          duration: DEFAULT_SEARCH_TIMEOUT_MS2,
+          orElse: () => Effect.fail(new ToolFailure({
+            message: `Search timed out after ${DEFAULT_SEARCH_TIMEOUT_MS2 / 1000} seconds. Consider using a more specific path or pattern.`
+          }))
+        }), Effect.map((result) => result.map((match) => Match2.make({
+          ...match,
+          entry: Entry2.make({
+            ...match.entry,
+            path: RelativePath2.make(path.relative(location.directory, path.resolve(cwd, match.entry.path)))
+          })
+        }))));
+        return { matches: matches.slice(0, limit), truncated: matches.length > limit };
+      }).pipe(Effect.map((result) => ({
+        output: result.matches,
+        content: toModelContent4(result.matches.map((match) => ({
+          ...match,
+          entry: { ...match.entry, path: path.resolve(location.directory, match.entry.path) }
+        })), result.truncated),
+        metadata: { matches: result.matches.length, truncated: result.truncated }
+      })), Effect.mapError((error) => error instanceof ToolFailure ? error : error instanceof InvalidPatternError2 ? new ToolFailure({ message: `Invalid regex pattern: ${error.message}` }) : new ToolFailure({ message: `Unable to grep for ${input.pattern}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name10, Input10, Output6, toModelContent4, Plugin27, exports_grep };

package/dist/chunks/repository-hj2f0bzq.js

@@ -0,0 +1,96 @@
+import {
+  latest2,
+  Service44
+} from "./repository-smnv2tch.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/plugin/warming.ts
+var exports_warming = {};
+__export(exports_warming, {
+  Plugin: () => Plugin39,
+  WarmingPlugin: () => exports_warming
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Clock, Duration, Effect, Scope } from "effect";
+var defaults = {
+  prompt: "This is a keep-alive request. Do not perform any work or use tools. Reply with exactly: OK",
+  interval: Duration.minutes(4),
+  duration: Duration.minutes(30)
+};
+var Plugin39 = define({
+  id: "opencode.warming",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service44;
+    const loadSettings = Effect.fn("WarmingPlugin.loadSettings")(function* () {
+      const warming = latest2(yield* config.entries(), "warming");
+      if (!warming)
+        return;
+      const settings = warming === true ? defaults : { ...defaults, ...warming };
+      const interval = Duration.toMillis(settings.interval);
+      const duration = Duration.toMillis(settings.duration);
+      if (Number.isFinite(interval) && interval > 0 && Number.isFinite(duration) && duration > 0)
+        return settings;
+      yield* Effect.logWarning("warming interval and duration must be finite positive durations");
+    });
+    const scope = yield* Scope.Scope;
+    const sessions = new Map;
+    const loop = Effect.fn("WarmingPlugin.loop")(function* (sessionID) {
+      const current = sessions.get(sessionID);
+      if (!current)
+        return;
+      const now = yield* Clock.currentTimeMillis;
+      const next = Math.min(current.last + Duration.toMillis(current.settings.interval), current.expires);
+      if (now < next) {
+        yield* Effect.sleep(Duration.millis(next - now));
+        return yield* loop(sessionID);
+      }
+      if (now >= current.expires) {
+        sessions.delete(sessionID);
+        return;
+      }
+      const last = current.last;
+      yield* Effect.logInfo("warming session", { sessionID, last });
+      yield* ctx.session.generate({ sessionID, prompt: current.settings.prompt }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to warm session", { sessionID, cause })));
+      const latest = sessions.get(sessionID);
+      if (latest === current && latest.last === last)
+        latest.last = yield* Clock.currentTimeMillis;
+      return yield* loop(sessionID);
+    });
+    const hook = (event) => Effect.gen(function* () {
+      const active = sessions.get(event.sessionID);
+      const settings = yield* loadSettings();
+      if (!settings) {
+        sessions.delete(event.sessionID);
+        return;
+      }
+      const message = event.messages.at(-1);
+      if (message?.role === "user" && message.content.length === 1 && message.content[0]?.type === "text" && (message.content[0].text === active?.settings.prompt || message.content[0].text === settings.prompt)) {
+        if (active)
+          active.settings = settings;
+        return;
+      }
+      const now = yield* Clock.currentTimeMillis;
+      const duration = Duration.toMillis(settings.duration);
+      if (active) {
+        active.last = now;
+        active.expires = now + duration;
+        active.settings = settings;
+        return;
+      }
+      sessions.set(event.sessionID, { last: now, expires: now + duration, settings });
+      yield* Effect.logInfo("scheduled session warming", {
+        sessionID: event.sessionID,
+        interval: settings.interval,
+        expires: now + duration
+      });
+      yield* loop(event.sessionID).pipe(Effect.catchCause((cause) => Effect.logError("session warming loop failed", { sessionID: event.sessionID, cause })), Effect.forkIn(scope));
+    });
+    yield* ctx.session.hook("context", hook);
+    yield* ctx.session.hook("compaction", hook);
+    yield* ctx.session.hook("generate", hook);
+  })
+});
+
+export { Plugin39, exports_warming };