@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-y0x38cee.js

@@ -0,0 +1,28 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/v1/config/provider-options.ts
+var exports_provider_options = {};
+__export(exports_provider_options, {
+  provider: () => provider,
+  model: () => model,
+  ConfigProviderOptionsV1: () => exports_provider_options
+});
+function provider(options) {
+  const headers = options.headers;
+  const body = options.body;
+  const settings = Object.fromEntries(Object.entries(options).filter(([key]) => key !== "headers" && key !== "body"));
+  const headerOverlay = typeof headers === "object" && headers !== null && !Array.isArray(headers) ? Object.fromEntries(Object.entries(headers).filter((entry) => typeof entry[1] === "string")) : undefined;
+  const bodyOverlay = typeof body === "object" && body !== null && !Array.isArray(body) ? { ...body } : undefined;
+  return {
+    settings,
+    headers: headerOverlay,
+    body: bodyOverlay
+  };
+}
+function model(options) {
+  return { ...options };
+}
+
+export { provider, model, exports_provider_options };

package/dist/chunks/ripgrep-y67x6rf6.js

@@ -0,0 +1,19 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/util/wildcard.ts
+var exports_wildcard = {};
+__export(exports_wildcard, {
+  match: () => match,
+  Wildcard: () => exports_wildcard
+});
+function match(input, pattern) {
+  const normalized = input.replaceAll("\\", "/");
+  let escaped = pattern.replaceAll("\\", "/").replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  if (escaped.endsWith(" .*"))
+    escaped = escaped.slice(0, -3) + "( .*)?";
+  return new RegExp("^" + escaped + "$", process.platform === "win32" ? "si" : "s").test(normalized);
+}
+
+export { match, exports_wildcard };

package/dist/chunks/ripgrep-y8rs54ne.js

@@ -0,0 +1,16 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  SessionSchema: () => exports_schema,
+  Info: () => Info,
+  ID: () => ID
+});
+import { Session } from "@opencode-ai/schema/session";
+var ID = Session.ID;
+var Info = Session.Info;
+
+export { ID, Info, exports_schema };

package/dist/chunks/ripgrep-y980s7ka.js

