@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-cgvnqv92.js

@@ -0,0 +1,27 @@
+import {
+  exports_provider
+} from "./ripgrep-d6vvk673.js";
+
+// src/plugin/provider/kilo.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var KiloPlugin = define({
+  id: "opencode.provider.kilo",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!exports_provider.isAISDK(item.provider.package))
+          continue;
+        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/openai-compatible")
+          continue;
+        if (item.provider.settings?.baseURL !== "https://api.kilo.ai/api/gateway")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = { ...provider.headers, "HTTP-Referer": "https://opencode.ai/", "X-Title": "opencode" };
+        });
+      }
+    });
+  })
+});
+
+export { KiloPlugin };

package/dist/chunks/ripgrep-ch0qh5se.js

@@ -0,0 +1,150 @@
+import {
+  exports_kv
+} from "./ripgrep-da1n05jh.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/wellknown.ts
+var exports_wellknown = {};
+__export(exports_wellknown, {
+  resolve: () => resolve,
+  node: () => node,
+  inspect: () => inspect,
+  WellKnown: () => exports_wellknown,
+  Service: () => Service,
+  RemoteConfig: () => RemoteConfig,
+  Manifest: () => Manifest,
+  Event: () => Event,
+  Config: () => Config,
+  Auth: () => Auth
+});
+import { Integration } from "@opencode-ai/schema/integration";
+import { Context, Effect, Layer, Ref, Schema, Semaphore } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { isDeepStrictEqual } from "node:util";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { httpClient } from "@opencode-ai/util/effect/app-node-platform";
+var Auth = Schema.Struct({
+  command: Schema.Array(Schema.String),
+  env: Schema.String
+}).annotate({ identifier: "WellKnown.Auth" });
+var RemoteConfig = Schema.Struct({
+  url: Schema.String,
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String))
+}).annotate({ identifier: "WellKnown.RemoteConfig" });
+var Config = Schema.Record(Schema.String, Schema.Json).annotate({ identifier: "WellKnown.Config" });
+var Manifest = Schema.Struct({
+  auth: Schema.optional(Auth),
+  config: Schema.optional(Schema.NullOr(Config)),
+  remote_config: Schema.optional(RemoteConfig)
+}).annotate({ identifier: "WellKnown.Manifest" });
+
+class Service extends Context.Service()("@opencode/WellKnown") {
+}
+var Event = {
+  Updated: exports_bus.ephemeral({ type: "wellknown.updated", schema: {} })
+};
+var inspect = Effect.fn("WellKnown.inspect")(function* (origin) {
+  const url = `${origin.replace(/\/+$/, "")}/.well-known/opencode`;
+  const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+  return yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson)).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Manifest)), Effect.mapError((cause) => new Error(`Failed to load wellknown manifest from ${url}`, { cause })));
+});
+var resolve = Effect.fn("WellKnown.resolve")(function* (input) {
+  const manifest = yield* inspect(input.origin);
+  return yield* resolveEntry({ origin: input.origin, integrationID: Integration.ID.make(input.origin.replace(/\/+$/, "")), manifest }, input.variables ?? {});
+});
+var resolveEntry = Effect.fnUntraced(function* (entry, variables) {
+  const configs = entry.manifest.config ? [entry.manifest.config] : [];
+  if (!entry.manifest.remote_config)
+    return configs;
+  const substitute = (value) => value.replace(/\{env:([^}]+)\}/g, (_, name) => variables[name] ?? process.env[name] ?? "");
+  const url = substitute(entry.manifest.remote_config.url);
+  const headers = Object.fromEntries(Object.entries(entry.manifest.remote_config.headers ?? {}).map(([key, value]) => [key, substitute(value)]));
+  const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+  const remote = yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.setHeaders(headers))).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Config)), Effect.mapError((cause) => new Error(`Failed to load wellknown remote config from ${url}`, { cause })));
+  if (Schema.is(Config)(remote.config))
+    return [...configs, remote.config];
+  return [...configs, remote];
+});
+var sourcesKey = "wellknown:sources";
+var Sources = Schema.Array(Schema.String);
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const http = yield* HttpClient.HttpClient;
+  const kv = yield* exports_kv.Service;
+  const bus = yield* exports_bus.Service;
+  const cache = yield* Ref.make(new Map);
+  const lock = Semaphore.makeUnsafe(1);
+  const load = Effect.fn("WellKnown.load")(function* () {
+    const value = yield* kv.get(sourcesKey);
+    const origins = Schema.is(Sources)(value) ? value : [];
+    const current = yield* Ref.get(cache);
+    const entries = yield* Effect.forEach(origins, (origin) => {
+      const cached = current.get(origin);
+      if (cached)
+        return Effect.succeed(cached);
+      return inspect(origin).pipe(Effect.provideService(HttpClient.HttpClient, http), Effect.map((manifest) => ({ origin, integrationID: Integration.ID.make(origin), manifest })));
+    });
+    yield* Ref.set(cache, new Map(entries.map((entry) => [entry.origin, entry])));
+    return entries;
+  });
+  const refresh = Effect.fn("WellKnown.refresh")(function* () {
+    return yield* lock.withPermit(Effect.gen(function* () {
+      const value = yield* kv.get(sourcesKey);
+      const origins = Schema.is(Sources)(value) ? value : [];
+      if (!origins.length)
+        return false;
+      const entries = yield* Effect.forEach(origins, (origin) => inspect(origin).pipe(Effect.provideService(HttpClient.HttpClient, http), Effect.map((manifest) => ({ origin, integrationID: Integration.ID.make(origin), manifest }))));
+      const next = new Map(entries.map((entry) => [entry.origin, entry]));
+      const changed = !isDeepStrictEqual(Ref.getUnsafe(cache), next);
+      if (!changed)
+        return false;
+      yield* Ref.set(cache, next);
+      yield* bus.publish(Event.Updated, {});
+      return true;
+    }));
+  });
+  return Service.of({
+    entries: load,
+    snapshot: () => Array.from(Ref.getUnsafe(cache).values()),
+    refresh,
+    add: Effect.fn("WellKnown.add")(function* (value) {
+      return yield* lock.withPermit(Effect.gen(function* () {
+        const origin = value.replace(/\/+$/, "");
+        const manifest = yield* inspect(origin).pipe(Effect.provideService(HttpClient.HttpClient, http));
+        if (!manifest.auth)
+          return yield* Effect.fail(new Error(`No authentication method found at ${origin}`));
+        const entry = { origin, integrationID: Integration.ID.make(origin), manifest };
+        const sources = yield* kv.get(sourcesKey);
+        const origins = Schema.is(Sources)(sources) ? sources : [];
+        yield* kv.set(sourcesKey, Array.from(new Set([...origins, origin])));
+        yield* Ref.update(cache, (current) => new Map(current).set(origin, entry));
+        yield* bus.publish(Event.Updated, {});
+        return entry;
+      }));
+    }),
+    remove: Effect.fn("WellKnown.remove")(function* (value) {
+      yield* lock.withPermit(Effect.gen(function* () {
+        const origin = value.replace(/\/+$/, "");
+        const sources = yield* kv.get(sourcesKey);
+        const origins = Schema.is(Sources)(sources) ? sources : [];
+        yield* kv.set(sourcesKey, origins.filter((item) => item !== origin));
+        yield* Ref.update(cache, (current) => {
+          const next = new Map(current);
+          next.delete(origin);
+          return next;
+        });
+        yield* bus.publish(Event.Updated, {});
+      }));
+    }),
+    resolve: Effect.fn("WellKnown.resolveEntry")(function* (entry, variables) {
+      return yield* resolveEntry(entry, variables).pipe(Effect.provideService(HttpClient.HttpClient, http));
+    })
+  });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [httpClient, exports_kv.node, exports_bus.node] });
+
+export { Auth, RemoteConfig, Config, Manifest, Service, Event, inspect, resolve, node, exports_wellknown };

