@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-2402vzrj.js

@@ -0,0 +1,175 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/repository.ts
+var exports_repository = {};
+__export(exports_repository, {
+  InvalidBranchError: () => InvalidBranchError3,
+  InvalidReferenceError: () => InvalidReferenceError2,
+  Repository: () => exports_repository,
+  UnsupportedLocalRepositoryError: () => UnsupportedLocalRepositoryError2,
+  cacheIdentity: () => cacheIdentity2,
+  cachePath: () => cachePath2,
+  isFile: () => isFile2,
+  isRemote: () => isRemote2,
+  parse: () => parse4,
+  parseRemote: () => parseRemote2,
+  same: () => same2,
+  validateBranch: () => validateBranch3
+});
+import path from "path";
+import { fileURLToPath } from "url";
+import { Schema } from "effect";
+
+class InvalidReferenceError2 extends Schema.TaggedError()("RepositoryInvalidReferenceError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class UnsupportedLocalRepositoryError2 extends Schema.TaggedError()("RepositoryUnsupportedLocalRepositoryError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class InvalidBranchError3 extends Schema.TaggedError()("RepositoryInvalidBranchError", {
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+function parse4(input) {
+  const cleaned = normalizeInput(input);
+  if (!cleaned)
+    return;
+  const githubPrefixed = cleaned.match(/^github:([^/\s]+)\/([^/\s]+)$/);
+  if (githubPrefixed)
+    return buildRemote({ host: "github.com", segments: [githubPrefixed[1], githubPrefixed[2]] });
+  if (!cleaned.includes("://")) {
+    const scp = cleaned.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/);
+    if (scp)
+      return buildRemote({ host: scp[1], segments: parts(scp[2]), remote: cleaned });
+    const direct = parts(cleaned);
+    if (direct.length >= 2 && hostLike(direct[0]))
+      return buildRemote({ host: direct[0], segments: direct.slice(1) });
+    if (direct.length === 2)
+      return buildRemote({ host: "github.com", segments: direct });
+  }
+  try {
+    const url = new URL(cleaned);
+    if (url.protocol === "file:")
+      return buildFile({ url, remote: cleaned });
+    const segments = parts(url.pathname);
+    return buildRemote({
+      host: url.host,
+      segments,
+      remote: url.host === "github.com" ? githubRemote(segments.join("/")) : cleaned,
+      protocol: url.protocol
+    });
+  } catch {
+    return;
+  }
+}
+function parseRemote2(input) {
+  const reference = parse4(input);
+  if (!reference) {
+    throw new InvalidReferenceError2({
+      repository: input,
+      message: "Repository must be a git URL, host/path reference, or GitHub owner/repo shorthand"
+    });
+  }
+  if (!isRemote2(reference)) {
+    throw new UnsupportedLocalRepositoryError2({
+      repository: input,
+      message: "Local file repositories are not supported"
+    });
+  }
+  return reference;
+}
+function validateBranch3(branch) {
+  if (/^[A-Za-z0-9/_.-]+$/.test(branch) && !branch.startsWith("-") && !branch.includes(".."))
+    return;
+  throw new InvalidBranchError3({
+    branch,
+    message: "Branch must contain only alphanumeric characters, /, _, ., and -, and cannot start with - or contain .."
+  });
+}
+function isFile2(reference) {
+  return reference.protocol === "file:";
+}
+function isRemote2(reference) {
+  return !isFile2(reference);
+}
+function cachePath2(root, reference, branch) {
+  const base = path.join(root, ...reference.host.split(":"), ...reference.segments);
+  return branch ? `${base}@${encodeURIComponent(branch)}` : base;
+}
+function cacheIdentity2(reference) {
+  return `${reference.host}/${reference.path}`;
+}
+function same2(left, right) {
+  return cacheIdentity2(left) === cacheIdentity2(right);
+}
+function normalizeInput(input) {
+  return input.trim().replace(/^git\+/, "").replace(/#.*$/, "").replace(/\/+$/, "");
+}
+function trimGitSuffix(input) {
+  return input.replace(/\.git$/, "");
+}
+function parts(input) {
+  return input.split("/").map((item) => trimGitSuffix(item.trim())).filter(Boolean);
+}
+function safeHost(input) {
+  return Boolean(input) && !input.startsWith("-") && !/[\s/\\]/.test(input);
+}
+function safeSegment(input) {
+  return input !== "." && input !== ".." && !input.includes(":") && !/[\s/\\]/.test(input);
+}
+function hostLike(input) {
+  return input.includes(".") || input.includes(":") || input === "localhost";
+}
+function withSlash(input) {
+  return input.endsWith("/") ? input : `${input}/`;
+}
+function githubRemote(pathname) {
+  const base = process.env.OPENCODE_REPO_CLONE_GITHUB_BASE_URL;
+  if (!base)
+    return `https://github.com/${pathname}.git`;
+  return new URL(`${pathname}.git`, withSlash(base)).href;
+}
+function buildRemote(input) {
+  const segments = input.segments.map(trimGitSuffix).filter(Boolean);
+  if (!safeHost(input.host) || !segments.length || segments.some((segment) => !safeSegment(segment)))
+    return;
+  const repositoryPath = segments.join("/");
+  const host = input.host.toLowerCase();
+  return {
+    host,
+    path: repositoryPath,
+    segments,
+    owner: segments.length === 2 ? segments[0] : undefined,
+    repo: segments[segments.length - 1],
+    remote: input.remote ?? (host === "github.com" ? githubRemote(repositoryPath) : `https://${host}/${repositoryPath}.git`),
+    label: host === "github.com" && segments.length === 2 ? repositoryPath : `${host}/${repositoryPath}`,
+    protocol: input.protocol
+  };
+}
+function buildFile(input) {
+  const filePath = path.normalize(fileURLToPath(input.url));
+  const segments = filePath.split(/[\\/]+/).filter(Boolean);
+  if (!segments.length)
+    return;
+  return {
+    host: "file",
+    path: filePath,
+    segments: segments.map((segment) => segment.replace(/:$/, "")),
+    owner: undefined,
+    repo: trimGitSuffix(segments[segments.length - 1]),
+    remote: input.remote,
+    label: filePath,
+    protocol: "file:"
+  };
+}
+
+export { InvalidReferenceError2, UnsupportedLocalRepositoryError2, InvalidBranchError3, parse4, parseRemote2, validateBranch3, isFile2, isRemote2, cachePath2, cacheIdentity2, same2, exports_repository };

package/dist/chunks/worktree-249ffbnn.js

@@ -0,0 +1,271 @@
+import {
+  definition2,
+  execute3,
+  normalizeContent2,
+  normalizedName2,
+  effectiveName2
+} from "./worktree-3w5fmr99.js";
+import {
+  create2,
+  catalog2
+} from "./worktree-x43y2vfs.js";
+import {
+  create3
+} from "./worktree-kg06axw8.js";
+import {
+  Service68,
+  node73
+} from "./worktree-nzwzy72p.js";
+import {
+  Service77,
+  node82
+} from "./worktree-r05k2dy1.js";
+import {
+  match2
+} from "./worktree-y1fvbwt7.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/tool.ts
+var exports_tool = {};
+__export(exports_tool, {
+  CallID: () => CallID2,
+  Content: () => Content3,
+  Error: () => Error5,
+  FileContent: () => FileContent3,
+  RegistrationError: () => RegistrationError2,
+  Service: () => Service67,
+  TextContent: () => TextContent2,
+  Tool: () => exports_tool,
+  node: () => node72
+});
+import { CallID as CallID2, Content as Content3, Error as Error5, FileContent as FileContent3, TextContent as TextContent2 } from "@opencode/schema/tool";
+import { ToolDefinition } from "@opencode/ai";
+import { Tool } from "@opencode/schema/tool";
+import { Context, Effect, Layer, Result, Schema, SchemaIssue } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+class RegistrationError2 extends Schema.TaggedError()("Tool.RegistrationError", {
+  name: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service67 extends Context.Service()("@opencode/Tool") {
+}
+var layer = Layer.effect(Service67, Effect.gen(function* () {
+  const hooks = yield* Service77;
+  const image = yield* Service68;
+  const normalizeImages = Effect.fnUntraced(function* (content) {
+    const normalized = yield* Effect.forEach(content, (item) => {
+      if (item.type !== "file" || !item.mime.startsWith("image/"))
+        return Effect.succeed(item);
+      const base64 = /^data:[^,]*;base64,(.*)$/s.exec(item.uri)?.[1];
+      if (base64 === undefined)
+        return Effect.succeed(item);
+      const resource = item.name ?? `${item.mime} tool output`;
+      return image.normalize(resource, { uri: resource, content: base64, encoding: "base64", mime: item.mime }).pipe(Effect.map((result) => ({
+        ...item,
+        uri: `data:${result.mime};base64,${result.content}`,
+        mime: result.mime
+      })), Effect.catchTag("Image.ResizerUnavailableError", () => Effect.succeed(item)), Effect.catchTag("Image.DecodeError", () => Effect.succeed("decode")), Effect.catchTag("Image.SizeError", () => Effect.succeed("size")));
+    });
+    const note = (reason, text) => {
+      const count = normalized.filter((item) => item === reason).length;
+      if (count === 0)
+        return [];
+      return [{ type: "text", text: `[${count} image${count === 1 ? "" : "s"} omitted: ${text}]` }];
+    };
+    return [
+      ...normalized.filter((item) => typeof item !== "string"),
+      ...note("decode", "could not be decoded."),
+      ...note("size", "could not be resized below the image size limit.")
+    ];
+  });
+  const beforeExecute = (name, input, context) => hooks.trigger("tool", "execute.before", {
+    tool: name,
+    sessionID: context.sessionID,
+    agent: context.agent,
+    messageID: context.messageID,
+    id: context.id,
+    input
+  });
+  const executeTool = Effect.fn("Tool.execute")(function* (tool, name, input, context) {
+    const execution = yield* execute3(tool, input, context).pipe(Effect.map((value) => ({ value })), Effect.catchTag("Tool.Error", (failure) => Effect.succeed({ failure })));
+    const base = {
+      tool: name,
+      sessionID: context.sessionID,
+      agent: context.agent,
+      messageID: context.messageID,
+      id: context.id,
+      input
+    };
+    if ("failure" in execution) {
+      const afterEvent = {
+        ...base,
+        status: "error",
+        error: execution.failure
+      };
+      yield* hooks.trigger("tool", "execute.after", afterEvent);
+      return yield* afterEvent.error;
+    }
+    const afterEvent = {
+      ...base,
+      status: "completed",
+      result: {
+        ...execution.value.output === undefined ? {} : { output: execution.value.output },
+        content: execution.value.content,
+        ...execution.value.metadata === undefined ? {} : { metadata: execution.value.metadata }
+      }
+    };
+    yield* hooks.trigger("tool", "execute.after", afterEvent);
+    const afterContent = yield* normalizeImages(normalizeContent2(afterEvent.result.content, afterEvent.result.output));
+    return {
+      ...afterEvent.result.output === undefined ? {} : { output: afterEvent.result.output },
+      content: afterContent,
+      ...afterEvent.result.metadata === undefined ? {} : { metadata: afterEvent.result.metadata }
+    };
+  });
+  const state = create3({
+    name: "tool",
+    initial: () => ({
+      tools: new Map,
+      namespaces: new Map,
+      errors: []
+    }),
+    editor: (editor) => ({
+      list: () => Array.from(editor.tools.values()),
+      get: (id) => editor.tools.get(id),
+      namespace: (namespace) => {
+        const error = namespaceError(namespace.name);
+        if (error) {
+          editor.errors.push({ kind: "namespace", name: namespace.name, namespace: namespace.name, error });
+          return;
+        }
+        editor.namespaces.set(namespace.name, { ...namespace });
+      },
+      add: (tool) => {
+        const error = registrationError(tool);
+        if (error) {
+          editor.errors.push({ kind: "tool", name: tool.name, namespace: tool.options?.namespace, error });
+          return;
+        }
+        const id = effectiveName2(tool);
+        editor.tools.set(id, { ...tool, id, options: tool.options && { ...tool.options } });
+      },
+      update: (id, update) => {
+        const current = editor.tools.get(id);
+        if (!current)
+          return;
+        const tool = { ...current, options: current.options && { ...current.options } };
+        update(tool);
+        tool.name = current.name;
+        tool.id = id;
+        if (tool.options?.namespace !== current.options?.namespace)
+          tool.options = { ...tool.options, namespace: current.options?.namespace };
+        const error = registrationError(tool);
+        if (error) {
+          editor.errors.push({ kind: "tool", name: tool.name, namespace: tool.options?.namespace, error });
+          return;
+        }
+        editor.tools.set(id, tool);
+      },
+      remove: (id) => {
+        editor.tools.delete(id);
+      }
+    }),
+    notify: (value) => Effect.forEach(value.errors, ({ kind, name, namespace, error }) => Effect.logError(`Skipping invalid ${kind} registration`, {
+      name,
+      namespace,
+      error: error.message
+    }), { discard: true })
+  });
+  return Service67.of({
+    transform: state.transform,
+    reload: state.reload,
+    snapshot: Effect.fn("Tool.snapshot")((permissions) => Effect.sync(() => {
+      const active = new Map;
+      const rules = permissions ?? [];
+      for (const [name, tool] of state.get().tools) {
+        if (whollyDisabled(tool.options?.permission ?? name, rules))
+          continue;
+        active.set(name, tool);
+      }
+      const direct = new Map(Array.from(active).filter(([, tool]) => tool.options?.codemode === false));
+      const codeModeTools = new Map(Array.from(active).filter(([, tool]) => tool.options?.codemode !== false));
+      const namespaces = state.get().namespaces;
+      const codeModeInventory = { tools: codeModeTools, namespaces };
+      const codeModeEnabled = !whollyDisabled("execute", rules);
+      const codeModeTool = codeModeEnabled ? create2(codeModeInventory, (name, tool, input, context) => beforeExecute(name, input, context).pipe(Effect.flatMap((event) => executeTool(tool, name, event.input, context)))) : undefined;
+      const codeModeCatalog = codeModeEnabled ? catalog2(codeModeInventory) : undefined;
+      return {
+        ...codeModeCatalog === undefined ? {} : { codeModeCatalog },
+        definitions: [
+          ...Array.from(direct).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, tool]) => definition2(tool)),
+          ...codeModeTool ? [definition2(codeModeTool)] : []
+        ],
+        execute: Effect.fnUntraced(function* (input) {
+          const context = {
+            sessionID: input.sessionID,
+            agent: input.agent,
+            messageID: input.messageID,
+            id: Tool.CallID.make(input.call.id),
+            progress: input.progress ?? (() => Effect.void)
+          };
+          const event = yield* beforeExecute(input.call.name, input.call.input, context);
+          const requested = input.definitions?.get(event.tool);
+          if (!requested && input.definitions && (direct.has(event.tool) || codeModeTool?.name === event.tool))
+            return yield* new Tool.Error({ message: `Tool is not available for this request: ${event.tool}` });
+          const name = requested?.name ?? event.tool;
+          if (name === "execute" && codeModeTool)
+            return yield* executeTool(codeModeTool, name, event.input, context);
+          const tool = direct.get(name);
+          if (tool)
+            return yield* executeTool(tool, name, event.input, context);
+          return yield* new Tool.Error({ message: `Unknown tool: ${name}` });
+        })
+      };
+    }))
+  });
+}));
+var whollyDisabled = (action, rules) => {
+  const rule = rules.findLast((rule) => match2(action, rule.action));
+  return rule?.resource === "*" && rule.effect === "deny";
+};
+var formatSchemaIssue = SchemaIssue.makeFormatterDefault();
+function schemaMakeError(error) {
+  if (error instanceof Error && SchemaIssue.isIssue(error.cause))
+    return formatSchemaIssue(error.cause);
+  return error instanceof Error ? error.message : String(error);
+}
+function registrationError(tool) {
+  const namespace = tool.options?.namespace;
+  if (namespace !== undefined) {
+    const error = namespaceError(namespace);
+    if (error)
+      return error;
+  }
+  const name = normalizedName2(tool);
+  if (!/^[A-Za-z0-9_-]{1,64}$/.test(name))
+    return new RegistrationError2({ name, message: `Invalid tool name: ${name}` });
+  const id = effectiveName2(tool);
+  if (tool.options?.codemode === false && id === "execute")
+    return new RegistrationError2({ name: id, message: 'Tool name "execute" is reserved for CodeMode' });
+  const result = Result.try({
+    try: () => ToolDefinition.make(definition2(tool)),
+    catch: (error) => new RegistrationError2({ name: id, message: `Invalid tool definition ${id}: ${schemaMakeError(error)}` })
+  });
+  return Result.isFailure(result) ? result.failure : undefined;
+}
+function namespaceError(name) {
+  if (name.split(".").every((segment) => /^[A-Za-z0-9_-]{1,64}$/.test(segment)))
+    return;
+  return new RegistrationError2({ name, message: `Invalid tool namespace: ${JSON.stringify(name)}` });
+}
+var node72 = makeLocationNode({
+  service: Service67,
+  layer,
+  deps: [node82, node73]
+});
+
+export { RegistrationError2, Service67, node72, exports_tool, CallID2, Content3, Error5, FileContent3, TextContent2 };

package/dist/chunks/worktree-255fqtq1.js

@@ -0,0 +1,71 @@
+import {
+  parseOption2
+} from "./worktree-5daktx2q.js";
+import {
+  AbsolutePath2
+} from "./worktree-922hggd3.js";
+import {
+  ID6,
+  Name2
+} from "./worktree-5ycqwtsz.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/config/plugin/skill-file.ts
+var exports_skill_file = {};
+__export(exports_skill_file, {
+  SkillFile: () => exports_skill_file,
+  parse: () => parse2
+});
+import path from "path";
+import { Result, Schema, SchemaParser } from "effect";
+var Frontmatter = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  description: Schema.String.pipe(Schema.optional),
+  slash: Schema.Boolean.pipe(Schema.optional),
+  metadata: Schema.Unknown.pipe(Schema.optional)
+});
+var decodeFrontmatter = SchemaParser.decodeUnknownResult(Frontmatter);
+var metadataBoolean = (metadata, key) => {
+  if (metadata === undefined || metadata === null || typeof metadata !== "object" || Array.isArray(metadata)) {
+    return;
+  }
+  const value = Reflect.get(metadata, key);
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value !== "string")
+    return;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true")
+    return true;
+  if (normalized === "false")
+    return false;
+  return;
+};
+function parse2(directory, filepath, content) {
+  const markdown = parseOption2(content);
+  if (!markdown)
+    return { _tag: "Skipped", reason: "markdown" };
+  const decoded = decodeFrontmatter(markdown.data);
+  if (Result.isFailure(decoded))
+    return { _tag: "Skipped", reason: "frontmatter", issue: decoded.failure };
+  const frontmatter = decoded.success;
+  const id = path.dirname(filepath) === directory && path.basename(filepath) !== "SKILL.md" ? path.basename(filepath, ".md") : path.basename(path.dirname(filepath));
+  const slash = metadataBoolean(frontmatter.metadata, "opencode/slash") ?? frontmatter.slash;
+  const autoinvoke = metadataBoolean(frontmatter.metadata, "opencode/autoinvoke");
+  return {
+    _tag: "Parsed",
+    skill: {
+      id: ID6.make(id),
+      name: Name2.make(frontmatter.name ?? id),
+      ...frontmatter.description === undefined ? {} : { description: frontmatter.description },
+      ...slash === undefined ? {} : { slash },
+      ...autoinvoke === undefined ? {} : { autoinvoke },
+      location: AbsolutePath2.make(filepath),
+      content: markdown.content
+    }
+  };
+}
+
+export { parse2, exports_skill_file };

