@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-jzg6c2d5.js

@@ -0,0 +1,109 @@
+// src/database/migration/20260127222353_familiar_lady_ursula.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260127222353_familiar_lady_ursula",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`project\` (
+          \`id\` text PRIMARY KEY,
+          \`worktree\` text NOT NULL,
+          \`vcs\` text,
+          \`name\` text,
+          \`icon_url\` text,
+          \`icon_color\` text,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`time_initialized\` integer,
+          \`sandboxes\` text NOT NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`message\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_message_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`part\` (
+          \`id\` text PRIMARY KEY,
+          \`message_id\` text NOT NULL,
+          \`session_id\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_part_message_id_message_id_fk\` FOREIGN KEY (\`message_id\`) REFERENCES \`message\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`permission\` (
+          \`project_id\` text PRIMARY KEY,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`data\` text NOT NULL,
+          CONSTRAINT \`fk_permission_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`session\` (
+          \`id\` text PRIMARY KEY,
+          \`project_id\` text NOT NULL,
+          \`parent_id\` text,
+          \`slug\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`title\` text NOT NULL,
+          \`version\` text NOT NULL,
+          \`share_url\` text,
+          \`summary_additions\` integer,
+          \`summary_deletions\` integer,
+          \`summary_files\` integer,
+          \`summary_diffs\` text,
+          \`revert\` text,
+          \`permission\` text,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          \`time_compacting\` integer,
+          \`time_archived\` integer,
+          CONSTRAINT \`fk_session_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`todo\` (
+          \`session_id\` text NOT NULL,
+          \`content\` text NOT NULL,
+          \`status\` text NOT NULL,
+          \`priority\` text NOT NULL,
+          \`position\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          CONSTRAINT \`todo_pk\` PRIMARY KEY(\`session_id\`, \`position\`),
+          CONSTRAINT \`fk_todo_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`session_share\` (
+          \`session_id\` text PRIMARY KEY,
+          \`id\` text NOT NULL,
+          \`secret\` text NOT NULL,
+          \`url\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          CONSTRAINT \`fk_session_share_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`CREATE INDEX \`message_session_idx\` ON \`message\` (\`session_id\`);`);
+      yield* tx.run(`CREATE INDEX \`part_message_idx\` ON \`part\` (\`message_id\`);`);
+      yield* tx.run(`CREATE INDEX \`part_session_idx\` ON \`part\` (\`session_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_project_idx\` ON \`session\` (\`project_id\`);`);
+      yield* tx.run(`CREATE INDEX \`session_parent_idx\` ON \`session\` (\`parent_id\`);`);
+      yield* tx.run(`CREATE INDEX \`todo_session_idx\` ON \`todo\` (\`session_id\`);`);
+    });
+  }
+};
+var _20260127222353_familiar_lady_ursula_default = migration;
+
+export { _20260127222353_familiar_lady_ursula_default };

package/dist/chunks/worktree-k56d8zdx.js