package/dist/chunks/ripgrep-cm67rqy2.js

@@ -0,0 +1,22 @@
+// src/database/migration/20260808023530_workspace_domain.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260808023530_workspace_domain",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP TABLE \`workspace\`;`);
+      yield* tx.run(`
+        CREATE TABLE \`workspace\` (
+          \`id\` text PRIMARY KEY,
+          \`provider\` text NOT NULL,
+          \`binding\` text NOT NULL,
+          \`created_at\` integer NOT NULL,
+          \`last_used_at\` integer NOT NULL
+        );
+      `);
+    });
+  }
+};
+var _20260808023530_workspace_domain_default = migration;
+
+export { _20260808023530_workspace_domain_default };

package/dist/chunks/ripgrep-cz3dkvcz.js

@@ -0,0 +1,16 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/runner/index.ts
+var exports_runner = {};
+__export(exports_runner, {
+  SessionRunner: () => exports_runner,
+  Service: () => Service
+});
+import { Context } from "effect";
+
+class Service extends Context.Service()("@opencode/SessionRunner") {
+}
+
+export { Service, exports_runner };

package/dist/chunks/ripgrep-d59wp3am.js

@@ -0,0 +1,430 @@
+import {
+  exports_message_updater
+} from "./ripgrep-38crwsq8.js";
+import {
+  exports_inbox
+} from "./ripgrep-8v2yzmx6.js";
+import {
+  Slug
+} from "./ripgrep-df3v2q6j.js";
+import {
+  exports_instruction_state
+} from "./ripgrep-ddjpbqb0.js";
+import {
+  exports_message
+} from "./ripgrep-25pxtba7.js";
+import {
+  SessionInboxTable,
+  SessionMessageTable,
+  SessionTable
+} from "./ripgrep-9d2xhdr4.js";
+import {
+  SessionEvent
+} from "./ripgrep-a83yvq99.js";
+import {
+  exports_agent
+} from "./ripgrep-4ffc1teg.js";
+import {
+  exports_workspace
+} from "./ripgrep-q6a2s21x.js";
+import {
+  AbsolutePath,
+  RelativePath
+} from "./ripgrep-j07kk359.js";
+import {
+  exports_model
+} from "./ripgrep-xfd1xnk3.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  exports_database
+} from "./ripgrep-x7kx8910.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/projector.ts
+var exports_projector = {};
+__export(exports_projector, {
+  node: () => node,
+  SessionProjector: () => exports_projector,
+  SessionAlreadyProjected: () => SessionAlreadyProjected
+});
+import { and, asc, desc, eq, gt, gte, inArray, lt, lte, sql } from "drizzle-orm";
+import { DateTime, Effect, Layer, Schema, Stream } from "effect";
+import path from "path";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Money } from "@opencode-ai/schema/money";
+import { Worktree } from "@opencode-ai/schema/worktree";
+import { Project } from "@opencode-ai/schema/project";
+var decodeMessage = Schema.decodeUnknownSync(exports_message.Info);
+var encodeMessage = Schema.encodeSync(exports_message.Info);
+
+class SessionAlreadyProjected extends Error {
+}
+var ForkBatchSize = 500;
+var forkTitle = (value) => {
+  if (value === undefined)
+    return;
+  const match = value.match(/^(.+) \(fork #(\d+)\)$/);
+  if (match)
+    return `${match[1]} (fork #${Number.parseInt(match[2], 10) + 1})`;
+  return `${value} (fork #1)`;
+};
+function applyUsage(db, sessionID, value, sign = 1) {
+  return db.update(SessionTable).set({
+    cost: sql`${SessionTable.cost} + ${value.cost * sign}`,
+    tokens_input: sql`${SessionTable.tokens_input} + ${value.tokens.input * sign}`,
+    tokens_output: sql`${SessionTable.tokens_output} + ${value.tokens.output * sign}`,
+    tokens_reasoning: sql`${SessionTable.tokens_reasoning} + ${value.tokens.reasoning * sign}`,
+    tokens_cache_read: sql`${SessionTable.tokens_cache_read} + ${value.tokens.cache.read * sign}`,
+    tokens_cache_write: sql`${SessionTable.tokens_cache_write} + ${value.tokens.cache.write * sign}`,
+    time_updated: sql`${SessionTable.time_updated}`
+  }).where(eq(SessionTable.id, sessionID)).run().pipe(Effect.orDie);
+}
+var publishSessionUsage = Effect.fn("SessionProjector.publishUsage")(function* (db, bus, sessionID) {
+  const row = yield* db.select({
+    cost: SessionTable.cost,
+    input: SessionTable.tokens_input,
+    output: SessionTable.tokens_output,
+    reasoning: SessionTable.tokens_reasoning,
+    cacheRead: SessionTable.tokens_cache_read,
+    cacheWrite: SessionTable.tokens_cache_write
+  }).from(SessionTable).where(eq(SessionTable.id, sessionID)).get().pipe(Effect.orDie);
+  if (!row)
+    return;
+  yield* bus.publish(SessionEvent.UsageUpdated, {
+    sessionID,
+    cost: Money.USD.make(row.cost),
+    tokens: {
+      input: row.input,
+      output: row.output,
+      reasoning: row.reasoning,
+      cache: { read: row.cacheRead, write: row.cacheWrite }
+    }
+  });
+});
+var projectFork = Effect.fn("SessionProjector.projectFork")(function* (db, event) {
+  const parent = yield* db.select().from(SessionTable).where(eq(SessionTable.id, event.data.parentID)).get().pipe(Effect.orDie);
+  if (!parent)
+    return yield* Effect.die(new Error(`Fork parent session not found: ${event.data.parentID}`));
+  const boundary = yield* db.select({ seq: SessionMessageTable.seq }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.parentID), eq(SessionMessageTable.id, event.data.boundary.messageID))).get().pipe(Effect.orDie);
+  if (!boundary)
+    return yield* Effect.die(new Error(`Fork boundary message not found: ${event.data.boundary.messageID}`));
+  const copied = yield* db.select({ seq: SessionMessageTable.seq }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.parentID), event.data.boundary.type === "before" ? lt(SessionMessageTable.seq, boundary.seq) : lte(SessionMessageTable.seq, boundary.seq))).orderBy(desc(SessionMessageTable.seq)).limit(1).get().pipe(Effect.orDie);
+  const copiedSeq = copied?.seq;
+  const stored = yield* db.insert(SessionTable).values({
+    id: event.data.sessionID,
+    parent_id: null,
+    fork_session_id: event.data.parentID,
+    fork_boundary: event.data.boundary,
+    project_id: parent.project_id,
+    workspace_id: parent.workspace_id,
+    slug: Slug.create(),
+    directory: parent.directory,
+    path: parent.path,
+    title: forkTitle(parent.title ?? undefined),
+    agent: parent.agent,
+    model: parent.model,
+    version: parent.version,
+    cost: 0,
+    tokens_input: 0,
+    tokens_output: 0,
+    tokens_reasoning: 0,
+    tokens_cache_read: 0,
+    tokens_cache_write: 0,
+    time_created: event.created,
+    time_updated: event.created
+  }).onConflictDoNothing().returning({ sessionID: SessionTable.id }).get().pipe(Effect.orDie);
+  if (!stored)
+    return yield* Effect.die(new SessionAlreadyProjected);
+  let cursor = -1;
+  while (copiedSeq !== undefined) {
+    const rows = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.parentID), gt(SessionMessageTable.seq, cursor), lt(SessionMessageTable.seq, copiedSeq + 1), sql`${SessionMessageTable.type} != 'compaction' or json_extract(${SessionMessageTable.data}, '$.status') != 'running'`)).orderBy(asc(SessionMessageTable.seq)).limit(ForkBatchSize).all().pipe(Effect.orDie);
+    if (rows.length === 0)
+      break;
+    yield* db.insert(SessionMessageTable).values(rows.map((row) => ({
+      id: exports_message.ID.create(),
+      session_id: event.data.sessionID,
+      type: row.type,
+      seq: row.seq,
+      time_created: row.time_created,
+      time_updated: row.time_updated,
+      data: row.data
+    }))).run().pipe(Effect.orDie);
+    cursor = rows.at(-1).seq;
+  }
+  if (copiedSeq !== undefined)
+    yield* exports_bus.reserveSequence(db, event.data.sessionID, copiedSeq);
+  if (event.data.instructions)
+    yield* exports_instruction_state.initialize(db, event.data.sessionID, event.durable.seq, event.data.instructions);
+});
+function run(db, event) {
+  return Effect.gen(function* () {
+    const decodeRow = (row) => decodeMessage({ ...row.data, id: row.id, type: row.type });
+    const updateMessage = (message) => {
+      if (event.durable === undefined)
+        return Effect.die(new Error("Durable Session event is missing aggregate sequence"));
+      const encoded = encodeMessage(message);
+      const { id, type, ...data } = encoded;
+      return db.update(SessionMessageTable).set({ type, time_created: DateTime.toEpochMillis(message.time.created), data }).where(and(eq(SessionMessageTable.id, exports_message.ID.make(id)), eq(SessionMessageTable.session_id, event.data.sessionID))).run().pipe(Effect.orDie);
+    };
+    const appendMessage = (message) => insertMessage(db, event, message);
+    const adapter = {
+      getAgent() {
+        return db.select({ agent: SessionTable.agent }).from(SessionTable).where(eq(SessionTable.id, event.data.sessionID)).get().pipe(Effect.orDie, Effect.map((row) => row?.agent ? exports_agent.ID.make(row.agent) : undefined));
+      },
+      getModel() {
+        return db.select({ model: SessionTable.model }).from(SessionTable).where(eq(SessionTable.id, event.data.sessionID)).get().pipe(Effect.orDie, Effect.map((row) => row?.model ? Schema.decodeUnknownSync(exports_model.Ref)(row.model) : undefined));
+      },
+      getLocation() {
+        return db.select({
+          directory: SessionTable.directory,
+          workspaceID: SessionTable.workspace_id,
+          projectID: SessionTable.project_id,
+          subpath: SessionTable.path
+        }).from(SessionTable).where(eq(SessionTable.id, event.data.sessionID)).get().pipe(Effect.orDie, Effect.map((row) => row ? {
+          location: {
+            directory: AbsolutePath.make(row.directory),
+            workspaceID: row.workspaceID ? exports_workspace.ID.make(row.workspaceID) : undefined
+          },
+          projectID: row.projectID,
+          subpath: row.subpath === null ? undefined : RelativePath.make(row.subpath)
+        } : undefined));
+      },
+      getCurrentAssistant() {
+        return Effect.gen(function* () {
+          const row = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.sessionID), eq(SessionMessageTable.type, "assistant"))).orderBy(desc(SessionMessageTable.seq)).limit(1).get().pipe(Effect.orDie);
+          if (!row)
+            return;
+          const message = decodeRow(row);
+          return message.type === "assistant" && !message.time.completed ? message : undefined;
+        });
+      },
+      getAssistant(messageID) {
+        return Effect.gen(function* () {
+          const row = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.id, messageID), eq(SessionMessageTable.session_id, event.data.sessionID), eq(SessionMessageTable.type, "assistant"))).get().pipe(Effect.orDie);
+          if (!row)
+            return;
+          const message = decodeRow(row);
+          return message.type === "assistant" ? message : undefined;
+        });
+      },
+      getShell(shellID) {
+        return Effect.gen(function* () {
+          const row = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.sessionID), eq(SessionMessageTable.type, "shell"), sql`json_extract(${SessionMessageTable.data}, '$.shellID') = ${shellID}`)).orderBy(desc(SessionMessageTable.seq)).limit(1).get().pipe(Effect.orDie);
+          if (!row)
+            return;
+          const message = decodeRow(row);
+          return message.type === "shell" ? message : undefined;
+        });
+      },
+      getCompaction() {
+        return Effect.gen(function* () {
+          const row = yield* db.select().from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.sessionID), eq(SessionMessageTable.type, "compaction"), sql`json_extract(${SessionMessageTable.data}, '$.status') = 'running'`)).orderBy(desc(SessionMessageTable.seq)).limit(1).get().pipe(Effect.orDie);
+          if (!row)
+            return;
+          const message = decodeRow(row);
+          return message.type === "compaction" ? message : undefined;
+        });
+      },
+      updateAssistant: updateMessage,
+      updateShell: updateMessage,
+      updateCompaction: updateMessage,
+      appendMessage
+    };
+    yield* exports_message_updater.update(adapter, event);
+  });
+}
+function insertMessage(db, event, message) {
+  if (event.durable === undefined)
+    return Effect.die(new Error("Durable Session event is missing aggregate sequence"));
+  const encoded = encodeMessage(message);
+  const { id, type, ...data } = encoded;
+  return db.insert(SessionMessageTable).values({
+    id: exports_message.ID.make(id),
+    session_id: event.data.sessionID,
+    type,
+    seq: event.durable.seq,
+    time_created: DateTime.toEpochMillis(message.time.created),
+    data
+  }).run().pipe(Effect.orDie);
+}
+var layer = Layer.effectDiscard(Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const db = (yield* exports_database.Service).db;
+  yield* bus.project(SessionEvent.Created, (event) => Effect.gen(function* () {
+    const stored = yield* db.insert(SessionTable).values({
+      id: event.data.sessionID,
+      project_id: event.data.projectID,
+      workspace_id: event.data.location.workspaceID ? exports_workspace.ID.make(event.data.location.workspaceID) : null,
+      parent_id: event.data.parentID,
+      slug: event.data.slug,
+      directory: event.data.location.directory,
+      path: event.data.subpath,
+      title: event.data.title,
+      agent: event.data.agent,
+      model: event.data.model,
+      version: event.data.version,
+      time_created: event.created,
+      time_updated: event.created
+    }).onConflictDoNothing().returning({ sessionID: SessionTable.id }).get().pipe(Effect.orDie);
+    if (!stored)
+      return yield* Effect.die(new SessionAlreadyProjected);
+  }));
+  yield* bus.project(SessionEvent.Moved, (event) => Effect.gen(function* () {
+    yield* run(db, event);
+    yield* db.update(SessionTable).set({
+      directory: event.data.location.directory,
+      path: event.data.subpath,
+      ...event.data.projectID ? { project_id: event.data.projectID } : {},
+      workspace_id: event.data.location.workspaceID ? exports_workspace.ID.make(event.data.location.workspaceID) : null,
+      time_updated: event.created
+    }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie);
+  }));
+  yield* bus.project(Worktree.Event.Resolved, (event) => Effect.gen(function* () {
+    const stale = [event.data.previous, Project.ID.global].filter((id) => id !== event.data.projectID);
+    if (stale.length === 0)
+      return;
+    const rows = yield* db.select({ id: SessionTable.id, directory: SessionTable.directory }).from(SessionTable).where(and(inArray(SessionTable.project_id, stale), gte(SessionTable.directory, event.data.directory), lte(SessionTable.directory, AbsolutePath.make(event.data.directory + "￿")))).all().pipe(Effect.orDie);
+    yield* Effect.forEach(rows, (row) => {
+      if (!FSUtil.contains(event.data.directory, row.directory))
+        return Effect.void;
+      return db.update(SessionTable).set({
+        project_id: event.data.projectID,
+        path: RelativePath.make(path.relative(event.data.directory, row.directory).replaceAll("\\", "/")),
+        time_updated: sql`${SessionTable.time_updated}`
+      }).where(eq(SessionTable.id, row.id)).run().pipe(Effect.orDie);
+    }, { discard: true });
+  }));
+  yield* bus.project(SessionEvent.Deleted, (event) => db.delete(SessionTable).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie));
+  yield* bus.project(SessionEvent.AgentSelected, (event) => Effect.gen(function* () {
+    yield* run(db, event);
+    yield* db.update(SessionTable).set({ agent: event.data.agent, time_updated: event.created }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie);
+  }));
+  yield* bus.project(SessionEvent.ModelSelected, (event) => Effect.gen(function* () {
+    yield* run(db, event);
+    yield* db.update(SessionTable).set({ model: event.data.model, time_updated: event.created }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie);
+  }));
+  yield* bus.project(SessionEvent.Renamed, (event) => db.update(SessionTable).set({ title: event.data.title, time_updated: event.created }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie));
+  yield* bus.project(SessionEvent.UsageRecorded, (event) => applyUsage(db, event.data.sessionID, event.data));
+  yield* bus.project(SessionEvent.Forked, (event) => projectFork(db, event));
+  yield* bus.project(SessionEvent.InboxDelivered, (event) => Effect.gen(function* () {
+    if (event.durable === undefined)
+      return yield* Effect.die(new Error("Durable Session event is missing aggregate sequence"));
+    const input = yield* exports_inbox.projectDelivered(db, {
+      id: event.data.inboxID,
+      sessionID: event.data.sessionID
+    });
+    if (input.type === "compaction" || input.type === "move")
+      return;
+    yield* insertMessage(db, event, input.type === "user" ? {
+      id: input.id,
+      type: "user",
+      metadata: input.payload.metadata,
+      text: input.payload.text,
+      files: input.payload.files,
+      agents: input.payload.agents,
+      skills: input.payload.skills,
+      time: { created: DateTime.makeUnsafe(event.created) }
+    } : {
+      id: input.id,
+      type: "synthetic",
+      text: input.payload.text,
+      description: input.payload.description,
+      metadata: input.payload.metadata,
+      time: { created: DateTime.makeUnsafe(event.created) }
+    });
+  }));
+  yield* bus.project(SessionEvent.InboxEnqueued, (event) => Effect.gen(function* () {
+    if (event.durable === undefined)
+      return yield* Effect.die(new Error("Durable Session event is missing aggregate sequence"));
+    yield* exports_inbox.projectAdmitted(db, {
+      enqueuedSeq: event.durable.seq,
+      id: event.data.inboxID,
+      sessionID: event.data.sessionID,
+      item: event.data.item,
+      timeCreated: event.created
+    });
+    yield* db.update(SessionTable).set({ time_updated: event.created }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie);
+  }));
+  yield* bus.project(SessionEvent.InboxCancelled, (event) => exports_inbox.projectCancelled(db, {
+    id: event.data.inboxID,
+    sessionID: event.data.sessionID
+  }));
+  yield* bus.project(SessionEvent.InboxDeliveryChanged, (event) => exports_inbox.projectDeliveryChanged(db, {
+    id: event.data.inboxID,
+    sessionID: event.data.sessionID,
+    delivery: event.data.delivery
+  }));
+  yield* bus.project(SessionEvent.Execution.Succeeded, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Execution.Failed, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Execution.Interrupted, (event) => run(db, event));
+  yield* bus.project(SessionEvent.InstructionsUpdated, (event) => Effect.gen(function* () {
+    yield* run(db, event);
+    yield* exports_instruction_state.apply(db, event.data.sessionID, event.durable.seq, event.data.delta);
+  }));
+  yield* bus.project(SessionEvent.Synthetic, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Skill.Activated, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Shell.Started, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Shell.Ended, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Step.Started, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Step.Ended, (event) => Effect.gen(function* () {
+    yield* run(db, event);
+    yield* applyUsage(db, event.data.sessionID, event.data);
+  }));
+  yield* bus.project(SessionEvent.Step.Failed, (event) => Effect.gen(function* () {
+    yield* run(db, event);
+    if (event.data.cost !== undefined && event.data.tokens !== undefined)
+      yield* applyUsage(db, event.data.sessionID, { cost: event.data.cost, tokens: event.data.tokens });
+  }));
+  yield* bus.project(SessionEvent.Text.Started, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Text.Ended, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Tool.Input.Started, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Tool.Input.Ended, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Tool.Called, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Tool.Success, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Tool.Failed, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Reasoning.Started, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Reasoning.Ended, (event) => run(db, event));
+  yield* bus.project(SessionEvent.RetryScheduled, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Compaction.Started, (event) => run(db, event));
+  yield* bus.project(SessionEvent.Compaction.Ended, (event) => Effect.gen(function* () {
+    yield* run(db, event);
+    yield* exports_instruction_state.advanceEpoch(db, event.data.sessionID, event.durable.seq);
+    if (event.durable === undefined)
+      return yield* Effect.die(new Error("Durable Session event is missing aggregate sequence"));
+  }));
+  yield* bus.project(SessionEvent.Compaction.Failed, (event) => Effect.gen(function* () {
+    yield* run(db, event);
+    if (event.durable === undefined)
+      return yield* Effect.die(new Error("Durable Session event is missing aggregate sequence"));
+  }));
+  yield* bus.project(SessionEvent.RevertEvent.Staged, (event) => Effect.gen(function* () {
+    const revert = event.data.revert;
+    yield* db.update(SessionTable).set({
+      revert: { ...revert, files: revert.files ? [...revert.files] : undefined },
+      time_updated: event.created
+    }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie);
+  }));
+  yield* bus.project(SessionEvent.RevertEvent.Cleared, (event) => db.update(SessionTable).set({ revert: null, time_updated: event.created }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie, Effect.asVoid));
+  yield* bus.project(SessionEvent.RevertEvent.Committed, (event) => Effect.gen(function* () {
+    const boundary = yield* db.select({ seq: SessionMessageTable.seq }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.sessionID), eq(SessionMessageTable.id, event.data.to))).get().pipe(Effect.orDie);
+    if (!boundary)
+      return yield* Effect.die(new Error(`Revert boundary message not found: ${event.data.to}`));
+    yield* db.delete(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, event.data.sessionID), gte(SessionMessageTable.seq, boundary.seq))).run().pipe(Effect.orDie);
+    yield* db.delete(SessionInboxTable).where(and(eq(SessionInboxTable.session_id, event.data.sessionID), gte(SessionInboxTable.enqueued_seq, boundary.seq))).run().pipe(Effect.orDie);
+    yield* db.update(SessionTable).set({ revert: null, time_updated: event.created }).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie);
+    yield* exports_instruction_state.reset(db, event.data.sessionID);
+  }));
+  yield* bus.subscribe([SessionEvent.Step.Ended, SessionEvent.Step.Failed, SessionEvent.UsageRecorded]).pipe(Stream.runForEach((event) => {
+    if (event.type === SessionEvent.Step.Failed.type && (event.data.cost === undefined || event.data.tokens === undefined))
+      return Effect.void;
+    return publishSessionUsage(db, bus, event.data.sessionID);
+  }), Effect.forkScoped({ startImmediately: true }));
+}));
+var node = makeGlobalNode({ name: "session-projector", layer, deps: [exports_bus.node, exports_database.node] });
+
+export { SessionAlreadyProjected, node, exports_projector };