Commit ccf8331600f323939a796169dfe2598a4c1b59c4 | the-knife

author	Julius Marminge <julius0216@outlook.com> 2026-06-19 21:29:25-07:00
committer	GitHub <noreply@github.com> 2026-06-19 21:29:25-07:00
log	ccf8331600f323939a796169dfe2598a4c1b59c4
tree	2c6d22cad818c99435435ec9f584e2daa700ac77
parent	ffae12f329c4de9680efd1757b488a3b5bbe3cd2
signature	Signed by PGP key B5690EEEBB952194

[codex] Align diagnostics and telemetry Effect services (#3189)

Co-authored-by: codex <codex@users.noreply.github.com>

20 files changed, 718 insertions(+), 556 deletions(-)

apps
- server
  - src
    diagnostics
    ProcessDiagnostics.ts
    ProcessResourceMonitor.test.ts
    ProcessResourceMonitor.ts
    TraceDiagnostics.ts
    http.ts
    observability
    BrowserTraceCollector.ts
    Layers
    Observability.ts
    Services
    BrowserTraceCollector.ts
    provider
    Layers
    ProviderService.test.ts
    ProviderService.ts
    server.test.ts
    server.ts
    serverRuntimeStartup.test.ts
    serverRuntimeStartup.ts
    telemetry
    AnalyticsService.test.ts
    AnalyticsService.ts
    Identify.ts
    Layers
    AnalyticsService.test.ts
    AnalyticsService.ts
    Services
    AnalyticsService.ts

apps/server/src/diagnostics/ProcessDiagnostics.ts+103-40

 @@ -12,7 +12,8 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import * as ChildProcess from "effect/unstable/process/ChildProcess";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
 import { collectUint8StreamText } from "../stream/collectUint8StreamText.ts";
 @@ -31,35 +32,80 @@ const PROCESS_QUERY_TIMEOUT_MS = 1_000;
 const POSIX_PROCESS_QUERY_COMMAND = "pid=,ppid=,pgid=,stat=,pcpu=,rss=,etime=,command=";
 const PROCESS_QUERY_MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
-export interface ProcessDiagnosticsShape {
-  readonly read: Effect.Effect<ServerProcessDiagnosticsResult>;
-  readonly signal: (input: {
-    readonly pid: number;
-    readonly signal: ServerProcessSignal;
-  }) => Effect.Effect<ServerSignalProcessResult>;
-}
 export class ProcessDiagnostics extends Context.Service<
   ProcessDiagnostics,
-  ProcessDiagnosticsShape
+  {
+    readonly read: Effect.Effect<ServerProcessDiagnosticsResult>;
+    readonly signal: (input: {
+      readonly pid: number;
+      readonly signal: ServerProcessSignal;
+    }) => Effect.Effect<ServerSignalProcessResult>;
+  }
 >()("t3/diagnostics/ProcessDiagnostics") {}
-class ProcessDiagnosticsError extends Schema.TaggedErrorClass<ProcessDiagnosticsError>()(
+class ProcessDiagnosticsQueryTimeoutError extends Schema.TaggedErrorClass<ProcessDiagnosticsQueryTimeoutError>()(
-  "ProcessDiagnosticsError",
+  "ProcessDiagnosticsQueryTimeoutError",
+  { command: Schema.String },
+) {
+  override get message(): string {
+    return `Process diagnostics query '${this.command}' timed out.`;
+  }
+}
+class ProcessDiagnosticsQueryFailedError extends Schema.TaggedErrorClass<ProcessDiagnosticsQueryFailedError>()(
+  "ProcessDiagnosticsQueryFailedError",
   {
-    message: Schema.String,
+    command: Schema.String,
+    stderr: Schema.optional(Schema.String),
     cause: Schema.optional(Schema.Defect()),
   },
-) {}
+) {
-const isProcessDiagnosticsError = Schema.is(ProcessDiagnosticsError);
+  override get message(): string {
+    return this.stderr?.trim() || `Failed to query process diagnostics with '${this.command}'.`;
+  }
+}
-function toProcessDiagnosticsError(message: string, cause?: unknown): ProcessDiagnosticsError {
+class ProcessDiagnosticsServerProcessSignalError extends Schema.TaggedErrorClass<ProcessDiagnosticsServerProcessSignalError>()(
-  return new ProcessDiagnosticsError({
+  "ProcessDiagnosticsServerProcessSignalError",
-    message,
+  { pid: Schema.Number },
-    ...(cause === undefined ? {} : { cause }),
+) {
-  });
+  override get message(): string {
+    return "Refusing to signal the T3 server process.";
+  }
+}
+class ProcessDiagnosticsNotDescendantError extends Schema.TaggedErrorClass<ProcessDiagnosticsNotDescendantError>()(
+  "ProcessDiagnosticsNotDescendantError",
+  { pid: Schema.Number },
+) {
+  override get message(): string {
+    return `Process ${this.pid} is not a live descendant of the T3 server.`;
+  }
 }
+class ProcessDiagnosticsSignalFailedError extends Schema.TaggedErrorClass<ProcessDiagnosticsSignalFailedError>()(
+  "ProcessDiagnosticsSignalFailedError",
+  {
+    pid: Schema.Number,
+    signal: Schema.String,
+    cause: Schema.Defect(),
+  },
+) {
+  override get message(): string {
+    return `Failed to signal process ${this.pid} with ${this.signal}.`;
+  }
+}
+const ProcessDiagnosticsError = Schema.Union([
+  ProcessDiagnosticsQueryTimeoutError,
+  ProcessDiagnosticsQueryFailedError,
+  ProcessDiagnosticsServerProcessSignalError,
+  ProcessDiagnosticsNotDescendantError,
+  ProcessDiagnosticsSignalFailedError,
+]);
+type ProcessDiagnosticsError = typeof ProcessDiagnosticsError.Type;
+const isProcessDiagnosticsError = Schema.is(ProcessDiagnosticsError);
 function parsePositiveInt(value: string): number | null {
   const parsed = Number.parseInt(value, 10);
   return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
 @@ -272,11 +318,7 @@ interface ProcessOutput {
 }
 const runProcess = Effect.fn("runProcess")(
-  function* (input: {
+  function* (input: { readonly command: string; readonly args: ReadonlyArray<string> }) {
-    readonly command: string;
-    readonly args: ReadonlyArray<string>;
-    readonly errorMessage: string;
-  }) {
     const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
     // `ps` and `powershell.exe` are real executables; spawning through cmd.exe
     // shell mode would re-tokenize the PowerShell `-Command` payload (which
 @@ -315,14 +357,22 @@ const runProcess = Effect.fn("runProcess")(
       Effect.timeoutOption(Duration.millis(PROCESS_QUERY_TIMEOUT_MS)),
       Effect.flatMap((result) =>
         Option.match(result, {
-          onNone: () => Effect.fail(toProcessDiagnosticsError(`${input.errorMessage} timed out.`)),
+          onNone: () =>
+            Effect.fail(
+              new ProcessDiagnosticsQueryTimeoutError({
+                command: input.command,
+              }),
+            ),
           onSome: Effect.succeed,
         }),
       ),
       Effect.mapError((cause) =>
         isProcessDiagnosticsError(cause)
           ? cause
-          : toProcessDiagnosticsError(input.errorMessage, cause),
+          : new ProcessDiagnosticsQueryFailedError({
+              command: input.command,
+              cause,
+            }),
       ),
     ),
 );
 @@ -335,11 +385,15 @@ function readPosixProcessRows(): Effect.Effect<
   return runProcess({
     command: "ps",
     args: ["-axo", POSIX_PROCESS_QUERY_COMMAND],
-    errorMessage: "Failed to query process diagnostics.",
   }).pipe(
     Effect.flatMap((result) =>
       result.exitCode !== 0
-        ? Effect.fail(toProcessDiagnosticsError(result.stderr.trim() || "ps failed."))
+        ? Effect.fail(
+            new ProcessDiagnosticsQueryFailedError({
+              command: "ps",
+              stderr: result.stderr.trim() || "ps failed.",
+            }),
+          )
         : Effect.succeed(parsePosixProcessRows(result.stdout)),
     ),
   );
 @@ -361,12 +415,14 @@ function readWindowsProcessRows(): Effect.Effect<
   return runProcess({
     command: "powershell.exe",
     args: ["-NoProfile", "-NonInteractive", "-Command", command],
-    errorMessage: "Failed to query process diagnostics.",
   }).pipe(
     Effect.flatMap((result) =>
       result.exitCode !== 0
         ? Effect.fail(
-            toProcessDiagnosticsError(result.stderr.trim() || "PowerShell process query failed."),
+            new ProcessDiagnosticsQueryFailedError({
+              command: "powershell.exe",
+              stderr: result.stderr.trim() || "PowerShell process query failed.",
+            }),
           )
         : Effect.succeed(parseWindowsProcessRows(result.stdout)),
     ),
 @@ -390,7 +446,11 @@ function assertDescendantPid(
   pid: number,
 ): Effect.Effect<void, ProcessDiagnosticsError, ChildProcessSpawner.ChildProcessSpawner> {
   if (pid === process.pid) {
-    return Effect.fail(toProcessDiagnosticsError("Refusing to signal the T3 server process."));
+    return Effect.fail(
+      new ProcessDiagnosticsServerProcessSignalError({
+        pid,
+      }),
+    );
   }
   return readProcessRows.pipe(
 @@ -402,16 +462,18 @@ function assertDescendantPid(
       return descendant
         ? Effect.void
         : Effect.fail(
-            toProcessDiagnosticsError(`Process ${pid} is not a live descendant of the T3 server.`),
+            new ProcessDiagnosticsNotDescendantError({
+              pid,
+            }),
           );
     }),
   );
 }
-export const make = Effect.fn("makeProcessDiagnostics")(function* () {
+export const make = Effect.gen(function* () {
   const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
-  const read: ProcessDiagnosticsShape["read"] = Effect.gen(function* () {
+  const read: ProcessDiagnostics["Service"]["read"] = Effect.gen(function* () {
     const readAt = yield* DateTime.now;
     const rows = yield* readProcessRows.pipe(
       Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
 @@ -427,7 +489,7 @@ export const make = Effect.fn("makeProcessDiagnostics")(function* () {
     ),
   );
-  const signal: ProcessDiagnosticsShape["signal"] = Effect.fn("ProcessDiagnostics.signal")(
+  const signal: ProcessDiagnostics["Service"]["signal"] = Effect.fn("ProcessDiagnostics.signal")(
     function* (input) {
       return yield* assertDescendantPid(input.pid).pipe(
         Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
 @@ -443,10 +505,11 @@ export const make = Effect.fn("makeProcessDiagnostics")(function* () {
               };
             },
             catch: (cause) =>
-              toProcessDiagnosticsError(
+              new ProcessDiagnosticsSignalFailedError({
-                `Failed to signal process ${input.pid} with ${input.signal}.`,
+                pid: input.pid,
+                signal: input.signal,
                 cause,
-              ),
+              }),
           }),
         ),
         Effect.catch((error: ProcessDiagnosticsError) =>
 @@ -464,4 +527,4 @@ export const make = Effect.fn("makeProcessDiagnostics")(function* () {
   return ProcessDiagnostics.of({ read, signal });
 });
-export const layer = Layer.effect(ProcessDiagnostics, make());
+export const layer = Layer.effect(ProcessDiagnostics, make);

apps/server/src/diagnostics/ProcessResourceMonitor.test.ts+10-13

...	@@ -3,16 +3,13 @@ import * as DateTime from "effect/DateTime";	...	@@ -3,16 +3,13 @@ import * as DateTime from "effect/DateTime";
3	import * as Effect from "effect/Effect";	3	import * as Effect from "effect/Effect";
4	import * as Option from "effect/Option";	4	import * as Option from "effect/Option";
5		5
6	import {	6	import * as ProcessResourceMonitor from "./ProcessResourceMonitor.ts";
7	aggregateProcessResourceHistory,
8	collectMonitoredSamples,
9	} from "./ProcessResourceMonitor.ts";
10		7
11	describe("ProcessResourceMonitor", () => {	8	describe("ProcessResourceMonitor", () => {
12	it.effect("samples the server root process and descendants", () =>	9	it.effect("samples the server root process and descendants", () =>
13	Effect.sync(() => {	10	Effect.sync(() => {
14	const sampledAt = DateTime.makeUnsafe("2026-05-05T10:00:00.000Z");	11	const sampledAt = DateTime.makeUnsafe("2026-05-05T10:00:00.000Z");
15	const samples = collectMonitoredSamples({	12	const samples = ProcessResourceMonitor.collectMonitoredSamples({
16	serverPid: 100,	13	serverPid: 100,
17	sampledAt,	14	sampledAt,
18	sampledAtMs: DateTime.toEpochMillis(sampledAt),	15	sampledAtMs: DateTime.toEpochMillis(sampledAt),
...	@@ -72,7 +69,7 @@ describe("ProcessResourceMonitor", () => {	...	@@ -72,7 +69,7 @@ describe("ProcessResourceMonitor", () => {
72	const firstAt = DateTime.makeUnsafe("2026-05-05T10:00:00.000Z");	69	const firstAt = DateTime.makeUnsafe("2026-05-05T10:00:00.000Z");
73	const secondAt = DateTime.makeUnsafe("2026-05-05T10:00:05.000Z");	70	const secondAt = DateTime.makeUnsafe("2026-05-05T10:00:05.000Z");
74	const samples = [	71	const samples = [
75	...collectMonitoredSamples({	72	...ProcessResourceMonitor.collectMonitoredSamples({
76	serverPid: 100,	73	serverPid: 100,
77	sampledAt: firstAt,	74	sampledAt: firstAt,
78	sampledAtMs: DateTime.toEpochMillis(firstAt),	75	sampledAtMs: DateTime.toEpochMillis(firstAt),
...	@@ -89,7 +86,7 @@ describe("ProcessResourceMonitor", () => {	...	@@ -89,7 +86,7 @@ describe("ProcessResourceMonitor", () => {
89	},	86	},
90	],	87	],
91	}),	88	}),
92	...collectMonitoredSamples({	89	...ProcessResourceMonitor.collectMonitoredSamples({
93	serverPid: 100,	90	serverPid: 100,
94	sampledAt: secondAt,	91	sampledAt: secondAt,
95	sampledAtMs: DateTime.toEpochMillis(secondAt),	92	sampledAtMs: DateTime.toEpochMillis(secondAt),
...	@@ -108,7 +105,7 @@ describe("ProcessResourceMonitor", () => {	...	@@ -108,7 +105,7 @@ describe("ProcessResourceMonitor", () => {
108	}),	105	}),
109	];	106	];
110		107
111	const result = aggregateProcessResourceHistory({	108	const result = ProcessResourceMonitor.aggregateProcessResourceHistory({
112	samples,	109	samples,
113	readAt: secondAt,	110	readAt: secondAt,
114	readAtMs: DateTime.toEpochMillis(secondAt),	111	readAtMs: DateTime.toEpochMillis(secondAt),
...	@@ -132,7 +129,7 @@ describe("ProcessResourceMonitor", () => {	...	@@ -132,7 +129,7 @@ describe("ProcessResourceMonitor", () => {
132	const firstAt = DateTime.makeUnsafe("2026-05-05T10:00:00.400Z");	129	const firstAt = DateTime.makeUnsafe("2026-05-05T10:00:00.400Z");
133	const secondAt = DateTime.makeUnsafe("2026-05-05T10:00:05.900Z");	130	const secondAt = DateTime.makeUnsafe("2026-05-05T10:00:05.900Z");
134	const samples = [	131	const samples = [
135	...collectMonitoredSamples({	132	...ProcessResourceMonitor.collectMonitoredSamples({
136	serverPid: 100,	133	serverPid: 100,
137	sampledAt: firstAt,	134	sampledAt: firstAt,
138	sampledAtMs: DateTime.toEpochMillis(firstAt),	135	sampledAtMs: DateTime.toEpochMillis(firstAt),
...	@@ -149,7 +146,7 @@ describe("ProcessResourceMonitor", () => {	...	@@ -149,7 +146,7 @@ describe("ProcessResourceMonitor", () => {
149	},	146	},
150	],	147	],
151	}),	148	}),
152	...collectMonitoredSamples({	149	...ProcessResourceMonitor.collectMonitoredSamples({
153	serverPid: 100,	150	serverPid: 100,
154	sampledAt: secondAt,	151	sampledAt: secondAt,
155	sampledAtMs: DateTime.toEpochMillis(secondAt),	152	sampledAtMs: DateTime.toEpochMillis(secondAt),
...	@@ -168,7 +165,7 @@ describe("ProcessResourceMonitor", () => {	...	@@ -168,7 +165,7 @@ describe("ProcessResourceMonitor", () => {
168	}),	165	}),
169	];	166	];
170		167
171	const result = aggregateProcessResourceHistory({	168	const result = ProcessResourceMonitor.aggregateProcessResourceHistory({
172	samples,	169	samples,
173	readAt: secondAt,	170	readAt: secondAt,
174	readAtMs: DateTime.toEpochMillis(secondAt),	171	readAtMs: DateTime.toEpochMillis(secondAt),
...	@@ -187,7 +184,7 @@ describe("ProcessResourceMonitor", () => {	...	@@ -187,7 +184,7 @@ describe("ProcessResourceMonitor", () => {
187	it.effect("returns all process summaries in the selected window", () =>	184	it.effect("returns all process summaries in the selected window", () =>
188	Effect.sync(() => {	185	Effect.sync(() => {
189	const sampledAt = DateTime.makeUnsafe("2026-05-05T10:00:00.000Z");	186	const sampledAt = DateTime.makeUnsafe("2026-05-05T10:00:00.000Z");
190	const samples = collectMonitoredSamples({	187	const samples = ProcessResourceMonitor.collectMonitoredSamples({
191	serverPid: 100,	188	serverPid: 100,
192	sampledAt,	189	sampledAt,
193	sampledAtMs: DateTime.toEpochMillis(sampledAt),	190	sampledAtMs: DateTime.toEpochMillis(sampledAt),
...	@@ -215,7 +212,7 @@ describe("ProcessResourceMonitor", () => {	...	@@ -215,7 +212,7 @@ describe("ProcessResourceMonitor", () => {
215	],	212	],
216	});	213	});
217		214
218	const result = aggregateProcessResourceHistory({	215	const result = ProcessResourceMonitor.aggregateProcessResourceHistory({
219	samples,	216	samples,
220	readAt: sampledAt,	217	readAt: sampledAt,
221	readAtMs: DateTime.toEpochMillis(sampledAt),	218	readAtMs: DateTime.toEpochMillis(sampledAt),

apps/server/src/diagnostics/ProcessResourceMonitor.ts+21-23

 @@ -10,14 +10,9 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Ref from "effect/Ref";
-import { ChildProcessSpawner } from "effect/unstable/process";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
-import {
+import * as ProcessDiagnostics from "./ProcessDiagnostics.ts";
-  buildDescendantEntries,
-  isDiagnosticsQueryProcess,
-  type ProcessRow,
-  readProcessRows,
-} from "./ProcessDiagnostics.ts";
 const SAMPLE_INTERVAL_MS = 5_000;
 const RETENTION_MS = 60 * 60_000;
 @@ -41,38 +36,41 @@ interface MonitorState {
   readonly lastError: string | null;
 }
-export interface ProcessResourceMonitorShape {
-  readonly readHistory: (
-    input: ServerProcessResourceHistoryInput,
-  ) => Effect.Effect<ServerProcessResourceHistoryResult>;
-}
 export class ProcessResourceMonitor extends Context.Service<
   ProcessResourceMonitor,
-  ProcessResourceMonitorShape
+  {
+    readonly readHistory: (
+      input: ServerProcessResourceHistoryInput,
+    ) => Effect.Effect<ServerProcessResourceHistoryResult>;
+  }
 >()("t3/diagnostics/ProcessResourceMonitor") {}
 function dateTimeFromMillis(ms: number): DateTime.Utc {
   return DateTime.makeUnsafe(ms);
 }
-function sampleKey(row: Pick<ProcessRow, "pid" | "command">): string {
+function sampleKey(row: Pick<ProcessDiagnostics.ProcessRow, "pid" | "command">): string {
   return `${row.pid}:${row.command}`;
 }
-function findServerRootRow(rows: ReadonlyArray<ProcessRow>, serverPid: number): ProcessRow | null {
+function findServerRootRow(
+  rows: ReadonlyArray<ProcessDiagnostics.ProcessRow>,
+  serverPid: number,
+): ProcessDiagnostics.ProcessRow | null {
   return rows.find((row) => row.pid === serverPid) ?? null;
 }
 export function collectMonitoredSamples(input: {
-  readonly rows: ReadonlyArray<ProcessRow>;
+  readonly rows: ReadonlyArray<ProcessDiagnostics.ProcessRow>;
   readonly serverPid: number;
   readonly sampledAt: DateTime.Utc;
   readonly sampledAtMs: number;
 }): ReadonlyArray<ProcessResourceSample> {
-  const rows = input.rows.filter((row) => !isDiagnosticsQueryProcess(row, input.serverPid));
+  const rows = input.rows.filter(
+    (row) => !ProcessDiagnostics.isDiagnosticsQueryProcess(row, input.serverPid),
+  );
   const root = findServerRootRow(rows, input.serverPid);
-  const descendants = buildDescendantEntries(rows, input.serverPid);
+  const descendants = ProcessDiagnostics.buildDescendantEntries(rows, input.serverPid);
   const samples: ProcessResourceSample[] = [];
   if (root) {
 @@ -245,14 +243,14 @@ export function aggregateProcessResourceHistory(input: {
   };
 }
-export const make = Effect.fn("makeProcessResourceMonitor")(function* () {
+export const make = Effect.gen(function* () {
   const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
   const state = yield* Ref.make<MonitorState>({ samples: [], lastError: null });
   const sampleOnce = Effect.gen(function* () {
     const sampledAt = yield* DateTime.now;
     const sampledAtMs = DateTime.toEpochMillis(sampledAt);
-    const rows = yield* readProcessRows.pipe(
+    const rows = yield* ProcessDiagnostics.readProcessRows.pipe(
       Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
     );
     const samples = collectMonitoredSamples({
 @@ -278,7 +276,7 @@ export const make = Effect.fn("makeProcessResourceMonitor")(function* () {
     Effect.forkScoped,
   );
-  const readHistory: ProcessResourceMonitorShape["readHistory"] = (input) =>
+  const readHistory: ProcessResourceMonitor["Service"]["readHistory"] = (input) =>
     Effect.gen(function* () {
       const readAt = yield* DateTime.now;
       const readAtMs = DateTime.toEpochMillis(readAt);
 @@ -296,4 +294,4 @@ export const make = Effect.fn("makeProcessResourceMonitor")(function* () {
   return ProcessResourceMonitor.of({ readHistory });
 });
-export const layer = Layer.effect(ProcessResourceMonitor, make());
+export const layer = Layer.effect(ProcessResourceMonitor, make);

apps/server/src/diagnostics/TraceDiagnostics.ts+11-10

apps/server/src/http.ts+10-9

 @@ -24,13 +24,13 @@ import {
 import * as HttpApiBuilder from "effect/unstable/httpapi/HttpApiBuilder";
 import { OtlpTracer } from "effect/unstable/observability";
-import { resolveStaticDir, ServerConfig } from "./config.ts";
+import * as ServerConfig from "./config.ts";
 import {
   ASSET_ROUTE_PREFIX,
   FALLBACK_PROJECT_FAVICON_SVG,
   resolveAsset,
 } from "./assets/AssetAccess.ts";
-import { BrowserTraceCollector } from "./observability/Services/BrowserTraceCollector.ts";
+import * as BrowserTraceCollector from "./observability/BrowserTraceCollector.ts";
 import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts";
 import { traceRelayRequest } from "./cloud/traceRelayRequest.ts";
 import {
 @@ -39,7 +39,7 @@ import {
   failEnvironmentAuthInvalid,
   failEnvironmentInternal,
 } from "./auth/http.ts";
-import { ServerEnvironment } from "./environment/Services/ServerEnvironment.ts";
+import * as ServerEnvironment from "./environment/Services/ServerEnvironment.ts";
 import { browserApiCorsAllowedHeaders, browserApiCorsAllowedMethods } from "./httpCors.ts";
 const OTLP_TRACES_PROXY_PATH = "/api/observability/v1/traces";
 @@ -47,7 +47,7 @@ const LOOPBACK_HOSTNAMES = new Set(["127.0.0.1", "::1", "localhost"]);
 export const browserApiCorsLayer = Layer.unwrap(
   Effect.gen(function* () {
-    const config = yield* ServerConfig;
+    const config = yield* ServerConfig.ServerConfig;
     const devOrigin = config.devUrl?.origin;
     return HttpRouter.cors({
       ...(devOrigin ? { allowedOrigins: [devOrigin], credentials: true } : {}),
 @@ -95,7 +95,7 @@ export const serverEnvironmentHttpApiLayer = HttpApiBuilder.group(
   EnvironmentHttpApi,
   "metadata",
   Effect.fnUntraced(function* (handlers) {
-    const serverEnvironment = yield* ServerEnvironment;
+    const serverEnvironment = yield* ServerEnvironment.ServerEnvironment;
     return handlers.handle(
       "descriptor",
       Effect.fn("environment.metadata.descriptor")(function* (args) {
 @@ -117,9 +117,9 @@ export const otlpTracesProxyRouteLayer = HttpRouter.add(
   Effect.gen(function* () {
     yield* authenticateRawRouteWithScope(AuthOrchestrationOperateScope);
     const request = yield* HttpServerRequest.HttpServerRequest;
-    const config = yield* ServerConfig;
+    const config = yield* ServerConfig.ServerConfig;
     const otlpTracesUrl = config.otlpTracesUrl;
-    const browserTraceCollector = yield* BrowserTraceCollector;
+    const browserTraceCollector = yield* BrowserTraceCollector.BrowserTraceCollector;
     const httpClient = yield* HttpClient.HttpClient;
     const bodyJson = cast<unknown, OtlpTracer.TraceData>(yield* request.json);
 @@ -223,14 +223,15 @@ export const staticAndDevRouteLayer = HttpRouter.add(
       return HttpServerResponse.text("Bad Request", { status: 400 });
     }
-    const config = yield* ServerConfig;
+    const config = yield* ServerConfig.ServerConfig;
     if (config.devUrl && isLoopbackHostname(url.value.hostname)) {
       return HttpServerResponse.redirect(resolveDevRedirectUrl(config.devUrl, url.value), {
         status: 302,
       });
     }
-    const staticDir = config.staticDir ?? (config.devUrl ? yield* resolveStaticDir() : undefined);
+    const staticDir =
+      config.staticDir ?? (config.devUrl ? yield* ServerConfig.resolveStaticDir() : undefined);
     if (!staticDir) {
       return HttpServerResponse.text("No static directory configured and no dev URL set.", {
         status: 503,

apps/server/src/observability/BrowserTraceCollector.ts created+23

...	@@ -0,0 +1,23 @@
1	import type { TraceRecord, TraceSink } from "@t3tools/shared/observability";
2	import * as Context from "effect/Context";
3	import * as Effect from "effect/Effect";
4	import * as Layer from "effect/Layer";
5
6	export class BrowserTraceCollector extends Context.Service<
7	BrowserTraceCollector,
8	{
9	readonly record: (records: ReadonlyArray<TraceRecord>) => Effect.Effect<void>;
10	}
11	>()("t3/observability/BrowserTraceCollector") {}
12
13	export const make = (sink: TraceSink): BrowserTraceCollector["Service"] =>
14	BrowserTraceCollector.of({
15	record: (records) =>
16	Effect.sync(() => {
17	for (const record of records) {
18	sink.push(record);
19	}
20	}),
21	});
22
23	export const layer = (sink: TraceSink) => Layer.succeed(BrowserTraceCollector, make(sink));

apps/server/src/observability/Layers/Observability.ts+7-12

 @@ -4,17 +4,19 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as References from "effect/References";
 import * as Tracer from "effect/Tracer";
-import { OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
+import * as OtlpMetrics from "effect/unstable/observability/OtlpMetrics";
+import * as OtlpSerialization from "effect/unstable/observability/OtlpSerialization";
+import * as OtlpTracer from "effect/unstable/observability/OtlpTracer";
-import { ServerConfig } from "../../config.ts";
+import * as ServerConfig from "../../config.ts";
 import { ServerLoggerLive } from "../../serverLogger.ts";
-import { BrowserTraceCollector } from "../Services/BrowserTraceCollector.ts";
+import * as BrowserTraceCollector from "../BrowserTraceCollector.ts";
 const otlpSerializationLayer = OtlpSerialization.layerJson;
 export const ObservabilityLive = Layer.unwrap(
   Effect.gen(function* () {
-    const config = yield* ServerConfig;
+    const config = yield* ServerConfig.ServerConfig;
     const traceReferencesLayer = Layer.mergeAll(
       Layer.succeed(Tracer.MinimumTraceLevel, config.traceMinLevel),
 @@ -56,14 +58,7 @@ export const ObservabilityLive = Layer.unwrap(
         return Layer.mergeAll(
           Layer.succeed(Tracer.Tracer, tracer),
-          Layer.succeed(BrowserTraceCollector, {
+          BrowserTraceCollector.layer(sink),
-            record: (records) =>
-              Effect.sync(() => {
-                for (const record of records) {
-                  sink.push(record);
-                }
-              }),
-          }),
         );
       }),
     ).pipe(Layer.provideMerge(otlpSerializationLayer));

apps/server/src/observability/Services/BrowserTraceCollector.ts deleted-12

...	@@ -1,12 +0,0 @@
1	import type { TraceRecord } from "@t3tools/shared/observability";
2	import * as Context from "effect/Context";
3	import type * as Effect from "effect/Effect";
4
5	export interface BrowserTraceCollectorShape {
6	readonly record: (records: ReadonlyArray<TraceRecord>) => Effect.Effect<void>;
7	}
8
9	export class BrowserTraceCollector extends Context.Service<
10	BrowserTraceCollector,
11	BrowserTraceCollectorShape
12	>()("t3/observability/Services/BrowserTraceCollector") {}

apps/server/src/provider/Layers/ProviderService.test.ts+164-75

 @@ -43,14 +43,11 @@ import {
   type ProviderAdapterError,
 } from "../Errors.ts";
 import type { ProviderAdapterShape } from "../Services/ProviderAdapter.ts";
-import {
+import * as ProviderAdapterRegistry from "../Services/ProviderAdapterRegistry.ts";
-  ProviderAdapterRegistry,
+import * as ProviderService from "../Services/ProviderService.ts";
-  type ProviderAdapterRegistryShape,
+import * as ProviderSessionDirectory from "../Services/ProviderSessionDirectory.ts";
-} from "../Services/ProviderAdapterRegistry.ts";
-import { ProviderService } from "../Services/ProviderService.ts";
-import { ProviderSessionDirectory } from "../Services/ProviderSessionDirectory.ts";
 import { makeProviderServiceLive } from "./ProviderService.ts";
-import { NoOpProviderEventLoggers, ProviderEventLoggers } from "./ProviderEventLoggers.ts";
+import * as ProviderEventLoggers from "./ProviderEventLoggers.ts";
 import { ProviderSessionDirectoryLive } from "./ProviderSessionDirectory.ts";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import * as ProviderSessionRuntime from "../../persistence/ProviderSessionRuntime.ts";
 @@ -58,11 +55,11 @@ import {
   makeSqlitePersistenceLive,
   SqlitePersistenceMemory,
 } from "../../persistence/Layers/Sqlite.ts";
-import { ServerSettingsService } from "../../serverSettings.ts";
+import * as ServerSettings from "../../serverSettings.ts";
-import { AnalyticsService } from "../../telemetry/Services/AnalyticsService.ts";
+import * as AnalyticsService from "../../telemetry/AnalyticsService.ts";
 import { makeAdapterRegistryMock } from "../testUtils/providerAdapterRegistryMock.ts";
-const defaultServerSettingsLayer = ServerSettingsService.layerTest();
+const defaultServerSettingsLayer = ServerSettings.ServerSettingsService.layerTest();
 const asRequestId = (value: string): ApprovalRequestId => ApprovalRequestId.make(value);
 const asEventId = (value: string): EventId => EventId.make(value);
 @@ -280,7 +277,10 @@ function makeProviderServiceLayer() {
     [ProviderDriverKind.make("cursor")]: cursor.adapter,
   });
-  const providerAdapterLayer = Layer.succeed(ProviderAdapterRegistry, registry);
+  const providerAdapterLayer = Layer.succeed(
+    ProviderAdapterRegistry.ProviderAdapterRegistry,
+    registry,
+  );
   const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe(
     Layer.provide(SqlitePersistenceMemory),
   );
 @@ -293,7 +293,12 @@ function makeProviderServiceLayer() {
         Layer.provide(directoryLayer),
         Layer.provide(defaultServerSettingsLayer),
         Layer.provideMerge(AnalyticsService.layerTest),
-        Layer.provide(Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers)),
+        Layer.provide(
+          Layer.succeed(
+            ProviderEventLoggers.ProviderEventLoggers,
+            ProviderEventLoggers.NoOpProviderEventLoggers,
+          ),
+        ),
       ),
       directoryLayer,
 @@ -325,7 +330,10 @@ it.effect("ProviderServiceLive catches stopAll failures during shutdown", () =>
     const registry = makeAdapterRegistryMock({
       [CODEX_DRIVER]: codex.adapter,
     });
-    const providerAdapterLayer = Layer.succeed(ProviderAdapterRegistry, registry);
+    const providerAdapterLayer = Layer.succeed(
+      ProviderAdapterRegistry.ProviderAdapterRegistry,
+      registry,
+    );
     const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe(
       Layer.provide(SqlitePersistenceMemory),
     );
 @@ -336,7 +344,12 @@ it.effect("ProviderServiceLive catches stopAll failures during shutdown", () =>
         Layer.provide(directoryLayer),
         Layer.provide(defaultServerSettingsLayer),
         Layer.provideMerge(AnalyticsService.layerTest),
-        Layer.provide(Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers)),
+        Layer.provide(
+          Layer.succeed(
+            ProviderEventLoggers.ProviderEventLoggers,
+            ProviderEventLoggers.NoOpProviderEventLoggers,
+          ),
+        ),
       ),
       directoryLayer,
       runtimeRepositoryLayer,
 @@ -345,7 +358,7 @@ it.effect("ProviderServiceLive catches stopAll failures during shutdown", () =>
     const scope = yield* Scope.make();
     const runtimeServices = yield* Layer.build(providerLayer).pipe(Scope.provide(scope));
-    yield* ProviderService.pipe(Effect.provide(runtimeServices));
+    yield* ProviderService.ProviderService.pipe(Effect.provide(runtimeServices));
     const closeExit = yield* Scope.close(scope, Exit.void).pipe(Effect.exit);
     assert.equal(Exit.isSuccess(closeExit), true);
 @@ -361,7 +374,7 @@ it.effect("ProviderServiceLive rejects new sessions for disabled providers", ()
       [CODEX_DRIVER]: codex.adapter,
       [CLAUDE_AGENT_DRIVER]: claude.adapter,
     });
-    const registry: ProviderAdapterRegistryShape = {
+    const registry: ProviderAdapterRegistry.ProviderAdapterRegistry["Service"] = {
       ...registryBase,
       getInstanceInfo: (instanceId) =>
         instanceId === claudeAgentInstanceId
 @@ -377,7 +390,10 @@ it.effect("ProviderServiceLive rejects new sessions for disabled providers", ()
             })
           : registryBase.getInstanceInfo(instanceId),
     };
-    const providerAdapterLayer = Layer.succeed(ProviderAdapterRegistry, registry);
+    const providerAdapterLayer = Layer.succeed(
+      ProviderAdapterRegistry.ProviderAdapterRegistry,
+      registry,
+    );
     const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe(
       Layer.provide(SqlitePersistenceMemory),
     );
 @@ -387,12 +403,17 @@ it.effect("ProviderServiceLive rejects new sessions for disabled providers", ()
       Layer.provide(directoryLayer),
       Layer.provide(defaultServerSettingsLayer),
       Layer.provide(AnalyticsService.layerTest),
-      Layer.provide(Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers)),
+      Layer.provide(
+        Layer.succeed(
+          ProviderEventLoggers.ProviderEventLoggers,
+          ProviderEventLoggers.NoOpProviderEventLoggers,
+        ),
+      ),
     );
     const failure = yield* Effect.flip(
       Effect.gen(function* () {
-        const provider = yield* ProviderService;
+        const provider = yield* ProviderService.ProviderService;
         return yield* provider.startSession(asThreadId("thread-disabled"), {
           provider: ProviderDriverKind.make("claudeAgent"),
           providerInstanceId: claudeAgentInstanceId,
 @@ -419,7 +440,7 @@ it.effect(
         new ProviderUnsupportedError({
           provider: driverKind,
         });
-      const registry: ProviderAdapterRegistryShape = {
+      const registry: ProviderAdapterRegistry.ProviderAdapterRegistry["Service"] = {
         getByInstance: (requestedInstanceId) =>
           requestedInstanceId === instanceId
             ? Effect.succeed(codex.adapter)
 @@ -444,8 +465,11 @@ it.effect(
           PubSub.subscribe(pubsub),
         ),
       };
-      const providerAdapterLayer = Layer.succeed(ProviderAdapterRegistry, registry);
+      const providerAdapterLayer = Layer.succeed(
-      const serverSettingsLayer = ServerSettingsService.layerTest({
+        ProviderAdapterRegistry.ProviderAdapterRegistry,
+        registry,
+      );
+      const serverSettingsLayer = ServerSettings.ServerSettingsService.layerTest({
         providers: {
           codex: {
             enabled: false,
 @@ -463,11 +487,16 @@ it.effect(
         Layer.provide(directoryLayer),
         Layer.provide(serverSettingsLayer),
         Layer.provide(AnalyticsService.layerTest),
-        Layer.provide(Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers)),
+        Layer.provide(
+          Layer.succeed(
+            ProviderEventLoggers.ProviderEventLoggers,
+            ProviderEventLoggers.NoOpProviderEventLoggers,
+          ),
+        ),
       );
       const session = yield* Effect.gen(function* () {
-        const provider = yield* ProviderService;
+        const provider = yield* ProviderService.ProviderService;
         return yield* provider.startSession(asThreadId("thread-enabled-custom"), {
           provider: driverKind,
           providerInstanceId: instanceId,
 @@ -490,7 +519,7 @@ it.effect("ProviderServiceLive rejects new sessions for disabled custom instance
       new ProviderUnsupportedError({
         provider: ProviderDriverKind.make("codex"),
       });
-    const registry: ProviderAdapterRegistryShape = {
+    const registry: ProviderAdapterRegistry.ProviderAdapterRegistry["Service"] = {
       getByInstance: (requestedInstanceId) =>
         requestedInstanceId === instanceId
           ? Effect.succeed(codex.adapter)
 @@ -515,7 +544,10 @@ it.effect("ProviderServiceLive rejects new sessions for disabled custom instance
         PubSub.subscribe(pubsub),
       ),
     };
-    const providerAdapterLayer = Layer.succeed(ProviderAdapterRegistry, registry);
+    const providerAdapterLayer = Layer.succeed(
+      ProviderAdapterRegistry.ProviderAdapterRegistry,
+      registry,
+    );
     const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe(
       Layer.provide(SqlitePersistenceMemory),
     );
 @@ -525,12 +557,17 @@ it.effect("ProviderServiceLive rejects new sessions for disabled custom instance
       Layer.provide(directoryLayer),
       Layer.provide(defaultServerSettingsLayer),
       Layer.provide(AnalyticsService.layerTest),
-      Layer.provide(Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers)),
+      Layer.provide(
+        Layer.succeed(
+          ProviderEventLoggers.ProviderEventLoggers,
+          ProviderEventLoggers.NoOpProviderEventLoggers,
+        ),
+      ),
     );
     const failure = yield* Effect.flip(
       Effect.gen(function* () {
-        const provider = yield* ProviderService;
+        const provider = yield* ProviderService.ProviderService;
         return yield* provider.startSession(asThreadId("thread-disabled-instance"), {
           provider: ProviderDriverKind.make("codex"),
           providerInstanceId: instanceId,
 @@ -571,15 +608,20 @@ it.effect("ProviderServiceLive writes canonical events to the emitting thread se
         close: () => Effect.void,
       },
     }).pipe(
-      Layer.provide(Layer.succeed(ProviderAdapterRegistry, registry)),
+      Layer.provide(Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, registry)),
       Layer.provide(directoryLayer),
       Layer.provide(defaultServerSettingsLayer),
       Layer.provide(AnalyticsService.layerTest),
-      Layer.provide(Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers)),
+      Layer.provide(
+        Layer.succeed(
+          ProviderEventLoggers.ProviderEventLoggers,
+          ProviderEventLoggers.NoOpProviderEventLoggers,
+        ),
+      ),
     );
     yield* Effect.gen(function* () {
-      yield* ProviderService;
+      yield* ProviderService.ProviderService;
       yield* advanceTestClock(10);
       codex.emit({
         eventId: asEventId("evt-canonical-thread-segment"),
 @@ -617,7 +659,7 @@ it.effect("ProviderServiceLive keeps persisted resumable sessions on startup", (
     const directoryLayer = ProviderSessionDirectoryLive.pipe(Layer.provide(runtimeRepositoryLayer));
     yield* Effect.gen(function* () {
-      const directory = yield* ProviderSessionDirectory;
+      const directory = yield* ProviderSessionDirectory.ProviderSessionDirectory;
       yield* directory.upsert({
         provider: ProviderDriverKind.make("codex"),
         providerInstanceId: codexInstanceId,
 @@ -626,17 +668,22 @@ it.effect("ProviderServiceLive keeps persisted resumable sessions on startup", (
     }).pipe(Effect.provide(directoryLayer));
     const providerLayer = makeProviderServiceLive().pipe(
-      Layer.provide(Layer.succeed(ProviderAdapterRegistry, registry)),
+      Layer.provide(Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, registry)),
       Layer.provide(directoryLayer),
       Layer.provide(defaultServerSettingsLayer),
       Layer.provide(AnalyticsService.layerTest),
-      Layer.provide(Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers)),
+      Layer.provide(
+        Layer.succeed(
+          ProviderEventLoggers.ProviderEventLoggers,
+          ProviderEventLoggers.NoOpProviderEventLoggers,
+        ),
+      ),
     );
-    yield* ProviderService.pipe(Effect.provide(providerLayer));
+    yield* ProviderService.ProviderService.pipe(Effect.provide(providerLayer));
     const persistedProvider = yield* Effect.gen(function* () {
-      const directory = yield* ProviderSessionDirectory;
+      const directory = yield* ProviderSessionDirectory.ProviderSessionDirectory;
       return yield* directory.getProvider(asThreadId("thread-stale"));
     }).pipe(Effect.provide(directoryLayer));
     assert.equal(persistedProvider, "codex");
 @@ -683,11 +730,18 @@ it.effect(
         Layer.provide(runtimeRepositoryLayer),
       );
       const firstProviderLayer = makeProviderServiceLive().pipe(
-        Layer.provide(Layer.succeed(ProviderAdapterRegistry, firstRegistry)),
+        Layer.provide(
+          Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, firstRegistry),
+        ),
         Layer.provide(firstDirectoryLayer),
         Layer.provide(defaultServerSettingsLayer),
         Layer.provide(AnalyticsService.layerTest),
-        Layer.provide(Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers)),
+        Layer.provide(
+          Layer.succeed(
+            ProviderEventLoggers.ProviderEventLoggers,
+            ProviderEventLoggers.NoOpProviderEventLoggers,
+          ),
+        ),
       );
       const updatedResumeCursor = {
         threadId: asThreadId("thread-1"),
 @@ -697,7 +751,7 @@ it.effect(
       };
       const startedSession = yield* Effect.gen(function* () {
-        const provider = yield* ProviderService;
+        const provider = yield* ProviderService.ProviderService;
         const threadId = asThreadId("thread-1");
         const session = yield* provider.startSession(threadId, {
           provider: ProviderDriverKind.make("codex"),
 @@ -735,18 +789,25 @@ it.effect(
         Layer.provide(runtimeRepositoryLayer),
       );
       const secondProviderLayer = makeProviderServiceLive().pipe(
-        Layer.provide(Layer.succeed(ProviderAdapterRegistry, secondRegistry)),
+        Layer.provide(
+          Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, secondRegistry),
+        ),
         Layer.provide(secondDirectoryLayer),
         Layer.provide(defaultServerSettingsLayer),
         Layer.provide(AnalyticsService.layerTest),
-        Layer.provide(Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers)),
+        Layer.provide(
+          Layer.succeed(
+            ProviderEventLoggers.ProviderEventLoggers,
+            ProviderEventLoggers.NoOpProviderEventLoggers,
+          ),
+        ),
       );
       secondCodex.startSession.mockClear();
       secondCodex.rollbackThread.mockClear();
       yield* Effect.gen(function* () {
-        const provider = yield* ProviderService;
+        const provider = yield* ProviderService.ProviderService;
         yield* provider.rollbackConversation({
           threadId: startedSession.threadId,
           numTurns: 1,
 @@ -780,7 +841,7 @@ it.effect(
 routing.layer("ProviderServiceLive routing", (it) => {
   it.effect("routes provider operations and rollback conversation", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       const session = yield* provider.startSession(asThreadId("thread-1"), {
         provider: ProviderDriverKind.make("codex"),
 @@ -866,7 +927,7 @@ routing.layer("ProviderServiceLive routing", (it) => {
   it.effect("recovers stale persisted sessions for rollback by resuming thread identity", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       const initial = yield* provider.startSession(asThreadId("thread-1"), {
         provider: ProviderDriverKind.make("codex"),
 @@ -907,7 +968,7 @@ routing.layer("ProviderServiceLive routing", (it) => {
   it.effect("preserves the persisted binding when stopping a session", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       const runtimeRepository = yield* ProviderSessionRuntime.ProviderSessionRuntimeRepository;
       const initial = yield* provider.startSession(asThreadId("thread-reap-preserve"), {
 @@ -959,7 +1020,7 @@ routing.layer("ProviderServiceLive routing", (it) => {
   it.effect("routes explicit claudeAgent provider session starts to the claude adapter", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       const session = yield* provider.startSession(asThreadId("thread-claude"), {
         provider: ProviderDriverKind.make("claudeAgent"),
 @@ -988,8 +1049,8 @@ routing.layer("ProviderServiceLive routing", (it) => {
   it.effect("dies when an active session conflicts with its persisted binding", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
-      const directory = yield* ProviderSessionDirectory;
+      const directory = yield* ProviderSessionDirectory.ProviderSessionDirectory;
       const threadId = asThreadId("thread-binding-mismatch");
       yield* provider.startSession(threadId, {
 @@ -1019,7 +1080,7 @@ routing.layer("ProviderServiceLive routing", (it) => {
   it.effect("stops stale sessions in other providers after a successful replacement start", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       const threadId = asThreadId("thread-provider-replacement");
       const codexSession = yield* provider.startSession(threadId, {
 @@ -1058,7 +1119,7 @@ routing.layer("ProviderServiceLive routing", (it) => {
   it.effect("recovers stale sessions for sendTurn using persisted cwd", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       const initial = yield* provider.startSession(asThreadId("thread-1"), {
         provider: ProviderDriverKind.make("codex"),
 @@ -1099,7 +1160,7 @@ routing.layer("ProviderServiceLive routing", (it) => {
   it.effect("recovers stale claudeAgent sessions for sendTurn using persisted cwd", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       const initial = yield* provider.startSession(asThreadId("thread-claude-send-turn"), {
         provider: ProviderDriverKind.make("claudeAgent"),
 @@ -1152,7 +1213,7 @@ routing.layer("ProviderServiceLive routing", (it) => {
   it.effect("lists no sessions after adapter runtime clears", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       yield* provider.startSession(asThreadId("thread-1"), {
         provider: ProviderDriverKind.make("codex"),
 @@ -1177,7 +1238,7 @@ routing.layer("ProviderServiceLive routing", (it) => {
   it.effect("persists runtime status transitions in provider_session_runtime", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       const runtimeRepository = yield* ProviderSessionRuntime.ProviderSessionRuntimeRepository;
       const threadId = asThreadId("thread-runtime-status");
 @@ -1237,15 +1298,22 @@ routing.layer("ProviderServiceLive routing", (it) => {
         Layer.provide(runtimeRepositoryLayer),
       );
       const firstProviderLayer = makeProviderServiceLive().pipe(
-        Layer.provide(Layer.succeed(ProviderAdapterRegistry, firstRegistry)),
+        Layer.provide(
+          Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, firstRegistry),
+        ),
         Layer.provide(firstDirectoryLayer),
         Layer.provide(defaultServerSettingsLayer),
         Layer.provide(AnalyticsService.layerTest),
-        Layer.provide(Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers)),
+        Layer.provide(
+          Layer.succeed(
+            ProviderEventLoggers.ProviderEventLoggers,
+            ProviderEventLoggers.NoOpProviderEventLoggers,
+          ),
+        ),
       );
       const initial = yield* Effect.gen(function* () {
-        const provider = yield* ProviderService;
+        const provider = yield* ProviderService.ProviderService;
         return yield* provider.startSession(asThreadId("thread-claude-start"), {
           provider: ProviderDriverKind.make("claudeAgent"),
           providerInstanceId: claudeAgentInstanceId,
 @@ -1256,7 +1324,7 @@ routing.layer("ProviderServiceLive routing", (it) => {
       }).pipe(Effect.provide(firstProviderLayer));
       yield* Effect.gen(function* () {
-        const provider = yield* ProviderService;
+        const provider = yield* ProviderService.ProviderService;
         yield* provider.listSessions();
       }).pipe(Effect.provide(firstProviderLayer));
 @@ -1268,17 +1336,24 @@ routing.layer("ProviderServiceLive routing", (it) => {
         Layer.provide(runtimeRepositoryLayer),
       );
       const secondProviderLayer = makeProviderServiceLive().pipe(
-        Layer.provide(Layer.succeed(ProviderAdapterRegistry, secondRegistry)),
+        Layer.provide(
+          Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, secondRegistry),
+        ),
         Layer.provide(secondDirectoryLayer),
         Layer.provide(defaultServerSettingsLayer),
         Layer.provide(AnalyticsService.layerTest),
-        Layer.provide(Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers)),
+        Layer.provide(
+          Layer.succeed(
+            ProviderEventLoggers.ProviderEventLoggers,
+            ProviderEventLoggers.NoOpProviderEventLoggers,
+          ),
+        ),
       );
       secondClaude.startSession.mockClear();
       yield* Effect.gen(function* () {
-        const provider = yield* ProviderService;
+        const provider = yield* ProviderService.ProviderService;
         yield* provider.startSession(initial.threadId, {
           provider: ProviderDriverKind.make("claudeAgent"),
           providerInstanceId: claudeAgentInstanceId,
 @@ -1327,15 +1402,22 @@ routing.layer("ProviderServiceLive routing", (it) => {
           Layer.provide(runtimeRepositoryLayer),
         );
         const firstProviderLayer = makeProviderServiceLive().pipe(
-          Layer.provide(Layer.succeed(ProviderAdapterRegistry, firstRegistry)),
+          Layer.provide(
+            Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, firstRegistry),
+          ),
           Layer.provide(firstDirectoryLayer),
           Layer.provide(defaultServerSettingsLayer),
           Layer.provide(AnalyticsService.layerTest),
-          Layer.provide(Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers)),
+          Layer.provide(
+            Layer.succeed(
+              ProviderEventLoggers.ProviderEventLoggers,
+              ProviderEventLoggers.NoOpProviderEventLoggers,
+            ),
+          ),
         );
         const initial = yield* Effect.gen(function* () {
-          const provider = yield* ProviderService;
+          const provider = yield* ProviderService.ProviderService;
           return yield* provider.startSession(asThreadId("thread-claude-cwd"), {
             provider: ProviderDriverKind.make("claudeAgent"),
             providerInstanceId: claudeAgentInstanceId,
 @@ -1353,17 +1435,24 @@ routing.layer("ProviderServiceLive routing", (it) => {
           Layer.provide(runtimeRepositoryLayer),
         );
         const secondProviderLayer = makeProviderServiceLive().pipe(
-          Layer.provide(Layer.succeed(ProviderAdapterRegistry, secondRegistry)),
+          Layer.provide(
+            Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, secondRegistry),
+          ),
           Layer.provide(secondDirectoryLayer),
           Layer.provide(defaultServerSettingsLayer),
           Layer.provide(AnalyticsService.layerTest),
-          Layer.provide(Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers)),
+          Layer.provide(
+            Layer.succeed(
+              ProviderEventLoggers.ProviderEventLoggers,
+              ProviderEventLoggers.NoOpProviderEventLoggers,
+            ),
+          ),
         );
         secondClaude.startSession.mockClear();
         yield* Effect.gen(function* () {
-          const provider = yield* ProviderService;
+          const provider = yield* ProviderService.ProviderService;
           yield* provider.startSession(initial.threadId, {
             provider: ProviderDriverKind.make("claudeAgent"),
             providerInstanceId: claudeAgentInstanceId,
 @@ -1397,7 +1486,7 @@ const fanout = makeProviderServiceLayer();
 fanout.layer("ProviderServiceLive fanout", (it) => {
   it.effect("fans out adapter turn completion events", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       const session = yield* provider.startSession(asThreadId("thread-1"), {
         provider: ProviderDriverKind.make("codex"),
         providerInstanceId: codexInstanceId,
 @@ -1443,7 +1532,7 @@ fanout.layer("ProviderServiceLive fanout", (it) => {
   it.effect("fans out canonical runtime events in emission order", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       const session = yield* provider.startSession(asThreadId("thread-seq"), {
         provider: ProviderDriverKind.make("codex"),
         providerInstanceId: codexInstanceId,
 @@ -1499,7 +1588,7 @@ fanout.layer("ProviderServiceLive fanout", (it) => {
   it.effect("keeps subscriber delivery ordered and isolates failing subscribers", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       const session = yield* provider.startSession(asThreadId("thread-1"), {
         provider: ProviderDriverKind.make("codex"),
         providerInstanceId: codexInstanceId,
 @@ -1571,7 +1660,7 @@ fanout.layer("ProviderServiceLive fanout", (it) => {
   it.effect("records provider metrics with the routed provider label", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       const session = yield* provider.startSession(asThreadId("thread-metrics"), {
         provider: ProviderDriverKind.make("claudeAgent"),
 @@ -1649,7 +1738,7 @@ fanout.layer("ProviderServiceLive fanout", (it) => {
     "records sendTurn metrics with the resolved provider when modelSelection is omitted",
     () =>
       Effect.gen(function* () {
-        const provider = yield* ProviderService;
+        const provider = yield* ProviderService.ProviderService;
         const session = yield* provider.startSession(asThreadId("thread-send-metrics"), {
           provider: ProviderDriverKind.make("claudeAgent"),
 @@ -1690,7 +1779,7 @@ const validation = makeProviderServiceLayer();
 validation.layer("ProviderServiceLive validation", (it) => {
   it.effect("rejects session starts without an explicit provider instance id", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       validation.codex.startSession.mockClear();
       const failure = yield* Effect.flip(
 @@ -1709,7 +1798,7 @@ validation.layer("ProviderServiceLive validation", (it) => {
   it.effect("rejects mismatched provider kind and provider instance id", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       validation.codex.startSession.mockClear();
       validation.claude.startSession.mockClear();
 @@ -1734,7 +1823,7 @@ validation.layer("ProviderServiceLive validation", (it) => {
   it.effect("returns ProviderValidationError for invalid input payloads", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       const failure = yield* Effect.result(
         provider.startSession(asThreadId("thread-validation"), {
 @@ -1759,7 +1848,7 @@ validation.layer("ProviderServiceLive validation", (it) => {
   it.effect("accepts startSession when adapter has not emitted provider thread id yet", () =>
     Effect.gen(function* () {
-      const provider = yield* ProviderService;
+      const provider = yield* ProviderService.ProviderService;
       const runtimeRepository = yield* ProviderSessionRuntime.ProviderSessionRuntimeRepository;
       validation.codex.startSession.mockImplementationOnce((input: ProviderSessionStartInput) =>

apps/server/src/provider/Layers/ProviderService.ts+44-32

 @@ -47,15 +47,12 @@ import {
 } from "../../observability/Metrics.ts";
 import { type ProviderAdapterError, ProviderValidationError } from "../Errors.ts";
 import type { ProviderAdapterShape } from "../Services/ProviderAdapter.ts";
-import { ProviderAdapterRegistry } from "../Services/ProviderAdapterRegistry.ts";
+import * as ProviderAdapterRegistry from "../Services/ProviderAdapterRegistry.ts";
-import { ProviderService, type ProviderServiceShape } from "../Services/ProviderService.ts";
+import * as ProviderService from "../Services/ProviderService.ts";
-import {
+import * as ProviderSessionDirectory from "../Services/ProviderSessionDirectory.ts";
-  ProviderSessionDirectory,
-  type ProviderRuntimeBinding,
-} from "../Services/ProviderSessionDirectory.ts";
 import { type EventNdjsonLogger } from "./EventNdjsonLogger.ts";
-import { ProviderEventLoggers } from "./ProviderEventLoggers.ts";
+import * as ProviderEventLoggers from "./ProviderEventLoggers.ts";
-import { AnalyticsService } from "../../telemetry/Services/AnalyticsService.ts";
+import * as AnalyticsService from "../../telemetry/AnalyticsService.ts";
 import * as McpProviderSession from "../../mcp/McpProviderSession.ts";
 import * as McpSessionRegistry from "../../mcp/McpSessionRegistry.ts";
 const isModelSelection = Schema.is(ModelSelection);
 @@ -69,6 +66,9 @@ export interface ProviderServiceLiveOptions {
   readonly canonicalEventLogger?: EventNdjsonLogger;
 }
+type ProviderServiceMethod<Name extends keyof ProviderService.ProviderService["Service"]> =
+  ProviderService.ProviderService["Service"][Name];
 const ProviderRollbackConversationInput = Schema.Struct({
   threadId: ThreadId,
   numTurns: NonNegativeInt,
 @@ -141,7 +141,7 @@ function toRuntimePayloadFromSession(
 }
 function readPersistedModelSelection(
-  runtimePayload: ProviderRuntimeBinding["runtimePayload"],
+  runtimePayload: ProviderSessionDirectory.ProviderRuntimeBinding["runtimePayload"],
 ): ModelSelection | undefined {
   if (!runtimePayload || typeof runtimePayload !== "object" || Array.isArray(runtimePayload)) {
     return undefined;
 @@ -151,7 +151,7 @@ function readPersistedModelSelection(
 }
 function readPersistedCwd(
-  runtimePayload: ProviderRuntimeBinding["runtimePayload"],
+  runtimePayload: ProviderSessionDirectory.ProviderRuntimeBinding["runtimePayload"],
 ): string | undefined {
   if (!runtimePayload || typeof runtimePayload !== "object" || Array.isArray(runtimePayload)) {
     return undefined;
 @@ -202,16 +202,16 @@ const correlateRuntimeEventWithInstance = (
 const makeProviderService = Effect.fn("makeProviderService")(function* (
   options?: ProviderServiceLiveOptions,
 ) {
-  const analytics = yield* Effect.service(AnalyticsService);
+  const analytics = yield* Effect.service(AnalyticsService.AnalyticsService);
-  const eventLoggers = yield* ProviderEventLoggers;
+  const eventLoggers = yield* ProviderEventLoggers.ProviderEventLoggers;
   // Options-provided logger wins (test overrides); otherwise we take whatever
   // the `ProviderEventLoggers` tag exposes — `undefined` means "no canonical
   // log writer is attached", which downstream code already handles as a
   // no-op.
   const canonicalEventLogger = options?.canonicalEventLogger ?? eventLoggers.canonical;
-  const registry = yield* ProviderAdapterRegistry;
+  const registry = yield* ProviderAdapterRegistry.ProviderAdapterRegistry;
-  const directory = yield* ProviderSessionDirectory;
+  const directory = yield* ProviderSessionDirectory.ProviderSessionDirectory;
   const runtimeEventPubSub = yield* PubSub.unbounded<ProviderRuntimeEvent>();
   const nowIso = Effect.map(DateTime.now, DateTime.formatIso);
   const prepareMcpSession = (threadId: ThreadId, providerInstanceId: ProviderInstanceId) =>
 @@ -353,7 +353,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
   ).pipe(Effect.forkScoped);
   const recoverSessionForThread = Effect.fn("recoverSessionForThread")(function* (input: {
-    readonly binding: ProviderRuntimeBinding;
+    readonly binding: ProviderSessionDirectory.ProviderRuntimeBinding;
     readonly operation: string;
   }) {
     const bindingInstanceId = yield* requireBindingInstanceId(input.operation, input.binding);
 @@ -519,7 +519,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
     );
   });
-  const startSession: ProviderServiceShape["startSession"] = Effect.fn("startSession")(
+  const startSession: ProviderServiceMethod<"startSession"> = Effect.fn("startSession")(
     function* (threadId, rawInput) {
       const parsed = yield* decodeInputOrValidationError({
         operation: "ProviderService.startSession",
 @@ -642,7 +642,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
     },
   );
-  const sendTurn: ProviderServiceShape["sendTurn"] = Effect.fn("sendTurn")(function* (rawInput) {
+  const sendTurn: ProviderServiceMethod<"sendTurn"> = Effect.fn("sendTurn")(function* (rawInput) {
     const parsed = yield* decodeInputOrValidationError({
       operation: "ProviderService.sendTurn",
       schema: ProviderSendTurnInput,
 @@ -717,7 +717,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
     );
   });
-  const interruptTurn: ProviderServiceShape["interruptTurn"] = Effect.fn("interruptTurn")(
+  const interruptTurn: ProviderServiceMethod<"interruptTurn"> = Effect.fn("interruptTurn")(
     function* (rawInput) {
       const input = yield* decodeInputOrValidationError({
         operation: "ProviderService.interruptTurn",
 @@ -754,7 +754,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
     },
   );
-  const respondToRequest: ProviderServiceShape["respondToRequest"] = Effect.fn("respondToRequest")(
+  const respondToRequest: ProviderServiceMethod<"respondToRequest"> = Effect.fn("respondToRequest")(
     function* (rawInput) {
       const input = yield* decodeInputOrValidationError({
         operation: "ProviderService.respondToRequest",
 @@ -792,7 +792,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
     },
   );
-  const respondToUserInput: ProviderServiceShape["respondToUserInput"] = Effect.fn(
+  const respondToUserInput: ProviderServiceMethod<"respondToUserInput"> = Effect.fn(
     "respondToUserInput",
   )(function* (rawInput) {
     const input = yield* decodeInputOrValidationError({
 @@ -826,7 +826,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
     );
   });
-  const stopSession: ProviderServiceShape["stopSession"] = Effect.fn("stopSession")(
+  const stopSession: ProviderServiceMethod<"stopSession"> = Effect.fn("stopSession")(
     function* (rawInput) {
       const input = yield* decodeInputOrValidationError({
         operation: "ProviderService.stopSession",
 @@ -874,7 +874,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
     },
   );
-  const listSessions: ProviderServiceShape["listSessions"] = Effect.fn("listSessions")(
+  const listSessions: ProviderServiceMethod<"listSessions"> = Effect.fn("listSessions")(
     function* () {
       const currentAdapters = yield* getAdapterEntries;
       const sessionsByProvider = yield* Effect.forEach(currentAdapters, ([instanceId, adapter]) =>
 @@ -895,13 +895,22 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
             (threadId) =>
               directory
                 .getBinding(threadId)
-                .pipe(Effect.orElseSucceed(() => Option.none<ProviderRuntimeBinding>())),
+                .pipe(
+                  Effect.orElseSucceed(() =>
+                    Option.none<ProviderSessionDirectory.ProviderRuntimeBinding>(),
+                  ),
+                ),
             { concurrency: "unbounded" },
           ),
         ),
-        Effect.orElseSucceed(() => [] as Array<Option.Option<ProviderRuntimeBinding>>),
+        Effect.orElseSucceed(
+          () => [] as Array<Option.Option<ProviderSessionDirectory.ProviderRuntimeBinding>>,
+        ),
       );
-      const bindingsByThreadId = new Map<ThreadId, ProviderRuntimeBinding>();
+      const bindingsByThreadId = new Map<
+        ThreadId,
+        ProviderSessionDirectory.ProviderRuntimeBinding
+      >();
       for (const bindingOption of persistedBindings) {
         const binding = Option.getOrUndefined(bindingOption);
         if (binding) {
 @@ -952,13 +961,13 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
     },
   );
-  const getCapabilities: ProviderServiceShape["getCapabilities"] = (instanceId) =>
+  const getCapabilities: ProviderServiceMethod<"getCapabilities"> = (instanceId) =>
     registry.getByInstance(instanceId).pipe(Effect.map((adapter) => adapter.capabilities));
-  const getInstanceInfo: ProviderServiceShape["getInstanceInfo"] = (instanceId) =>
+  const getInstanceInfo: ProviderServiceMethod<"getInstanceInfo"> = (instanceId) =>
     registry.getInstanceInfo(instanceId);
-  const rollbackConversation: ProviderServiceShape["rollbackConversation"] = Effect.fn(
+  const rollbackConversation: ProviderServiceMethod<"rollbackConversation"> = Effect.fn(
     "rollbackConversation",
   )(function* (rawInput) {
     const input = yield* decodeInputOrValidationError({
 @@ -1071,14 +1080,17 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (
     // Each access creates a fresh PubSub subscription so that multiple
     // consumers (ProviderRuntimeIngestion, CheckpointReactor, etc.) each
     // independently receive all runtime events.
-    get streamEvents(): ProviderServiceShape["streamEvents"] {
+    get streamEvents(): ProviderServiceMethod<"streamEvents"> {
       return Stream.fromPubSub(runtimeEventPubSub);
     },
-  } satisfies ProviderServiceShape;
+  } satisfies ProviderService.ProviderService["Service"];
 });
-export const ProviderServiceLive = Layer.effect(ProviderService, makeProviderService());
+export const ProviderServiceLive = Layer.effect(
+  ProviderService.ProviderService,
+  makeProviderService(),
+);
 export function makeProviderServiceLive(options?: ProviderServiceLiveOptions) {
-  return Layer.effect(ProviderService, makeProviderService(options));
+  return Layer.effect(ProviderService.ProviderService, makeProviderService(options));
 }

apps/server/src/server.test.ts+1-1

...	@@ -88,7 +88,7 @@ import * as ServerSettings from "./serverSettings.ts";	...	@@ -88,7 +88,7 @@ import * as ServerSettings from "./serverSettings.ts";
88	import * as TerminalManager from "./terminal/Services/Manager.ts";	88	import * as TerminalManager from "./terminal/Services/Manager.ts";
89	import * as PreviewManager from "./preview/Manager.ts";	89	import * as PreviewManager from "./preview/Manager.ts";
90	import * as PortScanner from "./preview/PortScanner.ts";	90	import * as PortScanner from "./preview/PortScanner.ts";
91	import * as BrowserTraceCollector from "./observability/Services/BrowserTraceCollector.ts";	91	import * as BrowserTraceCollector from "./observability/BrowserTraceCollector.ts";
92	import { ProjectFaviconResolverLive } from "./project/Layers/ProjectFaviconResolver.ts";	92	import { ProjectFaviconResolverLive } from "./project/Layers/ProjectFaviconResolver.ts";
93	import * as ProjectSetupScriptRunner from "./project/Services/ProjectSetupScriptRunner.ts";	93	import * as ProjectSetupScriptRunner from "./project/Services/ProjectSetupScriptRunner.ts";
94	import * as RepositoryIdentityResolver from "./project/Services/RepositoryIdentityResolver.ts";	94	import * as RepositoryIdentityResolver from "./project/Services/RepositoryIdentityResolver.ts";

apps/server/src/server.ts+2-2

apps/server/src/serverRuntimeStartup.test.ts+1-1

...	@@ -13,7 +13,7 @@ import * as Stream from "effect/Stream";	...	@@ -13,7 +13,7 @@ import * as Stream from "effect/Stream";
13	import * as ServerConfig from "./config.ts";	13	import * as ServerConfig from "./config.ts";
14	import * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngine.ts";	14	import * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngine.ts";
15	import * as ProjectionSnapshotQuery from "./orchestration/Services/ProjectionSnapshotQuery.ts";	15	import * as ProjectionSnapshotQuery from "./orchestration/Services/ProjectionSnapshotQuery.ts";
16	import * as AnalyticsService from "./telemetry/Services/AnalyticsService.ts";	16	import * as AnalyticsService from "./telemetry/AnalyticsService.ts";
17	import * as ServerRuntimeStartup from "./serverRuntimeStartup.ts";	17	import * as ServerRuntimeStartup from "./serverRuntimeStartup.ts";
18		18
19	it("uses the canonical Codex default for auto-bootstrapped model selection", () => {	19	it("uses the canonical Codex default for auto-bootstrapped model selection", () => {

apps/server/src/serverRuntimeStartup.ts+1-1

...	@@ -31,7 +31,7 @@ import * as OrchestrationReactor from "./orchestration/Services/OrchestrationRea	...	@@ -31,7 +31,7 @@ import * as OrchestrationReactor from "./orchestration/Services/OrchestrationRea
31	import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts";	31	import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts";
32	import * as ServerSettings from "./serverSettings.ts";	32	import * as ServerSettings from "./serverSettings.ts";
33	import * as ServerEnvironment from "./environment/Services/ServerEnvironment.ts";	33	import * as ServerEnvironment from "./environment/Services/ServerEnvironment.ts";
34	import * as AnalyticsService from "./telemetry/Services/AnalyticsService.ts";	34	import * as AnalyticsService from "./telemetry/AnalyticsService.ts";
35	import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts";	35	import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts";
36	import * as ProviderSessionReaper from "./provider/Services/ProviderSessionReaper.ts";	36	import * as ProviderSessionReaper from "./provider/Services/ProviderSessionReaper.ts";
37	import {	37	import {

apps/server/src/telemetry/AnalyticsService.test.ts created+120

...	@@ -0,0 +1,120 @@
1	import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
2	import * as NodeServices from "@effect/platform-node/NodeServices";
3	import { assert, it } from "@effect/vitest";
4	import * as ConfigProvider from "effect/ConfigProvider";
5	import * as Effect from "effect/Effect";
6	import * as Layer from "effect/Layer";
7	import * as HttpServer from "effect/unstable/http/HttpServer";
8	import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
9	import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
10
11	import * as ServerConfig from "../config.ts";
12	import { getTelemetryIdentifier } from "./Identify.ts";
13	import * as AnalyticsService from "./AnalyticsService.ts";
14
15	interface RecordedBatchRequest {
16	readonly path: string;
17	readonly body: {
18	readonly batch?: ReadonlyArray<{
19	readonly event?: string;
20	readonly properties?: {
21	readonly index?: number;
22	readonly clientType?: string;
23	};
24	}>;
25	} \| null;
26	}
27
28	interface RecordedBatchBody {
29	readonly batch: ReadonlyArray<{
30	readonly event?: string;
31	readonly properties?: {
32	readonly index?: number;
33	readonly clientType?: string;
34	};
35	}>;
36	}
37
38	it.layer(NodeServices.layer)("AnalyticsService test", (it) => {
39	it.effect("flush drains all buffered events across multiple batches", () =>
40	Effect.gen(function* () {
41	const capturedRequests: Array<RecordedBatchRequest> = [];
42	const serverConfigLayer = ServerConfig.ServerConfig.layerTest(process.cwd(), {
43	prefix: "t3-telemetry-base-",
44	});
45
46	const telemetryLayer = AnalyticsService.layer.pipe(Layer.provideMerge(serverConfigLayer));
47	const configLayer = ConfigProvider.layer(
48	ConfigProvider.fromUnknown({
49	T3CODE_TELEMETRY_ENABLED: true,
50	T3CODE_POSTHOG_KEY: "phc_test_key",
51	T3CODE_POSTHOG_HOST: "",
52	T3CODE_TELEMETRY_FLUSH_BATCH_SIZE: 20,
53	}),
54	);
55	const batchServerLayer = HttpServer.serve(
56	Effect.gen(function* () {
57	const request = yield* HttpServerRequest.HttpServerRequest;
58	if (request.method !== "POST") {
59	return HttpServerResponse.empty({ status: 404 });
60	}
61
62	const payload = yield* request.json.pipe(
63	Effect.map((body) => body as RecordedBatchRequest["body"]),
64	Effect.orElseSucceed(() => null),
65	);
66
67	capturedRequests.push({ path: request.url, body: payload });
68
69	return HttpServerResponse.jsonUnsafe({});
70	}),
71	);
72	const runtimeLayer = telemetryLayer.pipe(
73	Layer.provide(configLayer),
74	Layer.provideMerge(NodeHttpServer.layerTest),
75	);
76
77	yield* Effect.gen(function* () {
78	yield* Layer.launch(batchServerLayer).pipe(Effect.forkScoped);
79	const telemetryIdentifier = yield* getTelemetryIdentifier;
80	assert.equal(telemetryIdentifier !== null, true);
81	const analytics = yield* AnalyticsService.AnalyticsService;
82
83	for (let index = 0; index < 45; index += 1) {
84	yield* analytics.record("test.flush.drain", { index });
85	}
86
87	yield* analytics.flush;
88	}).pipe(Effect.provide(runtimeLayer));
89
90	const batchRequests = capturedRequests.filter(
91	(request): request is RecordedBatchRequest & { readonly body: RecordedBatchBody } =>
92	Array.isArray(request.body?.batch),
93	);
94	assert.equal(batchRequests.length, 3);
95	assert.equal(
96	batchRequests.every((request) => request.path === "/batch/" \|\| request.path === "/batch"),
97	true,
98	);
99	const deliveredIndexes = batchRequests.flatMap((request) =>
100	request.body.batch
101	.filter((event) => event.event === "test.flush.drain")
102	.map((event) => event.properties?.index)
103	.filter((index): index is number => typeof index === "number"),
104	);
105
106	const sorted = deliveredIndexes.toSorted((a, b) => a - b);
107	assert.equal(sorted.length, 45);
108	assert.deepEqual(
109	sorted,
110	Array.from({ length: 45 }, (_, index) => index),
111	);
112	assert.equal(
113	batchRequests.every((request) =>
114	request.body.batch.every((event) => event.properties?.clientType === "cli-web-client"),
115	),
116	true,
117	);
118	}),
119	);
120	});

apps/server/src/telemetry/AnalyticsService.ts created+186

...	@@ -0,0 +1,186 @@
1	/**
2	* Anonymous PostHog telemetry service.
3	*
4	* Persists an installation-scoped anonymous identifier, buffers events in
5	* memory, and flushes batches over Effect's HTTP client.
6	*
7	* @module AnalyticsService
8	*/
9	import { HostProcessArchitecture, HostProcessPlatform } from "@t3tools/shared/hostProcess";
10	import * as Config from "effect/Config";
11	import * as Context from "effect/Context";
12	import * as DateTime from "effect/DateTime";
13	import * as Effect from "effect/Effect";
14	import * as Layer from "effect/Layer";
15	import * as Option from "effect/Option";
16	import * as Ref from "effect/Ref";
17	import * as HttpClient from "effect/unstable/http/HttpClient";
18	import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
19	import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
20
21	import packageJson from "../../package.json" with { type: "json" };
22	import * as ServerConfig from "../config.ts";
23	import { getTelemetryIdentifier } from "./Identify.ts";
24
25	interface BufferedAnalyticsEvent {
26	readonly event: string;
27	readonly properties?: Readonly<Record<string, unknown>>;
28	readonly capturedAt: string;
29	}
30
31	const TelemetryEnvConfig = Config.all({
32	posthogKey: Config.string("T3CODE_POSTHOG_KEY").pipe(
33	Config.withDefault("phc_XOWci4oZP4VvLiEyrFqkFjP4CZn55mjYYBMREK5Wd6m"),
34	),
35	posthogHost: Config.string("T3CODE_POSTHOG_HOST").pipe(
36	Config.withDefault("https://us.i.posthog.com"),
37	),
38	enabled: Config.boolean("T3CODE_TELEMETRY_ENABLED").pipe(Config.withDefault(true)),
39	flushBatchSize: Config.number("T3CODE_TELEMETRY_FLUSH_BATCH_SIZE").pipe(Config.withDefault(20)),
40	maxBufferedEvents: Config.number("T3CODE_TELEMETRY_MAX_BUFFERED_EVENTS").pipe(
41	Config.withDefault(1_000),
42	),
43	wslDistroName: Config.string("WSL_DISTRO_NAME").pipe(Config.option),
44	});
45
46	export class AnalyticsService extends Context.Service<
47	AnalyticsService,
48	{
49	/** Record an anonymous event for best-effort buffered delivery. */
50	readonly record: (
51	event: string,
52	properties?: Readonly<Record<string, unknown>>,
53	) => Effect.Effect<void>;
54
55	/** Flush all currently queued telemetry events. */
56	readonly flush: Effect.Effect<void>;
57	}
58	>()("t3/telemetry/AnalyticsService") {
59	/** No-op layer for callers that intentionally disable telemetry. */
60	static readonly layerTest = Layer.succeed(
61	AnalyticsService,
62	AnalyticsService.of({
63	record: () => Effect.void,
64	flush: Effect.void,
65	}),
66	);
67	}
68
69	export const make = Effect.gen(function* () {
70	const telemetryConfig = yield* TelemetryEnvConfig;
71	const httpClient = yield* HttpClient.HttpClient;
72	const serverConfig = yield* ServerConfig.ServerConfig;
73	const identifier = yield* getTelemetryIdentifier;
74	const bufferRef = yield* Ref.make<ReadonlyArray<BufferedAnalyticsEvent>>([]);
75	const clientType = serverConfig.mode === "desktop" ? "desktop-app" : "cli-web-client";
76	const hostPlatform = yield* HostProcessPlatform;
77	const hostArchitecture = yield* HostProcessArchitecture;
78
79	const enqueueBufferedEvent = (event: string, properties?: Readonly<Record<string, unknown>>) =>
80	Effect.flatMap(DateTime.now, (now) =>
81	Ref.modify(bufferRef, (current) => {
82	const appended = [
83	...current,
84	{
85	event,
86	...(properties ? { properties } : {}),
87	capturedAt: DateTime.formatIso(now),
88	} satisfies BufferedAnalyticsEvent,
89	];
90
91	const next =
92	appended.length > telemetryConfig.maxBufferedEvents
93	? appended.slice(appended.length - telemetryConfig.maxBufferedEvents)
94	: appended;
95
96	return [
97	{
98	size: next.length,
99	dropped: next.length !== appended.length,
100	} as const,
101	next,
102	] as const;
103	}),
104	);
105
106	const sendBatch = Effect.fn("AnalyticsService.sendBatch")(function* (
107	events: ReadonlyArray<BufferedAnalyticsEvent>,
108	) {
109	if (!telemetryConfig.enabled \|\| !identifier) return;
110
111	const payload = {
112	api_key: telemetryConfig.posthogKey,
113	batch: events.map((event) => ({
114	event: event.event,
115	distinct_id: identifier,
116	properties: {
117	...event.properties,
118	$process_person_profile: false,
119	platform: hostPlatform,
120	wsl: Option.getOrUndefined(telemetryConfig.wslDistroName),
121	arch: hostArchitecture,
122	t3CodeVersion: packageJson.version,
123	clientType,
124	},
125	timestamp: event.capturedAt,
126	})),
127	};
128
129	yield* HttpClientRequest.post(`${telemetryConfig.posthogHost}/batch/`).pipe(
130	HttpClientRequest.bodyJson(payload),
131	Effect.flatMap(httpClient.execute),
132	Effect.flatMap(HttpClientResponse.filterStatusOk),
133	);
134	});
135
136	const flush: AnalyticsService["Service"]["flush"] = Effect.gen(function* () {
137	while (true) {
138	const batch = yield* Ref.modify(bufferRef, (current) => {
139	if (current.length === 0) {
140	return [[] as ReadonlyArray<BufferedAnalyticsEvent>, current] as const;
141	}
142	const nextBatch = current.slice(0, telemetryConfig.flushBatchSize);
143	const remaining = current.slice(nextBatch.length);
144	return [nextBatch, remaining] as const;
145	});
146
147	if (batch.length === 0) {
148	return;
149	}
150
151	yield* sendBatch(batch).pipe(
152	Effect.catch((error) =>
153	Ref.update(bufferRef, (current) => [...batch, ...current]).pipe(
154	Effect.flatMap(() => Effect.fail(error)),
155	),
156	),
157	);
158	}
159	}).pipe(Effect.catch((cause) => Effect.logError("Failed to flush telemetry", { cause })));
160
161	const record: AnalyticsService["Service"]["record"] = Effect.fn("AnalyticsService.record")(
162	function* (event, properties) {
163	if (!telemetryConfig.enabled \|\| !identifier) return;
164
165	const enqueueResult = yield* enqueueBufferedEvent(event, properties);
166	if (enqueueResult.dropped) {
167	yield* Effect.logDebug("analytics buffer full; dropping oldest event", {
168	size: enqueueResult.size,
169	event,
170	});
171	}
172	},
173	);
174
175	yield* Effect.forever(Effect.sleep(1000).pipe(Effect.flatMap(() => flush)), {
176	disableYield: true,
177	}).pipe(Effect.forkScoped);
178
179	yield* Effect.addFinalizer(() => flush);
180
181	return AnalyticsService.of({ record, flush });
182	});
183
184	export const layer = Layer.effect(AnalyticsService, make);
185
186	export const layerTest = AnalyticsService.layerTest;

apps/server/src/telemetry/Identify.ts+12-6

 @@ -6,7 +6,7 @@ import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 import * as Schema from "effect/Schema";
-import { ServerConfig } from "../config.ts";
+import * as ServerConfig from "../config.ts";
 const CodexAuthJsonSchema = Schema.Struct({
   tokens: Schema.Struct({
 @@ -19,9 +19,14 @@ const ClaudeJsonSchema = Schema.Struct({
 });
 class IdentifyUserError extends Schema.TaggedErrorClass<IdentifyUserError>()("IdentifyUserError", {
-  message: Schema.String,
+  operation: Schema.Literal("hash_identifier"),
-  cause: Schema.optional(Schema.Defect()),
+  algorithm: Schema.Literal("SHA-256"),
-}) {}
+  cause: Schema.Defect(),
+}) {
+  override get message(): string {
+    return `Failed to hash telemetry identifier with ${this.algorithm}.`;
+  }
+}
 const hash = (value: string) =>
   Crypto.Crypto.pipe(
 @@ -30,7 +35,8 @@ const hash = (value: string) =>
     Effect.mapError(
       (cause) =>
         new IdentifyUserError({
-          message: "Failed to hash identifier",
+          operation: "hash_identifier",
+          algorithm: "SHA-256",
           cause,
         }),
     ),
 @@ -64,7 +70,7 @@ const getClaudeUserId = Effect.gen(function* () {
 const upsertAnonymousId = Effect.gen(function* () {
   const fileSystem = yield* FileSystem.FileSystem;
-  const { anonymousIdPath } = yield* ServerConfig;
+  const { anonymousIdPath } = yield* ServerConfig.ServerConfig;
   const anonymousId = yield* fileSystem.readFileString(anonymousIdPath).pipe(
     Effect.catch(() =>

apps/server/src/telemetry/Layers/AnalyticsService.test.ts deleted-121

...	@@ -1,121 +0,0 @@
1	import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
2	import * as NodeServices from "@effect/platform-node/NodeServices";
3	import { assert, it } from "@effect/vitest";
4	import * as ConfigProvider from "effect/ConfigProvider";
5	import * as Effect from "effect/Effect";
6	import * as Layer from "effect/Layer";
7	import * as HttpServer from "effect/unstable/http/HttpServer";
8	import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
9	import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
10
11	import { ServerConfig } from "../../config.ts";
12	import { getTelemetryIdentifier } from "../Identify.ts";
13	import { AnalyticsService } from "../Services/AnalyticsService.ts";
14	import { AnalyticsServiceLayerLive } from "./AnalyticsService.ts";
15
16	interface RecordedBatchRequest {
17	readonly path: string;
18	readonly body: {
19	readonly batch?: ReadonlyArray<{
20	readonly event?: string;
21	readonly properties?: {
22	readonly index?: number;
23	readonly clientType?: string;
24	};
25	}>;
26	} \| null;
27	}
28
29	interface RecordedBatchBody {
30	readonly batch: ReadonlyArray<{
31	readonly event?: string;
32	readonly properties?: {
33	readonly index?: number;
34	readonly clientType?: string;
35	};
36	}>;
37	}
38
39	it.layer(NodeServices.layer)("AnalyticsService test", (it) => {
40	it.effect("flush drains all buffered events across multiple batches", () =>
41	Effect.gen(function* () {
42	const capturedRequests: Array<RecordedBatchRequest> = [];
43	const serverConfigLayer = ServerConfig.layerTest(process.cwd(), {
44	prefix: "t3-telemetry-base-",
45	});
46
47	const telemetryLayer = AnalyticsServiceLayerLive.pipe(Layer.provideMerge(serverConfigLayer));
48	const configLayer = ConfigProvider.layer(
49	ConfigProvider.fromUnknown({
50	T3CODE_TELEMETRY_ENABLED: true,
51	T3CODE_POSTHOG_KEY: "phc_test_key",
52	T3CODE_POSTHOG_HOST: "",
53	T3CODE_TELEMETRY_FLUSH_BATCH_SIZE: 20,
54	}),
55	);
56	const batchServerLayer = HttpServer.serve(
57	Effect.gen(function* () {
58	const request = yield* HttpServerRequest.HttpServerRequest;
59	if (request.method !== "POST") {
60	return HttpServerResponse.empty({ status: 404 });
61	}
62
63	const payload = yield* request.json.pipe(
64	Effect.map((body) => body as RecordedBatchRequest["body"]),
65	Effect.orElseSucceed(() => null),
66	);
67
68	capturedRequests.push({ path: request.url, body: payload });
69
70	return HttpServerResponse.jsonUnsafe({});
71	}),
72	);
73	const runtimeLayer = telemetryLayer.pipe(
74	Layer.provide(configLayer),
75	Layer.provideMerge(NodeHttpServer.layerTest),
76	);
77
78	yield* Effect.gen(function* () {
79	yield* Layer.launch(batchServerLayer).pipe(Effect.forkScoped);
80	const telemetryIdentifier = yield* getTelemetryIdentifier;
81	assert.equal(telemetryIdentifier !== null, true);
82	const analytics = yield* AnalyticsService;
83
84	for (let index = 0; index < 45; index += 1) {
85	yield* analytics.record("test.flush.drain", { index });
86	}
87
88	yield* analytics.flush;
89	}).pipe(Effect.provide(runtimeLayer));
90
91	const batchRequests = capturedRequests.filter(
92	(request): request is RecordedBatchRequest & { readonly body: RecordedBatchBody } =>
93	Array.isArray(request.body?.batch),
94	);
95	assert.equal(batchRequests.length, 3);
96	assert.equal(
97	batchRequests.every((request) => request.path === "/batch/" \|\| request.path === "/batch"),
98	true,
99	);
100	const deliveredIndexes = batchRequests.flatMap((request) =>
101	request.body.batch
102	.filter((event) => event.event === "test.flush.drain")
103	.map((event) => event.properties?.index)
104	.filter((index): index is number => typeof index === "number"),
105	);
106
107	const sorted = deliveredIndexes.toSorted((a, b) => a - b);
108	assert.equal(sorted.length, 45);
109	assert.deepEqual(
110	sorted,
111	Array.from({ length: 45 }, (_, index) => index),
112	);
113	assert.equal(
114	batchRequests.every((request) =>
115	request.body.batch.every((event) => event.properties?.clientType === "cli-web-client"),
116	),
117	true,
118	);
119	}),
120	);
121	});

apps/server/src/telemetry/Layers/AnalyticsService.ts deleted-163

...	@@ -1,163 +0,0 @@
1	/**
2	* AnalyticsServiceLive - Anonymous PostHog telemetry layer.
3	*
4	* Persists a random installation-scoped anonymous id to state dir, buffers
5	* events in memory, and flushes batches to PostHog over Effect HttpClient.
6	*
7	* @module AnalyticsServiceLive
8	*/
9
10	import { HostProcessArchitecture, HostProcessPlatform } from "@t3tools/shared/hostProcess";
11	import * as Config from "effect/Config";
12	import * as DateTime from "effect/DateTime";
13	import * as Effect from "effect/Effect";
14	import * as Layer from "effect/Layer";
15	import * as Option from "effect/Option";
16	import * as Ref from "effect/Ref";
17	import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
18
19	import { ServerConfig } from "../../config.ts";
20	import { AnalyticsService, type AnalyticsServiceShape } from "../Services/AnalyticsService.ts";
21	import { getTelemetryIdentifier } from "../Identify.ts";
22	import packageJson from "../../../package.json" with { type: "json" };
23
24	interface BufferedAnalyticsEvent {
25	readonly event: string;
26	readonly properties?: Readonly<Record<string, unknown>>;
27	readonly capturedAt: string;
28	}
29
30	const TelemetryEnvConfig = Config.all({
31	posthogKey: Config.string("T3CODE_POSTHOG_KEY").pipe(
32	Config.withDefault("phc_XOWci4oZP4VvLiEyrFqkFjP4CZn55mjYYBMREK5Wd6m"),
33	),
34	posthogHost: Config.string("T3CODE_POSTHOG_HOST").pipe(
35	Config.withDefault("https://us.i.posthog.com"),
36	),
37	enabled: Config.boolean("T3CODE_TELEMETRY_ENABLED").pipe(Config.withDefault(true)),
38	flushBatchSize: Config.number("T3CODE_TELEMETRY_FLUSH_BATCH_SIZE").pipe(Config.withDefault(20)),
39	maxBufferedEvents: Config.number("T3CODE_TELEMETRY_MAX_BUFFERED_EVENTS").pipe(
40	Config.withDefault(1_000),
41	),
42	wslDistroName: Config.string("WSL_DISTRO_NAME").pipe(Config.option),
43	});
44
45	const makeAnalyticsService = Effect.gen(function* () {
46	const telemetryConfig = yield* TelemetryEnvConfig;
47	const httpClient = yield* HttpClient.HttpClient;
48	const serverConfig = yield* ServerConfig;
49	const identifier = yield* getTelemetryIdentifier;
50	const bufferRef = yield* Ref.make<ReadonlyArray<BufferedAnalyticsEvent>>([]);
51	const clientType = serverConfig.mode === "desktop" ? "desktop-app" : "cli-web-client";
52	const hostPlatform = yield* HostProcessPlatform;
53	const hostArchitecture = yield* HostProcessArchitecture;
54
55	const enqueueBufferedEvent = (event: string, properties?: Readonly<Record<string, unknown>>) =>
56	Effect.flatMap(DateTime.now, (now) =>
57	Ref.modify(bufferRef, (current) => {
58	const appended = [
59	...current,
60	{
61	event,
62	...(properties ? { properties } : {}),
63	capturedAt: DateTime.formatIso(now),
64	} satisfies BufferedAnalyticsEvent,
65	];
66
67	const next =
68	appended.length > telemetryConfig.maxBufferedEvents
69	? appended.slice(appended.length - telemetryConfig.maxBufferedEvents)
70	: appended;
71
72	return [
73	{
74	size: next.length,
75	dropped: next.length !== appended.length,
76	} as const,
77	next,
78	] as const;
79	}),
80	);
81
82	const sendBatch = Effect.fn("sendBatch")(function* (
83	events: ReadonlyArray<BufferedAnalyticsEvent>,
84	) {
85	if (!telemetryConfig.enabled \|\| !identifier) return;
86
87	const payload = {
88	api_key: telemetryConfig.posthogKey,
89	batch: events.map((event) => ({
90	event: event.event,
91	distinct_id: identifier,
92	properties: {
93	...event.properties,
94	$process_person_profile: false,
95	platform: hostPlatform,
96	wsl: Option.getOrUndefined(telemetryConfig.wslDistroName),
97	arch: hostArchitecture,
98	t3CodeVersion: packageJson.version,
99	clientType,
100	},
101	timestamp: event.capturedAt,
102	})),
103	};
104
105	yield* HttpClientRequest.post(`${telemetryConfig.posthogHost}/batch/`).pipe(
106	HttpClientRequest.bodyJson(payload),
107	Effect.flatMap(httpClient.execute),
108	Effect.flatMap(HttpClientResponse.filterStatusOk),
109	);
110	});
111
112	const flush: AnalyticsServiceShape["flush"] = Effect.gen(function* () {
113	while (true) {
114	const batch = yield* Ref.modify(bufferRef, (current) => {
115	if (current.length === 0) {
116	return [[] as ReadonlyArray<BufferedAnalyticsEvent>, current] as const;
117	}
118	const nextBatch = current.slice(0, telemetryConfig.flushBatchSize);
119	const remaining = current.slice(nextBatch.length);
120	return [nextBatch, remaining] as const;
121	});
122
123	if (batch.length === 0) {
124	return;
125	}
126
127	yield* sendBatch(batch).pipe(
128	Effect.catch((error) =>
129	Ref.update(bufferRef, (current) => [...batch, ...current]).pipe(
130	Effect.flatMap(() => Effect.fail(error)),
131	),
132	),
133	);
134	}
135	}).pipe(Effect.catch((cause) => Effect.logError("Failed to flush telemetry", { cause })));
136
137	const record: AnalyticsServiceShape["record"] = Effect.fn("record")(
138	function* (event, properties) {
139	if (!telemetryConfig.enabled \|\| !identifier) return;
140
141	const enqueueResult = yield* enqueueBufferedEvent(event, properties);
142	if (enqueueResult.dropped) {
143	yield* Effect.logDebug("analytics buffer full; dropping oldest event", {
144	size: enqueueResult.size,
145	event,
146	});
147	}
148	},
149	);
150
151	yield* Effect.forever(Effect.sleep(1000).pipe(Effect.flatMap(() => flush)), {
152	disableYield: true,
153	}).pipe(Effect.forkScoped);
154
155	yield* Effect.addFinalizer(() => flush);
156
157	return {
158	record,
159	flush,
160	} satisfies AnalyticsServiceShape;
161	});
162
163	export const AnalyticsServiceLayerLive = Layer.effect(AnalyticsService, makeAnalyticsService);

apps/server/src/telemetry/Services/AnalyticsService.ts+2-35

...	@@ -1,35 +1,2 @@	...	@@ -1,35 +1,2 @@
1	/**	1	// Compatibility shim for the intentionally excluded orchestration harness.
2	* AnalyticsService - Anonymous telemetry capture contract.	2	export { AnalyticsService } from "../AnalyticsService.ts";
3	*
4	* Provides a best-effort event API for runtime telemetry and a strict
5	* `captureImmediate` method for call sites that need explicit error handling.
6	*
7	* @module AnalyticsService
8	*/
9	import * as Effect from "effect/Effect";
10	import * as Layer from "effect/Layer";
11	import * as Context from "effect/Context";
12
13	export interface AnalyticsServiceShape {
14	/**
15	* Capture an event immediately; returns typed failure when capture fails.
16	*/
17	readonly record: (
18	event: string,
19	properties?: Readonly<Record<string, unknown>>,
20	) => Effect.Effect<void, never>;
21
22	/**
23	* Flush queued telemetry.
24	*/
25	readonly flush: Effect.Effect<void, never>;
26	}
27
28	export class AnalyticsService extends Context.Service<AnalyticsService, AnalyticsServiceShape>()(
29	"t3/telemetry/Services/AnalyticsService",
30	) {
31	static readonly layerTest = Layer.succeed(AnalyticsService, {
32	record: () => Effect.void,
33	flush: Effect.void,
34	});
35	}

...	@@ -39,13 +39,14 @@ export interface TraceDiagnosticsOptions {	...	@@ -39,13 +39,14 @@ export interface TraceDiagnosticsOptions {
39	readonly readAt?: DateTime.Utc;	39	readonly readAt?: DateTime.Utc;
40	}	40	}
41		41
42	export interface TraceDiagnosticsShape {	42	export class TraceDiagnostics extends Context.Service<
43	readonly read: (options: TraceDiagnosticsOptions) => Effect.Effect<ServerTraceDiagnosticsResult>;	43	TraceDiagnostics,
44	}	44	{
45		45	readonly read: (
46	export class TraceDiagnostics extends Context.Service<TraceDiagnostics, TraceDiagnosticsShape>()(	46	options: TraceDiagnosticsOptions,
47	"t3/diagnostics/TraceDiagnostics",	47	) => Effect.Effect<ServerTraceDiagnosticsResult>;
48	) {}	48	}
		49	>()("t3/diagnostics/TraceDiagnostics") {}
49		50
50	interface TraceDiagnosticsInput {	51	interface TraceDiagnosticsInput {
51	readonly traceFilePath: string;	52	readonly traceFilePath: string;
...	@@ -395,10 +396,10 @@ function readTraceFile(	...	@@ -395,10 +396,10 @@ function readTraceFile(
395	);	396	);
396	}	397	}
397		398
398	export const make = Effect.fn("makeTraceDiagnostics")(function* () {	399	export const make = Effect.gen(function* () {
399	const fileSystem = yield* FileSystem.FileSystem;	400	const fileSystem = yield* FileSystem.FileSystem;
400		401
401	const read: TraceDiagnosticsShape["read"] = Effect.fn("TraceDiagnostics.read")(	402	const read: TraceDiagnostics["Service"]["read"] = Effect.fn("TraceDiagnostics.read")(
402	function* (options) {	403	function* (options) {
403	const readAt = options.readAt ?? (yield* DateTime.now);	404	const readAt = options.readAt ?? (yield* DateTime.now);
404	const slowSpanThresholdMs = options.slowSpanThresholdMs ?? DEFAULT_SLOW_SPAN_THRESHOLD_MS;	405	const slowSpanThresholdMs = options.slowSpanThresholdMs ?? DEFAULT_SLOW_SPAN_THRESHOLD_MS;
...	@@ -449,7 +450,7 @@ export const make = Effect.fn("makeTraceDiagnostics")(function* () {	...	@@ -449,7 +450,7 @@ export const make = Effect.fn("makeTraceDiagnostics")(function* () {
449	return TraceDiagnostics.of({ read });	450	return TraceDiagnostics.of({ read });
450	});	451	});
451		452
452	export const layer = Layer.effect(TraceDiagnostics, make());	453	export const layer = Layer.effect(TraceDiagnostics, make);
453		454
454	export function readTraceDiagnostics(	455	export function readTraceDiagnostics(
455	options: TraceDiagnosticsOptions,	456	options: TraceDiagnosticsOptions,

...	@@ -17,7 +17,7 @@ import { websocketRpcRouteLayer } from "./ws.ts";	...	@@ -17,7 +17,7 @@ import { websocketRpcRouteLayer } from "./ws.ts";
17	import * as ExternalLauncher from "./process/externalLauncher.ts";	17	import * as ExternalLauncher from "./process/externalLauncher.ts";
18	import { layerConfig as SqlitePersistenceLayerLive } from "./persistence/Layers/Sqlite.ts";	18	import { layerConfig as SqlitePersistenceLayerLive } from "./persistence/Layers/Sqlite.ts";
19	import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts";	19	import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts";
20	import { AnalyticsServiceLayerLive } from "./telemetry/Layers/AnalyticsService.ts";	20	import * as AnalyticsService from "./telemetry/AnalyticsService.ts";
21	import { ProviderSessionDirectoryLive } from "./provider/Layers/ProviderSessionDirectory.ts";	21	import { ProviderSessionDirectoryLive } from "./provider/Layers/ProviderSessionDirectory.ts";
22	import * as ProviderSessionRuntime from "./persistence/ProviderSessionRuntime.ts";	22	import * as ProviderSessionRuntime from "./persistence/ProviderSessionRuntime.ts";
23	import { ProviderAdapterRegistryLive } from "./provider/Layers/ProviderAdapterRegistry.ts";	23	import { ProviderAdapterRegistryLive } from "./provider/Layers/ProviderAdapterRegistry.ts";
...	@@ -332,7 +332,7 @@ const RuntimeDependenciesLive = RuntimeCoreDependenciesLive.pipe(	...	@@ -332,7 +332,7 @@ const RuntimeDependenciesLive = RuntimeCoreDependenciesLive.pipe(
332	Layer.provideMerge(ProcessDiagnostics.layer),	332	Layer.provideMerge(ProcessDiagnostics.layer),
333	Layer.provideMerge(ProcessResourceMonitor.layer),	333	Layer.provideMerge(ProcessResourceMonitor.layer),
334	Layer.provideMerge(TraceDiagnostics.layer),	334	Layer.provideMerge(TraceDiagnostics.layer),
335	Layer.provideMerge(AnalyticsServiceLayerLive),	335	Layer.provideMerge(AnalyticsService.layer),
336	Layer.provideMerge(ExternalLauncher.layer),	336	Layer.provideMerge(ExternalLauncher.layer),
337	Layer.provideMerge(ServerLifecycleEvents.layer),	337	Layer.provideMerge(ServerLifecycleEvents.layer),
338	Layer.provide(NetService.layer),	338	Layer.provide(NetService.layer),