@@ -0,0 +1,294 @@
+import {
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  Service74,
+  node79
+} from "./worktree-z82wee6n.js";
+import {
+  ID15,
+  Service73,
+  node78
+} from "./worktree-7vcja736.js";
+import {
+  NotFoundError9
+} from "./worktree-k7d0894y.js";
+import {
+  Service72,
+  node77
+} from "./worktree-3bgy0jaw.js";
+import {
+  match2
+} from "./worktree-y1fvbwt7.js";
+import {
+  Service71,
+  node76
+} from "./worktree-xmc8nah8.js";
+import {
+  Service77,
+  node82
+} from "./worktree-r05k2dy1.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/permission.ts
+var exports_permission2 = {};
+__export(exports_permission2, {
+  AskResult: () => AskResult2,
+  AssertInput: () => AssertInput2,
+  BlockedError: () => BlockedError2,
+  CorrectedError: () => CorrectedError2,
+  DeclinedError: () => DeclinedError2,
+  Effect: () => PermissionEffect,
+  Event: () => Event17,
+  ID: () => ID13,
+  NotFoundError: () => NotFoundError8,
+  Permission: () => exports_permission2,
+  Reply: () => Reply3,
+  ReplyInput: () => ReplyInput2,
+  Request: () => Request3,
+  Rule: () => Rule3,
+  Ruleset: () => Ruleset2,
+  Service: () => Service70,
+  Source: () => Source5,
+  evaluate: () => evaluate2,
+  merge: () => merge2,
+  node: () => node75
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Deferred, Effect, Layer, Schema } from "effect";
+import { Permission } from "@opencode/schema/permission";
+import { Rule as Rule3, Ruleset as Ruleset2 } from "@opencode/schema/permission";
+import { Event as Event17 } from "@opencode/schema/permission";
+var PermissionEffect = Permission.Effect;
+var missingAgentPermissions = [{ action: "*", resource: "*", effect: "deny" }];
+var ID13 = Permission.ID;
+var Source5 = Permission.Source;
+var RequestFields = {
+  sessionID: Permission.Request.fields.sessionID,
+  action: Permission.Request.fields.action,
+  resources: Permission.Request.fields.resources,
+  save: Permission.Request.fields.save,
+  metadata: Permission.Request.fields.metadata,
+  source: Permission.Request.fields.source
+};
+var Request3 = Permission.Request;
+var Reply3 = Permission.Reply;
+var AssertInput2 = Schema.Struct({
+  id: ID13.pipe(Schema.optional),
+  ...RequestFields,
+  agent: ID15.pipe(Schema.optional)
+}).annotate({ identifier: "Permission.AssertInput" });
+var ReplyInput2 = Schema.Struct({
+  requestID: ID13,
+  reply: Reply3,
+  message: Schema.String.pipe(Schema.optional)
+}).annotate({ identifier: "Permission.ReplyInput" });
+var AskResult2 = Schema.Struct({
+  id: ID13,
+  effect: Permission.Effect
+}).annotate({ identifier: "Permission.AskResult" });
+
+class DeclinedError2 extends Schema.TaggedError()("Permission.DeclinedError", {}) {
+}
+
+class CorrectedError2 extends Schema.TaggedError()("Permission.CorrectedError", {
+  feedback: Schema.String
+}) {
+}
+
+class BlockedError2 extends Schema.TaggedError()("Permission.BlockedError", {
+  rules: Permission.Ruleset,
+  permission: Schema.String,
+  resources: Schema.Array(Schema.String),
+  reason: Schema.String.pipe(Schema.optional)
+}) {
+  get message() {
+    return this.reason ?? `Permission denied: ${this.permission}`;
+  }
+}
+
+class NotFoundError8 extends Schema.TaggedError()("Permission.NotFoundError", {
+  requestID: ID13
+}) {
+}
+function evaluate2(action, resource, ...rulesets) {
+  return rulesets.flat().findLast((rule) => match2(action, rule.action) && match2(resource, rule.resource)) ?? {
+    action,
+    resource: "*",
+    effect: "ask"
+  };
+}
+function merge2(...rulesets) {
+  return rulesets.flat();
+}
+
+class Service70 extends Context.Service()("@opencode/Permission") {
+}
+var layer = Layer.effect(Service70, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const location = yield* Service74;
+  const agents = yield* Service73;
+  const sessions = yield* Service72;
+  const saved = yield* Service71;
+  const hooks = yield* Service77;
+  const pending = new Map;
+  yield* Effect.addFinalizer(() => Effect.forEach(pending.values(), (item) => Deferred.fail(item.deferred, new DeclinedError2), {
+    discard: true
+  }).pipe(Effect.ensuring(Effect.sync(() => {
+    pending.clear();
+  }))));
+  const savedRules = Effect.fnUntraced(function* () {
+    return (yield* saved.list({ projectID: location.project.id })).map((item) => ({
+      action: item.action,
+      resource: item.resource,
+      effect: "allow"
+    }));
+  });
+  const configured = Effect.fnUntraced(function* (sessionID, agentID) {
+    const session = yield* sessions.get(sessionID);
+    if (!session)
+      return yield* new NotFoundError9({ sessionID });
+    const agent = yield* agents.resolve(agentID ?? session.agent);
+    return agent?.permissions ?? missingAgentPermissions;
+  });
+  function denied(input, rules) {
+    return input.resources.some((resource) => evaluate2(input.action, resource, rules).effect === "deny");
+  }
+  function relevant(input, rules) {
+    return rules.filter((rule) => match2(input.action, rule.action));
+  }
+  const evaluateInput = Effect.fnUntraced(function* (input) {
+    const rules = yield* configured(input.sessionID, input.agent);
+    if (denied(input, rules))
+      return { effect: "deny", rules };
+    const all = [...rules, ...yield* savedRules()];
+    const effects = input.resources.map((resource) => evaluate2(input.action, resource, all).effect);
+    const effect = effects.includes("ask") ? "ask" : "allow";
+    const event = yield* hooks.trigger("permission", "evaluate", {
+      sessionID: input.sessionID,
+      agent: input.agent,
+      action: input.action,
+      resources: input.resources,
+      metadata: input.metadata,
+      source: input.source,
+      effect
+    });
+    return { effect: event.effect, message: event.message, rules: all };
+  });
+  function request(input, message) {
+    return {
+      id: input.id ?? ID13.create(),
+      sessionID: input.sessionID,
+      action: input.action,
+      resources: input.resources,
+      save: input.save,
+      metadata: input.metadata,
+      source: input.source,
+      message
+    };
+  }
+  const create = (request, agent) => Effect.uninterruptible(Effect.gen(function* () {
+    const deferred = yield* Deferred.make();
+    const item = { request, agent, deferred };
+    if (pending.has(request.id))
+      return yield* Effect.die(new Error(`Duplicate pending permission ID: ${request.id}`));
+    pending.set(request.id, item);
+    yield* bus.publish(Permission.Event.Asked, request).pipe(Effect.onError(() => Effect.sync(() => pending.delete(request.id))));
+    return item;
+  }));
+  const ask = Effect.fn("Permission.ask")(function* (input) {
+    const result = yield* evaluateInput(input);
+    const value = request(input, result.message);
+    if (result.effect === "ask")
+      yield* create(value, input.agent);
+    return { id: value.id, effect: result.effect };
+  });
+  const assert = Effect.fn("Permission.assert")((input) => Effect.gen(function* () {
+    const result = yield* evaluateInput(input);
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      if (result.effect === "deny") {
+        return yield* new BlockedError2({
+          rules: relevant(input, result.rules),
+          permission: input.action,
+          resources: input.resources,
+          reason: result.message
+        });
+      }
+      if (result.effect === "allow")
+        return;
+      const item = yield* create(request(input, result.message), input.agent);
+      return yield* restore(Deferred.await(item.deferred)).pipe(Effect.catchTag("Permission.DeclinedError", (error) => Effect.die(error)), Effect.ensuring(Effect.sync(() => {
+        pending.delete(item.request.id);
+      })));
+    }));
+  }));
+  const reply = Effect.fn("Permission.reply")((input) => Effect.uninterruptible(Effect.gen(function* () {
+    const existing = pending.get(input.requestID);
+    if (!existing)
+      return yield* new NotFoundError8({ requestID: input.requestID });
+    yield* bus.publish(Permission.Event.Replied, {
+      sessionID: existing.request.sessionID,
+      requestID: existing.request.id,
+      reply: input.reply
+    });
+    if (input.reply === "reject") {
+      yield* Deferred.fail(existing.deferred, input.message ? new CorrectedError2({ feedback: input.message }) : new DeclinedError2);
+      pending.delete(input.requestID);
+      for (const [id, item] of pending) {
+        if (item.request.sessionID !== existing.request.sessionID)
+          continue;
+        yield* bus.publish(Permission.Event.Replied, {
+          sessionID: item.request.sessionID,
+          requestID: item.request.id,
+          reply: "reject"
+        });
+        yield* Deferred.fail(item.deferred, new DeclinedError2);
+        pending.delete(id);
+      }
+      return;
+    }
+    if (input.reply === "always" && existing.request.save?.length) {
+      yield* saved.add({
+        projectID: location.project.id,
+        action: existing.request.action,
+        resources: existing.request.save
+      });
+    }
+    yield* Deferred.succeed(existing.deferred, undefined);
+    pending.delete(input.requestID);
+    if (input.reply !== "always" || !existing.request.save?.length)
+      return;
+    for (const [id, item] of pending) {
+      const result = yield* evaluateInput({ ...item.request, agent: item.agent }).pipe(Effect.catchTag("Session.NotFoundError", () => Effect.undefined));
+      if (result?.effect !== "allow")
+        continue;
+      yield* bus.publish(Permission.Event.Replied, {
+        sessionID: item.request.sessionID,
+        requestID: item.request.id,
+        reply: "always"
+      });
+      yield* Deferred.succeed(item.deferred, undefined);
+      pending.delete(id);
+    }
+  })));
+  const list = Effect.fn("Permission.list")(function* () {
+    return Array.from(pending.values(), (item) => item.request);
+  });
+  const get = Effect.fn("Permission.get")(function* (id) {
+    return pending.get(id)?.request;
+  });
+  const forSession = Effect.fn("Permission.forSession")(function* (sessionID) {
+    return Array.from(pending.values(), (item) => item.request).filter((request) => request.sessionID === sessionID);
+  });
+  return Service70.of({ ask, assert, reply, get, forSession, list });
+}));
+var node75 = makeLocationNode({
+  service: Service70,
+  layer,
+  deps: [node84, node79, node78, node77, node76, node82]
+});
+
+export { PermissionEffect, ID13, Source5, Request3, Reply3, AssertInput2, ReplyInput2, AskResult2, DeclinedError2, CorrectedError2, BlockedError2, NotFoundError8, evaluate2, merge2, Service70, node75, exports_permission2, Rule3, Ruleset2, Event17 };