@@ -0,0 +1,174 @@
+import {
+  load
+} from "./ripgrep-dkmkay92.js";
+import {
+  lazy
+} from "./ripgrep-8w9tzfz1.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/filesystem/watcher.ts
+var exports_watcher = {};
+__export(exports_watcher, {
+  testLayer: () => testLayer,
+  node: () => node,
+  nativeNode: () => nativeNode,
+  nativeLayer: () => nativeLayer,
+  layer: () => layer,
+  hasNativeBinding: () => hasNativeBinding,
+  configured: () => configured,
+  Watcher: () => exports_watcher,
+  Test: () => Test,
+  Service: () => Service,
+  Options: () => Options,
+  Native: () => Native,
+  Event: () => Event
+});
+import { createWrapper } from "@parcel/watcher/wrapper";
+import { FileSystem } from "@opencode-ai/schema/filesystem";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { Cause, Context, Effect, Layer, PubSub, RcMap, Schema, Stream } from "effect";
+import { watch as watchFileSystem } from "node:fs";
+import path from "path";
+var SUBSCRIBE_TIMEOUT_MS = 1e4;
+var Event = { Updated: FileSystem.Event.Changed };
+var watcher = lazy(() => {
+  try {
+    return createWrapper(load());
+  } catch {
+    return;
+  }
+});
+function getBackend() {
+  if (process.platform === "win32")
+    return "windows";
+  if (process.platform === "darwin")
+    return "fs-events";
+  if (process.platform === "linux")
+    return "inotify";
+}
+var hasNativeBinding = () => !!watcher();
+
+class Native extends Context.Service()("@opencode/Watcher/Native") {
+}
+var Options = Schema.Struct({
+  enabled: Schema.optional(Schema.Boolean)
+});
+
+class Service extends Context.Service()("@opencode/Watcher") {
+}
+
+class Test extends Context.Service()("@opencode/Watcher/Test") {
+}
+var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
+  if (options?.enabled === false) {
+    return Service.of({ subscribe: () => Effect.succeed(Stream.empty) });
+  }
+  const native = yield* Native;
+  const watchers = yield* RcMap.make({
+    lookup: (key) => Effect.gen(function* () {
+      const pubsub = yield* Effect.acquireRelease(PubSub.unbounded(), (pubsub2) => PubSub.shutdown(pubsub2));
+      const subscription = yield* Effect.acquireRelease(native.subscribe({
+        type: key.type,
+        target: key.target,
+        ignore: key.ignore,
+        publish: (update) => PubSub.publishUnsafe(pubsub, update)
+      }), (subscription2) => subscription2 ? Effect.promise(() => subscription2.unsubscribe()).pipe(Effect.ignoreCause, Effect.andThen(Effect.logInfo("watcher stopped", { path: key.target, type: key.type }))) : Effect.void, { interruptible: true });
+      if (!subscription) {
+        yield* PubSub.shutdown(pubsub);
+        return pubsub;
+      }
+      yield* Effect.logInfo("watcher started", {
+        path: key.target,
+        type: key.type,
+        backend: subscription.backend,
+        ignores: key.ignore.length
+      });
+      return pubsub;
+    })
+  });
+  const subscribe = (input) => {
+    const target = path.resolve(input.path);
+    const ignore = [...new Set(input.type === "directory" ? input.ignore ?? [] : [])].toSorted();
+    return Effect.gen(function* () {
+      yield* Effect.logInfo("watcher subscribe", {
+        path: target,
+        type: input.type,
+        ignores: ignore.length
+      });
+      return Stream.unwrap(Effect.gen(function* () {
+        const pubsub = yield* RcMap.get(watchers, { type: input.type, target, ignore });
+        return Stream.fromPubSub(pubsub);
+      }));
+    });
+  };
+  return Service.of({ subscribe });
+}));
+var testLayer = Layer.effectContext(Effect.gen(function* () {
+  const subscriptions = [];
+  const active = new Set;
+  const native = Native.of({
+    subscribe: (input) => Effect.sync(() => {
+      subscriptions.push(input.type === "file" ? { path: input.target, type: "file" } : input.ignore.length > 0 ? { path: input.target, type: "directory", ignore: input.ignore } : { path: input.target, type: "directory" });
+      active.add(input.publish);
+      return {
+        unsubscribe: () => {
+          active.delete(input.publish);
+          return Promise.resolve();
+        }
+      };
+    })
+  });
+  const context = yield* Layer.build(layer().pipe(Layer.provide(Layer.succeed(Native, native))));
+  const test = Test.of({
+    subscribe: Context.get(context, Service).subscribe,
+    emit: (update) => Effect.sync(() => active.forEach((publish) => publish(update))),
+    subscriptions: () => Effect.sync(() => [...subscriptions])
+  });
+  return Context.empty().pipe(Context.add(Service, test), Context.add(Test, test));
+}));
+var nativeLayer = Layer.succeed(Native, Native.of({
+  subscribe: (input) => {
+    if (input.type === "file") {
+      return Effect.sync(() => {
+        const directory = path.dirname(input.target);
+        const subscription = watchFileSystem(directory, { recursive: false }, (_event, file) => {
+          if (file && path.resolve(directory, file.toString()) !== input.target)
+            return;
+          input.publish({ path: input.target, type: "update" });
+        });
+        if ("on" in subscription && typeof subscription.on === "function") {
+          subscription.on("error", (error) => Effect.runFork(Effect.logError("watcher callback failed", { path: input.target, error })));
+        }
+        return { unsubscribe: () => Promise.resolve(subscription.close()), backend: "node" };
+      });
+    }
+    return subscribeDirectory(watcher(), getBackend(), input.target, input.ignore, input.publish);
+  }
+}));
+var nativeNode = makeGlobalNode({ service: Native, layer: nativeLayer, deps: [] });
+function configured(options) {
+  return makeGlobalNode({ service: Service, layer: layer(options), deps: [nativeNode] });
+}
+var node = configured();
+function subscribeDirectory(native, backend, directory, ignore, publish) {
+  if (!native || !backend) {
+    return Effect.logError("watcher backend not supported", { directory, platform: process.platform }).pipe(Effect.as(undefined));
+  }
+  const callback = (error, updates) => {
+    if (error)
+      Effect.runFork(Effect.logError("watcher callback failed", { error }));
+    for (const update of updates)
+      publish(update);
+  };
+  const pending = native.subscribe(directory, callback, { ignore: [...ignore], backend });
+  return Effect.promise(() => pending).pipe(Effect.map((subscription) => ({ unsubscribe: () => subscription.unsubscribe(), backend })), Effect.onInterrupt(() => Effect.sync(() => {
+    pending.then((subscription) => subscription.unsubscribe()).catch(() => {});
+  })), Effect.timeout(SUBSCRIBE_TIMEOUT_MS), Effect.catchCause((cause) => Effect.logError("failed to subscribe", {
+    directory,
+    cause: Cause.pretty(cause)
+  }).pipe(Effect.as(undefined))));
+}
+
+export { Event, hasNativeBinding, Native, Options, Service, Test, layer, testLayer, nativeLayer, nativeNode, configured, node, exports_watcher };