package/dist/chunks/worktree-26tj7vag.js

@@ -0,0 +1,116 @@
+import {
+  SessionEvent2
+} from "./worktree-ec1grn59.js";
+import {
+  toSessionError2
+} from "./worktree-yfjv9t1g.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session/runner/retry.ts
+var exports_retry = {};
+__export(exports_retry, {
+  SessionRunnerRetry: () => exports_retry,
+  isRetryable: () => isRetryable2,
+  make: () => make6,
+  policy: () => policy2,
+  transient: () => transient2
+});
+import { isContextOverflowFailure } from "@opencode/ai";
+import { Clock, Duration, Effect, Pull, Schedule } from "effect";
+function isRetryable2(error) {
+  const override = error.reason.http?.headers["x-should-retry"];
+  if (override === "true")
+    return true;
+  if (override === "false")
+    return false;
+  switch (error.reason._tag) {
+    case "RateLimit":
+    case "ProviderInternal":
+      return true;
+    case "Transport":
+      return error.reason.delivery === undefined || error.reason.delivery === "not-sent";
+    case "InvalidProviderOutput":
+      return error.reason.classification === "incomplete-stream";
+    case "UnknownProvider":
+      return true;
+    case "Authentication":
+    case "QuotaExceeded":
+    case "ContentPolicy":
+    case "InvalidRequest":
+    case "UnsupportedOperation":
+    case "NoRoute":
+      return false;
+    default: {
+      const exhaustive = error.reason;
+      return exhaustive;
+    }
+  }
+}
+var RETRY_AFTER_MAX = Duration.toMillis("15 minutes");
+var retryAfter = (input) => {
+  if (input.cause.reason._tag === "RateLimit" || input.cause.reason._tag === "ProviderInternal")
+    return input.cause.reason.retryAfterMs === undefined ? undefined : Math.min(input.cause.reason.retryAfterMs, RETRY_AFTER_MAX);
+  return;
+};
+var schedule = Schedule.max([Schedule.exponential("2 seconds"), Schedule.recurs(4)]).pipe(Schedule.jittered, Schedule.setInputType(), Schedule.modifyDelay(({ input, duration: delay }) => {
+  const minimum = retryAfter(input);
+  const duration = minimum === undefined ? delay : Duration.max(delay, Duration.millis(minimum));
+  return Effect.succeed(Duration.millis(Math.ceil(Duration.toMillis(duration))));
+}));
+var policy2 = (sessionID) => Effect.gen(function* () {
+  const step = yield* Schedule.toStep(schedule);
+  let attempt = 1;
+  return (input) => Effect.gen(function* () {
+    const now = yield* Clock.currentTimeMillis;
+    const next = yield* step(now, input).pipe(Pull.catchDone(() => Effect.succeed(undefined)));
+    if (!next)
+      return { retry: false };
+    const [, duration] = next;
+    attempt++;
+    const delay = Math.ceil(Duration.toMillis(duration));
+    const event = {
+      sessionID,
+      agent: input.agent,
+      model: input.model,
+      error: input.error,
+      attempt,
+      decision: input.retry ? { retry: true, delay } : { retry: false }
+    };
+    yield* input.hook(event);
+    if (!event.decision.retry)
+      return event.decision;
+    const normalized = Number.isFinite(event.decision.delay) && event.decision.delay >= 0 ? Math.ceil(event.decision.delay) : delay;
+    return { retry: true, attempt, delay: normalized };
+  });
+});
+var transient2 = (decide, input) => (effect) => Effect.retry(effect, {
+  while: (cause) => Effect.gen(function* () {
+    if (isContextOverflowFailure(cause))
+      return false;
+    const decision = yield* decide({ ...input, cause, error: toSessionError2(cause), retry: isRetryable2(cause) });
+    if (!decision.retry)
+      return false;
+    yield* Effect.sleep(decision.delay);
+    return true;
+  })
+});
+var make6 = (bus, sessionID) => Effect.gen(function* () {
+  const decide = yield* policy2(sessionID);
+  const wait = (input) => Effect.gen(function* () {
+    const scheduled = yield* Clock.currentTimeMillis;
+    yield* bus.publish(SessionEvent2.RetryScheduled, {
+      sessionID,
+      assistantMessageID: input.assistantMessageID,
+      attempt: input.decision.attempt,
+      at: scheduled + input.decision.delay,
+      error: input.error
+    });
+    const remaining = Math.max(0, scheduled + input.decision.delay - (yield* Clock.currentTimeMillis));
+    yield* Effect.sleep(Duration.millis(remaining));
+  });
+  return { decide, wait };
+});
+
+export { isRetryable2, policy2, transient2, make6, exports_retry };

package/dist/chunks/worktree-2710q6r3.js

@@ -0,0 +1,20 @@
+// src/event/sql.ts
+import { sqliteTable, text, integer, index, uniqueIndex } from "drizzle-orm/sqlite-core";
+var EventSequenceTable2 = sqliteTable("event_sequence", {
+  aggregate_id: text().notNull().primaryKey(),
+  seq: integer().notNull(),
+  owner_id: text()
+});
+var EventTable2 = sqliteTable("event", {
+  id: text().$type().primaryKey(),
+  aggregate_id: text().notNull().references(() => EventSequenceTable2.aggregate_id, { onDelete: "cascade" }),
+  seq: integer().notNull(),
+  created: integer().notNull().default(0),
+  type: text().notNull(),
+  data: text({ mode: "json" }).$type().notNull()
+}, (table) => [
+  uniqueIndex("event_aggregate_seq_idx").on(table.aggregate_id, table.seq),
+  index("event_aggregate_type_seq_idx").on(table.aggregate_id, table.type, table.seq)
+]);
+
+export { EventSequenceTable2, EventTable2 };