package/dist/chunks/worktree-k65ezx0v.js

@@ -0,0 +1,117 @@
+import {
+  Service55
+} from "./worktree-ccrec4q8.js";
+import {
+  unavailable3
+} from "./worktree-eaj1djv9.js";
+import {
+  AbsolutePath2
+} from "./worktree-922hggd3.js";
+import {
+  File2,
+  Service78
+} from "./worktree-t2pd0szj.js";
+import {
+  Service74
+} from "./worktree-z82wee6n.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/config/plugin/instruction.ts
+var exports_instruction = {};
+__export(exports_instruction, {
+  ConfigInstructionPlugin: () => exports_instruction,
+  Plugin: () => Plugin30
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { dirname, join } from "path";
+import { Effect, PubSub, Semaphore, Stream } from "effect";
+var Plugin30 = define({
+  id: "opencode.config.instruction",
+  effect: Effect.fn(function* () {
+    const discovery = yield* Service78;
+    if (!discovery.project && !discovery.global)
+      return;
+    yield* Effect.gen(function* () {
+      const fs = yield* FSUtil.Service;
+      const global = yield* Global.Service;
+      const location = yield* Service74;
+      const watcher = yield* Service55;
+      const changes = yield* PubSub.sliding(1);
+      const lock = Semaphore.makeUnsafe(1);
+      const start = yield* fs.resolve(location.directory);
+      const root = yield* fs.resolve(location.project.directory);
+      const home = yield* fs.resolve(global.home);
+      const project = discovery.project && FSUtil.contains(root, start);
+      const stop = FSUtil.contains(home, start) ? home : root;
+      const globalFile = yield* fs.resolve(join(global.config, "AGENTS.md"));
+      const loaded = { current: { type: "available", files: [] } };
+      const publish = (update) => PubSub.publish(changes, update.path).pipe(Effect.asVoid);
+      const candidates = [
+        ...discovery.global ? [globalFile] : [],
+        ...project ? ancestorDirectories(start, stop).map((directory) => join(directory, "AGENTS.md")).filter((file) => discovery.global || file !== globalFile) : []
+      ];
+      for (const path of new Set(candidates)) {
+        const updates = yield* watcher.subscribe({ path, type: "file" });
+        yield* updates.pipe(Stream.runForEach(publish), Effect.forkScoped({ startImmediately: true }));
+      }
+      const read = Effect.fn("ConfigInstructionPlugin.read")(function* (path) {
+        const content = yield* fs.readFileStringSafe(path);
+        if (content !== undefined)
+          return new File2({ path: AbsolutePath2.make(path), content });
+        yield* Effect.logDebug("instruction file skipped", { path, reason: "unavailable" });
+      });
+      const globalSource = Effect.fn("ConfigInstructionPlugin.globalSource")(function* () {
+        if (!discovery.global)
+          return [];
+        const file = yield* read(globalFile);
+        return file ? [file] : [];
+      });
+      const projectSource = Effect.fn("ConfigInstructionPlugin.projectSource")(function* () {
+        if (!project)
+          return [];
+        const walked = yield* Effect.forEach(yield* fs.up({ targets: ["AGENTS.md"], start, stop }), fs.resolve);
+        const discovered = new Set(walked.filter((file) => discovery.global || file !== globalFile));
+        const files = yield* Effect.forEach(discovered, read, { concurrency: "unbounded" });
+        if (files.some((file) => file === undefined))
+          return unavailable3;
+        return files.filter((file) => file !== undefined);
+      });
+      const isolate = (source, effect) => effect.pipe(Effect.catchCause((cause) => Effect.logWarning("failed to load instruction source", { source, cause }).pipe(Effect.as(unavailable3))));
+      const refresh = Effect.fn("ConfigInstructionPlugin.refresh")(function* (file) {
+        const sources = yield* Effect.all({
+          global: isolate("global", globalSource()),
+          project: isolate("project", projectSource())
+        });
+        loaded.current = Array.isArray(sources.global) && Array.isArray(sources.project) ? { type: "available", files: [...sources.global, ...sources.project] } : { type: "unavailable" };
+        if (!file)
+          return;
+        yield* Effect.logDebug("instructions rescanned", {
+          file,
+          instructions: loaded.current.type === "available" ? loaded.current.files.map((item) => item.path) : "unavailable"
+        });
+      }, (effect, ..._args) => lock.withPermit(effect));
+      const updates = yield* PubSub.subscribe(changes);
+      yield* Stream.fromSubscription(updates).pipe(Stream.debounce("100 millis"), Stream.runForEach((file) => refresh(file).pipe(Effect.andThen(discovery.reload()))), Effect.forkScoped({ startImmediately: true }));
+      yield* refresh();
+      yield* discovery.transform((editor) => {
+        if (loaded.current.type === "unavailable") {
+          editor.unavailable();
+          return;
+        }
+        for (const file of loaded.current.files)
+          editor.add(file);
+      });
+    }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to activate instruction source", { cause }).pipe(Effect.andThen(discovery.transform((editor) => editor.unavailable())), Effect.asVoid)));
+  })
+});
+function ancestorDirectories(start, stop) {
+  if (start === stop)
+    return [start];
+  return [start, ...ancestorDirectories(dirname(start), stop)];
+}
+
+export { Plugin30, exports_instruction };

package/dist/chunks/worktree-k7d0894y.js

@@ -0,0 +1,147 @@
+import {
+  SessionMessage2
+} from "./worktree-gftt206x.js";
+import {
+  SessionSchema2
+} from "./worktree-2f04pwep.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session/error.ts
+var exports_error2 = {};
+__export(exports_error2, {
+  AgentNotFoundError: () => AgentNotFoundError2,
+  AttachmentError: () => AttachmentError2,
+  BusyError: () => BusyError2,
+  CompactionConflictError: () => CompactionConflictError2,
+  ForkEmptyError: () => ForkEmptyError2,
+  InboxConflictError: () => InboxConflictError2,
+  MessageDecodeError: () => MessageDecodeError2,
+  MessageIncompleteError: () => MessageIncompleteError2,
+  MessageNotAssistantError: () => MessageNotAssistantError2,
+  MessageNotFoundError: () => MessageNotFoundError2,
+  MessageToolIncompleteError: () => MessageToolIncompleteError2,
+  NotFoundError: () => NotFoundError9,
+  PromptConflictError: () => PromptConflictError2,
+  SessionErrors: () => exports_error2,
+  SkillNotFoundError: () => SkillNotFoundError2,
+  StepFailedError: () => StepFailedError2,
+  SyntheticConflictError: () => SyntheticConflictError2,
+  UserInterruptedError: () => UserInterruptedError2
+});
+import { Schema } from "effect";
+import { Agent } from "@opencode/schema/agent";
+import { Skill } from "@opencode/schema/skill";
+import { SessionError } from "@opencode/schema/session-error";
+
+class NotFoundError9 extends Schema.TaggedError()("Session.NotFoundError", {
+  sessionID: SessionSchema2.ID
+}) {
+}
+
+class MessageNotFoundError2 extends Schema.TaggedError()("Session.MessageNotFoundError", {
+  sessionID: SessionSchema2.ID,
+  messageID: SessionMessage2.ID
+}) {
+}
+
+class MessageNotAssistantError2 extends Schema.TaggedError()("Session.MessageNotAssistantError", {
+  sessionID: SessionSchema2.ID,
+  messageID: SessionMessage2.ID
+}) {
+}
+
+class MessageIncompleteError2 extends Schema.TaggedError()("Session.MessageIncompleteError", {
+  sessionID: SessionSchema2.ID,
+  messageID: SessionMessage2.ID
+}) {
+}
+
+class MessageToolIncompleteError2 extends Schema.TaggedError()("Session.MessageToolIncompleteError", {
+  sessionID: SessionSchema2.ID,
+  messageID: SessionMessage2.ID
+}) {
+}
+
+class ForkEmptyError2 extends Schema.TaggedError()("Session.ForkEmptyError", {
+  sessionID: SessionSchema2.ID
+}) {
+  get message() {
+    return `Cannot fork empty session: ${this.sessionID}`;
+  }
+}
+
+class MessageDecodeError2 extends Schema.TaggedError()("Session.MessageDecodeError", {
+  sessionID: SessionSchema2.ID,
+  messageID: SessionMessage2.ID
+}) {
+  get message() {
+    return `Failed to decode message ${this.messageID} in session ${this.sessionID}`;
+  }
+}
+
+class AgentNotFoundError2 extends Schema.TaggedError()("Session.AgentNotFoundError", {
+  sessionID: SessionSchema2.ID,
+  agent: Agent.ID
+}) {
+  get message() {
+    return `Agent not found: "${this.agent}"`;
+  }
+}
+
+class StepFailedError2 extends Schema.TaggedError()("Session.StepFailedError", {
+  error: SessionError.Error
+}) {
+  get message() {
+    return this.error.message;
+  }
+}
+
+class UserInterruptedError2 extends Schema.TaggedError()("Session.UserInterruptedError", {}) {
+  get message() {
+    return "Session interrupted by user";
+  }
+}
+
+class PromptConflictError2 extends Schema.TaggedError()("Session.PromptConflictError", {
+  sessionID: SessionSchema2.ID,
+  messageID: SessionMessage2.ID
+}) {
+}
+
+class SyntheticConflictError2 extends Schema.TaggedError()("Session.SyntheticConflictError", {
+  sessionID: SessionSchema2.ID,
+  inputID: SessionMessage2.ID
+}) {
+}
+
+class AttachmentError2 extends Schema.TaggedError()("Session.AttachmentError", {
+  uri: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CompactionConflictError2 extends Schema.TaggedError()("Session.CompactionConflictError", {
+  sessionID: SessionSchema2.ID,
+  inputID: SessionMessage2.ID
+}) {
+}
+
+class BusyError2 extends Schema.TaggedError()("Session.BusyError", {
+  sessionID: SessionSchema2.ID
+}) {
+}
+
+class InboxConflictError2 extends Schema.TaggedError()("Session.InboxConflictError", {
+  sessionID: SessionSchema2.ID,
+  inboxID: SessionMessage2.ID
+}) {
+}
+
+class SkillNotFoundError2 extends Schema.TaggedError()("Session.SkillNotFoundError", {
+  skill: Skill.ID
+}) {
+}
+
+export { NotFoundError9, MessageNotFoundError2, MessageNotAssistantError2, MessageIncompleteError2, MessageToolIncompleteError2, ForkEmptyError2, MessageDecodeError2, AgentNotFoundError2, StepFailedError2, UserInterruptedError2, PromptConflictError2, SyntheticConflictError2, AttachmentError2, CompactionConflictError2, BusyError2, InboxConflictError2, SkillNotFoundError2, exports_error2 };

package/dist/chunks/worktree-k8wahcmx.js

@@ -0,0 +1,33 @@
+import {
+  Service35
+} from "./worktree-vkez6a4k.js";
+import {
+  awaitActivation2
+} from "./worktree-1x11rq2a.js";
+import {
+  SkillNotFoundError2
+} from "./worktree-k7d0894y.js";
+import {
+  Service39
+} from "./worktree-5ycqwtsz.js";
+import {
+  __export
+} from "./worktree-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* Service35;
+  const skills = yield* awaitActivation2.pipe(Effect.andThen(Service39), 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 };