package/dist/chunks/ripgrep-ydk0tm9b.js

@@ -0,0 +1,286 @@
+import {
+  exports_parse
+} from "./ripgrep-0zs4qnv1.js";
+import {
+  exports_location_mutation
+} from "./ripgrep-0vcm5yws.js";
+import {
+  exports_runtime
+} from "./ripgrep-5rzqpsek.js";
+import {
+  exports_shell
+} from "./ripgrep-93d188hz.js";
+import {
+  exports_tool_output
+} from "./ripgrep-szwg0y7q.js";
+import {
+  exports_config
+} from "./ripgrep-rz9mfttk.js";
+import {
+  exports_environment1 as exports_environment
+} from "./ripgrep-bfaw9j5x.js";
+import {
+  exports_permission
+} from "./ripgrep-x5r76fqd.js";
+import {
+  NonNegativeInt
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/tool/plugin/shell.ts
+var exports_shell2 = {};
+__export(exports_shell2, {
+  name: () => name,
+  ShellTool: () => exports_shell2,
+  Plugin: () => Plugin,
+  Input: () => Input,
+  DEFAULT_TIMEOUT_MS: () => DEFAULT_TIMEOUT_MS
+});
+import path from "path";
+import { ToolFailure } from "@opencode-ai/ai";
+import { Deferred, Effect, Schema, Scope } from "effect";
+var name = "shell";
+var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
+var BACKGROUND_STARTED = "The command was moved to the background.";
+var BACKGROUND_INSTRUCTION = "You will be notified automatically when the command finishes. DO NOT sleep, poll, or proactively check on its progress.";
+var OS = process.platform === "darwin" ? "macOS" : process.platform === "win32" ? "Windows" : process.platform === "linux" ? "Linux" : process.platform;
+var description = (shell) => [
+  "Execute a shell command and return its output.",
+  ...shell ? [`Commands run on ${OS} using ${shell}.`] : [],
+  "Quote file paths containing spaces or special characters.",
+  "Prefer dedicated tools over shell commands when possible.",
+  "When output is large, the full result is saved to a file and a truncated preview is returned.",
+  "Rely on automatic truncation unless filtering the output is more useful.",
+  "Commands accept an optional timeout, background commands have no timeout by default.",
+  "Background commands return immediately, and you will be notified when they complete."
+].join(" ");
+var Input = Schema.Struct({
+  command: Schema.String.annotate({ description: "Shell command string to execute" }),
+  workdir: Schema.optionalKey(Schema.String).annotate({
+    description: "Working directory to execute the command in. Defaults to the current working directory. When possible, avoid changing directories in the command and set the working directory here instead."
+  }),
+  timeout: Schema.optionalKey(NonNegativeInt).annotate({
+    description: `Timeout in milliseconds. Set to 0 to disable the timeout. Defaults to ${DEFAULT_TIMEOUT_MS} for foreground commands. Background commands have no timeout by default.`
+  }),
+  background: Schema.optionalKey(Schema.Boolean).annotate({
+    description: "Run the command in the background and return immediately. You will be notified when it completes. DO NOT poll its progress."
+  })
+});
+var StructuredOutput = Schema.Struct({
+  exit: Schema.optionalKey(Schema.Number),
+  shellID: Schema.optionalKey(Schema.String),
+  truncated: Schema.Boolean,
+  timeout: Schema.optionalKey(Schema.Boolean)
+});
+var Output = Schema.Struct({
+  ...StructuredOutput.fields,
+  output: Schema.String,
+  status: Schema.optionalKey(Schema.Literals(["completed", "running"]))
+});
+var modelOutput = (output) => {
+  if (output.status === "running")
+    return BACKGROUND_INSTRUCTION;
+  if (output.timeout)
+    return "Command timed out before completion.";
+  return `Command exited with code ${output.exit}.`;
+};
+var Plugin = {
+  id: "opencode.tool.shell",
+  effect: Effect.fn("ShellTool.Plugin")(function* (ctx) {
+    const runtime = yield* exports_runtime.Service;
+    const scope = yield* Scope.Scope;
+    const environment = yield* exports_environment.Service;
+    const mutation = yield* exports_location_mutation.Service;
+    const shell = yield* exports_shell.Service;
+    const permission = yield* exports_permission.Service;
+    const config = yield* exports_config.Service;
+    const notifyWhenDone = Effect.fn("ShellTool.notifyWhenDone")(function* (sessionID, id, command) {
+      yield* runtime.job.wait({ id }).pipe(Effect.flatMap((result) => {
+        const state = result.info?.status === "completed" ? "completed" : result.info?.status === "error" ? "error" : result.info?.status === "cancelled" ? "cancelled" : undefined;
+        if (state === undefined)
+          return Effect.void;
+        const text = state === "completed" ? result.info.output ?? "" : state === "error" ? result.info.error ?? "Command failed" : "Command cancelled";
+        return runtime.session.synthetic({
+          sessionID,
+          text: `<shell id="${id}" state="${state}" command="${command}">
+${text}
+</shell>`,
+          description: command,
+          metadata: { source: "shell", jobID: id, state }
+        });
+      }), Effect.forkIn(scope, { startImmediately: true }));
+    });
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description: description(),
+      input: Input,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        const source = {
+          type: "tool",
+          messageID: context.messageID,
+          id: context.id
+        };
+        const timeout = input.background === true ? input.timeout ?? 0 : input.timeout ?? DEFAULT_TIMEOUT_MS;
+        let finalTimeout = timeout;
+        const info = yield* shell.create({
+          command: input.command,
+          cwd: input.workdir,
+          timeout,
+          metadata: { sessionID: context.sessionID }
+        }, (invocation) => Effect.gen(function* () {
+          const target = yield* mutation.resolve({ path: invocation.cwd, kind: "directory" });
+          const unrestricted = (yield* permission.allowsAll({
+            sessionID: context.sessionID,
+            action: name,
+            agent: context.agent
+          })) && (yield* permission.allowsAll({
+            sessionID: context.sessionID,
+            action: "external_directory",
+            agent: context.agent
+          }));
+          invocation.cwd = target.absolute;
+          finalTimeout = invocation.timeout;
+          if (!unrestricted) {
+            const portable = exports_config.latest(yield* config.entries(), "experimental")?.portable_shell_scanner === true;
+            const parsed = yield* exports_parse.scan(invocation.command, invocation.shell, target.absolute, {
+              portable
+            });
+            const directories = yield* Effect.forEach(parsed.directories, (directory) => mutation.resolve({ path: path.resolve(target.absolute, directory), kind: "directory" }));
+            const external = [target, ...directories].map((item) => item.externalDirectory).filter((item) => item !== undefined).filter((item, index, items) => items.findIndex((other) => other.resource === item.resource) === index);
+            if (external.length > 0)
+              yield* permission.assert({
+                action: "external_directory",
+                resources: external.map((item) => item.resource),
+                save: external.map((item) => item.save),
+                sessionID: context.sessionID,
+                agent: context.agent,
+                source
+              });
+            if (parsed.commands.length > 0)
+              yield* permission.assert({
+                action: name,
+                resources: parsed.commands.map((command) => command.resource),
+                save: parsed.commands.map((command) => command.save),
+                sessionID: context.sessionID,
+                agent: context.agent,
+                source
+              });
+          }
+          const workdir = yield* exports_environment.typeFollowing(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new Error(`Working directory does not exist: ${target.absolute}`))));
+          if (workdir !== "directory")
+            return yield* Effect.fail(new Error(`Working directory is not a directory: ${target.absolute}`));
+        }));
+        yield* context.progress({ shellID: info.id });
+        const captureShell = Effect.fn("ShellTool.captureShell")(function* () {
+          const configured = exports_config.latest(yield* config.entries(), "tool_output");
+          const maxLines = configured?.max_lines ?? exports_tool_output.MAX_LINES;
+          const maxBytes = configured?.max_bytes ?? exports_tool_output.MAX_BYTES;
+          const latest = yield* shell.output(info.id, { cursor: Number.MAX_SAFE_INTEGER });
+          const page = yield* shell.output(info.id, {
+            cursor: Math.max(0, latest.size - maxBytes),
+            limit: maxBytes
+          });
+          const lines = page.output.split(`
+`);
+          if (page.output.endsWith(`
+`))
+            lines.pop();
+          const truncated = latest.size > maxBytes || lines.length > maxLines;
+          const output = lines.length > maxLines ? lines.slice(-maxLines).join(`
+`) : page.output;
+          const notice = truncated ? `
+
+[output truncated; full output saved to: ${info.file}]` : "";
+          return {
+            output: `${output || "(no output)"}${notice}`,
+            truncated
+          };
+        });
+        const settleShell = Effect.fn("ShellTool.settleShell")(function* () {
+          const final = yield* shell.wait(info.id);
+          const capture = yield* captureShell();
+          if (final.status === "timeout") {
+            return {
+              ...final.exit !== undefined ? { exit: final.exit } : {},
+              output: `${capture.output}
+
+Command exceeded timeout of ${finalTimeout} ms. Retry with a larger timeout if the command is expected to take longer.`,
+              truncated: capture.truncated,
+              timeout: true,
+              status: "completed"
+            };
+          }
+          return {
+            ...final.exit !== undefined ? { exit: final.exit } : {},
+            output: capture.output,
+            truncated: capture.truncated,
+            status: "completed"
+          };
+        });
+        const settled = yield* Deferred.make();
+        const run = settleShell().pipe(Effect.tap((output) => Deferred.succeed(settled, output)), Effect.map((output) => output.output), Effect.onInterrupt(() => shell.remove(info.id).pipe(Effect.ignore)));
+        const job = yield* runtime.job.start({
+          id: context.id,
+          type: name,
+          title: info.command,
+          metadata: { sessionID: context.sessionID, shellID: info.id },
+          run
+        });
+        if (input.background === true) {
+          yield* runtime.job.background(job.id);
+          yield* notifyWhenDone(context.sessionID, context.id, info.command);
+          return {
+            output: BACKGROUND_STARTED,
+            shellID: info.id,
+            truncated: false,
+            status: "running"
+          };
+        }
+        const result = yield* runtime.job.block({ id: job.id, sessionID: context.sessionID }).pipe(Effect.onInterrupt(() => runtime.job.cancel(job.id).pipe(Effect.ignore)));
+        if (result?.type === "backgrounded") {
+          yield* shell.timeout(info.id, 0);
+          yield* notifyWhenDone(context.sessionID, context.id, info.command);
+          return {
+            output: BACKGROUND_STARTED,
+            shellID: info.id,
+            truncated: false,
+            status: "running"
+          };
+        }
+        if (result?.info.status === "error")
+          return yield* Effect.fail(new Error(result.info.error ?? "Command failed"));
+        if (result?.info.status === "cancelled")
+          return yield* Effect.fail(new Error("Command cancelled"));
+        return yield* Deferred.await(settled);
+      }).pipe(Effect.map((output) => {
+        const content = [{ type: "text", text: output.output }];
+        const model = modelOutput(output);
+        if (model)
+          content.push({ type: "text", text: model });
+        return {
+          output,
+          content,
+          metadata: {
+            status: output.status,
+            truncated: output.truncated,
+            ..."exit" in output && output.exit !== undefined ? { exit: output.exit } : {},
+            ..."shellID" in output && output.shellID !== undefined ? { shellID: output.shellID } : {},
+            ..."timeout" in output && output.timeout !== undefined ? { timeout: output.timeout } : {}
+          }
+        };
+      }), Effect.mapError((error) => new ToolFailure({ message: `Unable to execute command: ${input.command}`, error })))
+    })).pipe(Effect.orDie);
+    yield* ctx.session.hook("context", (event) => Effect.gen(function* () {
+      const tool = event.tools[name];
+      if (!tool)
+        return;
+      tool.description = description(yield* shell.name());
+    }));
+  })
+};
+
+export { name, DEFAULT_TIMEOUT_MS, Input, Plugin, exports_shell2 as exports_shell };

package/dist/chunks/ripgrep-yndnp7z4.js

@@ -0,0 +1,85 @@
+import {
+  MessageDecodeError
+} from "./ripgrep-s6by3cc4.js";
+import {
+  exports_instruction_state
+} from "./ripgrep-ddjpbqb0.js";
+import {
+  exports_message
+} from "./ripgrep-25pxtba7.js";
+import {
+  SessionMessageTable
+} from "./ripgrep-9d2xhdr4.js";
+import {
+  exports_instructions
+} from "./ripgrep-8k8ks5a6.js";
+import {
+  exports_schema
+} from "./ripgrep-y8rs54ne.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/history.ts
+var exports_history = {};
+__export(exports_history, {
+  preview: () => preview,
+  load: () => load,
+  latestCompaction: () => latestCompaction,
+  firstUserMessage: () => firstUserMessage,
+  entriesForRunner: () => entriesForRunner,
+  SessionHistory: () => exports_history
+});
+import { and, asc, desc, eq, gte, sql } from "drizzle-orm";
+import { Effect, Schema } from "effect";
+var decode = Schema.decodeUnknownEffect(exports_message.Info);
+var latestCompaction = Effect.fnUntraced(function* (db, sessionID) {
+  return yield* db.select({ seq: SessionMessageTable.seq }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, sessionID), eq(SessionMessageTable.type, "compaction"), sql`json_extract(${SessionMessageTable.data}, '$.status') = 'completed'`)).orderBy(desc(SessionMessageTable.seq)).limit(1).get().pipe(Effect.orDie);
+});
+var messageRows = Effect.fnUntraced(function* (db, sessionID, compaction) {
+  const rows = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, sessionID), compaction ? gte(SessionMessageTable.seq, compaction.seq) : undefined)).orderBy(asc(SessionMessageTable.seq)).all().pipe(Effect.orDie);
+  return rows;
+});
+var decodeMessageRow = (row) => decode({ ...row.data, id: row.id, type: row.type }).pipe(Effect.mapError(() => new MessageDecodeError({
+  sessionID: exports_schema.ID.make(row.session_id),
+  messageID: exports_message.ID.make(row.id)
+})));
+var messageEntries = Effect.fnUntraced(function* (db, sessionID) {
+  const rows = yield* messageRows(db, sessionID, yield* latestCompaction(db, sessionID));
+  return yield* Effect.forEach(rows, (row) => decodeMessageRow(row).pipe(Effect.map((message) => ({ seq: row.seq, message }))));
+});
+var load = Effect.fn("SessionHistory.load")(function* (db, sessionID) {
+  return (yield* messageEntries(db, sessionID)).map((entry) => entry.message);
+});
+var entriesForRunner = Effect.fn("SessionHistory.entriesForRunner")(function* (db, sessionID, instructions) {
+  return yield* db.transaction(() => Effect.gen(function* () {
+    const messages = yield* messageEntries(db, sessionID);
+    return {
+      initial: yield* exports_instruction_state.initial(db, sessionID, instructions),
+      entries: messages
+    };
+  })).pipe(Effect.orDie);
+});
+var preview = Effect.fn("SessionHistory.preview")(function* (db, sessionID, instructions) {
+  const observed = yield* exports_instructions.read(instructions);
+  return yield* db.transaction(() => Effect.gen(function* () {
+    const messages = yield* messageEntries(db, sessionID);
+    const unsettled = messages.findIndex((entry) => entry.message.type === "assistant" && entry.message.time.completed === undefined);
+    const settled = unsettled === -1 ? messages : messages.slice(0, unsettled);
+    const assembled = yield* exports_instruction_state.preview(db, sessionID, instructions, observed);
+    return {
+      initial: assembled.initial,
+      messages: settled.map((entry) => entry.message),
+      instructionUpdate: assembled.update
+    };
+  })).pipe(Effect.catch((error) => error instanceof exports_instructions.InitializationBlocked ? error : Effect.die(error)));
+});
+var firstUserMessage = Effect.fn("SessionHistory.firstUserMessage")(function* (db, sessionID) {
+  const row = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, sessionID), eq(SessionMessageTable.type, "user"))).orderBy(asc(SessionMessageTable.seq)).get().pipe(Effect.orDie);
+  if (!row)
+    return;
+  const message = yield* decodeMessageRow(row).pipe(Effect.catch(() => Effect.succeed(undefined)));
+  return message?.type === "user" ? message : undefined;
+});
+
+export { latestCompaction, load, entriesForRunner, preview, firstUserMessage, exports_history };

package/dist/chunks/ripgrep-yrqrg4vp.js

@@ -0,0 +1,17 @@
+// src/database/migration/20260603040000_session_message_projection_order.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260603040000_session_message_projection_order",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_message\`;`);
+      yield* tx.run(`ALTER TABLE \`session_message\` ADD COLUMN \`seq\` integer NOT NULL;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_message_session_type_time_created_id_idx\`;`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_seq_idx\` ON \`session_message\` (\`session_id\`,\`seq\`);`);
+      yield* tx.run(`CREATE INDEX \`session_message_session_type_seq_idx\` ON \`session_message\` (\`session_id\`,\`type\`,\`seq\`);`);
+    });
+  }
+};
+var _20260603040000_session_message_projection_order_default = migration;
+
+export { _20260603040000_session_message_projection_order_default };