lael-labs/t3code

apps/server/integration/OrchestrationEngineHarness.integration.ts+15−16

 import { ProjectionCheckpointRepository } from "../src/persistence/Services/ProjectionCheckpoints.ts";
 import { ProjectionPendingApprovalRepository } from "../src/persistence/Services/ProjectionPendingApprovals.ts";
 import { makeAdapterRegistryMock } from "../src/provider/testUtils/providerAdapterRegistryMock.ts";
-import { ProviderAdapterRegistry } from "../src/provider/Services/ProviderAdapterRegistry.ts";
+import * as ProviderAdapterRegistry from "../src/provider/ProviderAdapterRegistry.ts";
 import { makeProviderRegistryLayer } from "../src/provider/testUtils/providerRegistryMock.ts";
-import { ProviderSessionDirectoryLive } from "../src/provider/Layers/ProviderSessionDirectory.ts";
+import * as ProviderSessionDirectory from "../src/provider/ProviderSessionDirectory.ts";
 import { ServerSettingsService } from "../src/serverSettings.ts";
-import { makeProviderServiceLive } from "../src/provider/Layers/ProviderService.ts";
+import * as ProviderService from "../src/provider/ProviderService.ts";
 import { makeCodexAdapter } from "../src/provider/Layers/CodexAdapter.ts";
-import {
+import * as ProviderEventLoggers from "../src/provider/ProviderEventLoggers.ts";
-  NoOpProviderEventLoggers,
-  ProviderEventLoggers,
-} from "../src/provider/Layers/ProviderEventLoggers.ts";
-import { ProviderService } from "../src/provider/Services/ProviderService.ts";
 import { AnalyticsService } from "../src/telemetry/Services/AnalyticsService.ts";
 import { CheckpointReactorLive } from "../src/orchestration/Layers/CheckpointReactor.ts";
 import * as RepositoryIdentityResolver from "../src/project/RepositoryIdentityResolver.ts";
   readonly adapterHarness: TestProviderAdapterHarness | null;
   readonly engine: OrchestrationEngineShape;
   readonly snapshotQuery: ProjectionSnapshotQuery["Service"];
-  readonly providerService: ProviderService["Service"];
+  readonly providerService: ProviderService.ProviderService["Service"];
   readonly checkpointStore: CheckpointStore.CheckpointStore["Service"];
   readonly checkpointRepository: ProjectionCheckpointRepository["Service"];
   readonly pendingApprovalRepository: ProjectionPendingApprovalRepository["Service"];
         });
     const fakeRegistry = adapterHarness
       ? Layer.succeed(
-          ProviderAdapterRegistry,
+          ProviderAdapterRegistry.ProviderAdapterRegistry,
           makeAdapterRegistryMock({ [adapterHarness.provider]: adapterHarness.adapter }),
         )
       : null;
       Layer.provide(OrchestrationEventStoreLive),
       Layer.provide(OrchestrationCommandReceiptRepositoryLive),
     );
-    const providerSessionDirectoryLayer = ProviderSessionDirectoryLive.pipe(
+    const providerSessionDirectoryLayer = ProviderSessionDirectory.layer.pipe(
       Layer.provide(ProviderSessionRuntimeRepositoryLive),
     );
     const realCodexRegistry = Layer.effect(
-      ProviderAdapterRegistry,
+      ProviderAdapterRegistry.ProviderAdapterRegistry,
       Effect.gen(function* () {
         const codexSettings = yield* decodeCodexSettings({});
         const codexAdapter = yield* makeCodexAdapter(codexSettings);
       Layer.provideMerge(NodeServices.layer),
       Layer.provideMerge(providerSessionDirectoryLayer),
     );
-    const providerEventLoggersLayer = Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers);
+    const providerEventLoggersLayer = Layer.succeed(
+      ProviderEventLoggers.ProviderEventLoggers,
+      ProviderEventLoggers.NoOpProviderEventLoggers,
+    );
     const providerLayer = useRealCodex
-      ? makeProviderServiceLive().pipe(
+      ? ProviderService.layer.pipe(
           Layer.provide(providerSessionDirectoryLayer),
           Layer.provide(realCodexRegistry),
           Layer.provide(AnalyticsService.layerTest),
           Layer.provide(providerEventLoggersLayer),
         )
-      : makeProviderServiceLive().pipe(
+      : ProviderService.layer.pipe(
           Layer.provide(providerSessionDirectoryLayer),
           Layer.provide(fakeRegistry!),
           Layer.provide(AnalyticsService.layerTest),
       runtime.runPromise(Effect.service(ProjectionSnapshotQuery)),
     ).pipe(Effect.orDie);
     const providerService = yield* tryRuntimePromise("load ProviderService service", () =>
-      runtime.runPromise(Effect.service(ProviderService)),
+      runtime.runPromise(Effect.service(ProviderService.ProviderService)),
     ).pipe(Effect.orDie);
     const checkpointStore = yield* tryRuntimePromise("load CheckpointStore service", () =>
       runtime.runPromise(Effect.service(CheckpointStore.CheckpointStore)),

apps/server/integration/providerService.integration.test.ts+1−3

@@ -70,9 +70,7 @@ const makeIntegrationFixture = Effect.gen(function* () { · 69 unmodified lines
70	),	70	),
71	).pipe(Layer.provide(SqlitePersistenceMemory));	71	).pipe(Layer.provide(SqlitePersistenceMemory));
72		72
73	const layer = Layer.effect(ProviderService.ProviderService, ProviderService.make()).pipe(	73	const layer = ProviderService.layer.pipe(Layer.provide(shared));
74	Layer.provide(shared),
75	);
76		74
77	return {	75	return {
78	cwd,	76	cwd,

apps/server/src/orchestration/Layers/CheckpointReactor.test.ts+3−6

 } from "../Services/OrchestrationEngine.ts";
 import { CheckpointReactor } from "../Services/CheckpointReactor.ts";
 import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts";
-import {
+import * as ProviderService from "../../provider/ProviderService.ts";
-  ProviderService,
-  type ProviderServiceShape,
-} from "../../provider/Services/ProviderService.ts";
 import { checkpointRefForThreadTurn } from "../../checkpointing/Utils.ts";
 import { ServerConfig } from "../../config.ts";
 import * as WorkspaceEntries from "../../workspace/WorkspaceEntries.ts";
           },
         ] satisfies ReadonlyArray<ProviderSession>)
       : Effect.succeed([] as ReadonlyArray<ProviderSession>);
-  const service: ProviderServiceShape = {
+  const service: ProviderService.ProviderService["Service"] = {
     startSession: () => unsupported(),
     sendTurn: () => unsupported(),
     interruptTurn: () => unsupported(),
       Layer.provideMerge(orchestrationLayer),
       Layer.provideMerge(projectionSnapshotLayer),
       Layer.provideMerge(RuntimeReceiptBusLive),
-      Layer.provideMerge(Layer.succeed(ProviderService, provider.service)),
+      Layer.provideMerge(Layer.succeed(ProviderService.ProviderService, provider.service)),
       Layer.provideMerge(vcsStatusBroadcasterLayer),
       Layer.provideMerge(CheckpointStore.layer.pipe(Layer.provide(VcsDriverRegistry.layer))),
       Layer.provideMerge(

apps/server/src/orchestration/Layers/CheckpointReactor.ts+2−2

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts+17−14

 import { OrchestrationEventStoreLive } from "../../persistence/Layers/OrchestrationEventStore.ts";
 import { OrchestrationCommandReceiptRepositoryLive } from "../../persistence/Layers/OrchestrationCommandReceipts.ts";
 import { SqlitePersistenceMemory } from "../../persistence/Layers/Sqlite.ts";
-import {
+import * as ProviderService from "../../provider/ProviderService.ts";
-  ProviderService,
-  type ProviderServiceShape,
-} from "../../provider/Services/ProviderService.ts";
 import { makeProviderRegistryLayer } from "../../provider/testUtils/providerRegistryMock.ts";
 import { TextGeneration, type TextGenerationShape } from "../../textGeneration/TextGeneration.ts";
 import * as RepositoryIdentityResolver from "../../project/RepositoryIdentityResolver.ts";
       }),
     );
     const interruptTurn = vi.fn((_: unknown) => Effect.void);
-    const respondToRequest = vi.fn<ProviderServiceShape["respondToRequest"]>(() => Effect.void);
+    const respondToRequest = vi.fn<ProviderService.ProviderService["Service"]["respondToRequest"]>(
-    const respondToUserInput = vi.fn<ProviderServiceShape["respondToUserInput"]>(() => Effect.void);
+      () => Effect.void,
+    );
+    const respondToUserInput = vi.fn<
+      ProviderService.ProviderService["Service"]["respondToUserInput"]
+    >(() => Effect.void);
     const stopSession = vi.fn((input: unknown) =>
       Effect.sync(() => {
         const threadId =
     ];
     const unsupported = () => Effect.die(new Error("Unsupported provider call in test")) as never;
-    const service: ProviderServiceShape = {
+    const service: ProviderService.ProviderService["Service"] = {
-      startSession: startSession as ProviderServiceShape["startSession"],
+      startSession: startSession as ProviderService.ProviderService["Service"]["startSession"],
-      sendTurn: sendTurn as ProviderServiceShape["sendTurn"],
+      sendTurn: sendTurn as ProviderService.ProviderService["Service"]["sendTurn"],
-      interruptTurn: interruptTurn as ProviderServiceShape["interruptTurn"],
+      interruptTurn: interruptTurn as ProviderService.ProviderService["Service"]["interruptTurn"],
-      respondToRequest: respondToRequest as ProviderServiceShape["respondToRequest"],
+      respondToRequest:
-      respondToUserInput: respondToUserInput as ProviderServiceShape["respondToUserInput"],
+        respondToRequest as ProviderService.ProviderService["Service"]["respondToRequest"],
-      stopSession: stopSession as ProviderServiceShape["stopSession"],
+      respondToUserInput:
+        respondToUserInput as ProviderService.ProviderService["Service"]["respondToUserInput"],
+      stopSession: stopSession as ProviderService.ProviderService["Service"]["stopSession"],
       listSessions: () => Effect.succeed(runtimeSessions),
       getCapabilities: (_provider) =>
         Effect.succeed({
     const layer = ProviderCommandReactorLive.pipe(
       Layer.provideMerge(orchestrationLayer),
       Layer.provideMerge(projectionSnapshotLayer),
-      Layer.provideMerge(Layer.succeed(ProviderService, service)),
+      Layer.provideMerge(Layer.succeed(ProviderService.ProviderService, service)),
       Layer.provideMerge(makeProviderRegistryLayer(providerSnapshots as never)),
       Layer.provideMerge(
         Layer.mock(GitWorkflowService.GitWorkflowService)({

apps/server/src/orchestration/Layers/ProviderCommandReactor.ts+4−4

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts+3−6

 import { OrchestrationEventStoreLive } from "../../persistence/Layers/OrchestrationEventStore.ts";
 import { OrchestrationCommandReceiptRepositoryLive } from "../../persistence/Layers/OrchestrationCommandReceipts.ts";
 import { SqlitePersistenceMemory } from "../../persistence/Layers/Sqlite.ts";
-import {
+import * as ProviderService from "../../provider/ProviderService.ts";
-  ProviderService,
-  type ProviderServiceShape,
-} from "../../provider/Services/ProviderService.ts";
 import * as RepositoryIdentityResolver from "../../project/RepositoryIdentityResolver.ts";
 import { OrchestrationEngineLive } from "./OrchestrationEngine.ts";
 import { OrchestrationProjectionPipelineLive } from "./ProjectionPipeline.ts";
   const runtimeSessions: ProviderSession[] = [];
   const unsupported = () => Effect.die(new Error("Unsupported provider call in test")) as never;
-  const service: ProviderServiceShape = {
+  const service: ProviderService.ProviderService["Service"] = {
     startSession: () => unsupported(),
     sendTurn: () => unsupported(),
     interruptTurn: () => unsupported(),
       Layer.provideMerge(orchestrationLayer),
       Layer.provideMerge(projectionSnapshotLayer),
       Layer.provideMerge(SqlitePersistenceMemory),
-      Layer.provideMerge(Layer.succeed(ProviderService, provider.service)),
+      Layer.provideMerge(Layer.succeed(ProviderService.ProviderService, provider.service)),
       Layer.provideMerge(makeTestServerSettingsLayer(options?.serverSettings)),
       Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())),
       Layer.provideMerge(NodeServices.layer),

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts+2−2

apps/server/src/orchestration/Layers/ThreadDeletionReactor.ts+2−2

@@ -5,7 +5,7 @@ import * as Effect from "effect/Effect"; · 4 unmodified lines
5	import * as Layer from "effect/Layer";	5	import * as Layer from "effect/Layer";
6	import * as Stream from "effect/Stream";	6	import * as Stream from "effect/Stream";
7		7
8	import { ProviderService } from "../../provider/Services/ProviderService.ts";	8	import * as ProviderService from "../../provider/ProviderService.ts";
9	import * as TerminalManager from "../../terminal/Manager.ts";	9	import * as TerminalManager from "../../terminal/Manager.ts";
10	import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";	10	import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";
11	import {	11	import {
@@ -38,7 +38,7 @@ export const logCleanupCauseUnlessInterrupted = <R, E>({ · 26 unmodified lines
38		38
39	const make = Effect.gen(function* () {	39	const make = Effect.gen(function* () {
40	const orchestrationEngine = yield* OrchestrationEngineService;	40	const orchestrationEngine = yield* OrchestrationEngineService;
41	const providerService = yield* ProviderService;	41	const providerService = yield* ProviderService.ProviderService;
42	const terminalManager = yield* TerminalManager.TerminalManager;	42	const terminalManager = yield* TerminalManager.TerminalManager;
43		43
44	const stopProviderSession = (threadId: ThreadDeletedEvent["payload"]["threadId"]) =>	44	const stopProviderSession = (threadId: ThreadDeletedEvent["payload"]["threadId"]) =>

apps/server/src/provider/Layers/OpenCodeProvider.test.ts+25−0

@@ -16,6 +16,31 @@ const decodeOpenCodeSettings = Schema.decodeSync(OpenCodeSettings); · 15 unmodified lines
16		16
17	const DEFAULT_VERSION_STDOUT = "opencode 1.14.19\n";	17	const DEFAULT_VERSION_STDOUT = "opencode 1.14.19\n";
18		18
		19	it("keeps OpenCode runtime causes separate from stable messages", () => {
		20	const cause = new Error("sdk response included sensitive diagnostics");
		21	const error = new OpenCodeRuntime.OpenCodeRuntimeError({
		22	operation: "provider.list",
		23	detail: cause.message,
		24	cause,
		25	});
		26
		27	assert.equal(error.cause, cause);
		28	assert.equal(error.message, "OpenCode runtime operation provider.list failed.");
		29	assert.doesNotMatch(error.message, /sensitive diagnostics/u);
		30
		31	const processExit = new OpenCodeRuntime.OpenCodeRuntimeError({
		32	operation: "startOpenCodeServerProcess",
		33	detail: "OpenCode server exited before startup completed.",
		34	exitCode: 1,
		35	stdout: "startup output",
		36	stderr: "startup failure",
		37	});
		38	assert.equal(processExit.cause, undefined);
		39	assert.equal(processExit.exitCode, 1);
		40	assert.equal(processExit.stdout, "startup output");
		41	assert.equal(processExit.stderr, "startup failure");
		42	});
		43
19	/**	44	/**
20	* The legacy `OpenCodeProviderLive` Layer + `OpenCodeProvider` service tag	45	* The legacy `OpenCodeProviderLive` Layer + `OpenCodeProvider` service tag
21	* are deleted. The snapshot-producing logic they wrapped now lives in the	46	* are deleted. The snapshot-producing logic they wrapped now lives in the

apps/server/src/provider/Layers/ProviderEventLoggers.ts+0−6

@@ -1,6 +0,0 @@
1	// Compatibility shim for the intentionally excluded orchestration harness.
2	import * as Canonical from "../ProviderEventLoggers.ts";
3
4	export const ProviderEventLoggersLive = Canonical.layer;
5	export const ProviderEventLoggers = Canonical.ProviderEventLoggers;
6	export const NoOpProviderEventLoggers = Canonical.NoOpProviderEventLoggers;

apps/server/src/provider/Layers/ProviderService.ts+0−11

@@ -1,11 +0,0 @@
1	// Compatibility shim for the intentionally excluded orchestration harness.
2	import * as Layer from "effect/Layer";
3
4	import * as ProviderService from "../ProviderService.ts";
5
6	export type ProviderServiceLiveOptions = ProviderService.ProviderServiceOptions;
7
8	export const ProviderServiceLive = ProviderService.layer;
9
10	export const makeProviderServiceLive = (options?: ProviderService.ProviderServiceOptions) =>
11	Layer.effect(ProviderService.ProviderService, ProviderService.make(options));

apps/server/src/provider/Layers/ProviderSessionDirectory.ts+0−6

@@ -1,6 +0,0 @@
1	// Compatibility shim for the intentionally excluded orchestration harness.
2	import * as ProviderSessionDirectory from "../ProviderSessionDirectory.ts";
3
4	export const ProviderSessionDirectoryLive = ProviderSessionDirectory.layer;
5
6	export const makeProviderSessionDirectoryLive = () => ProviderSessionDirectory.layer;

apps/server/src/provider/ProviderAdapterRegistry.ts+26−9

  *   - `getByInstance` / `listInstances` — new per-instance routing. Callers
  *     that already know an `instanceId` (threads, sessions, events)
  *     should prefer these.
+ *   - `listProviders` — legacy kind-keyed routing for default instances
  *     (`defaultInstanceIdForDriver(kind) === kind`), matching the pre-Slice-D
  *     behaviour. New code should not grow additional callers of the kind-keyed
  *     methods; they exist so the settings UI, WS refresh RPC, and a handful
  *     of legacy persisted rows can still be routed during the rollout.
  *
+ * Adapter lookups are resolved dynamically through `ProviderInstanceRegistry`.
+ * Settings-driven hot reload is therefore visible immediately without
+ * rebuilding this facade.
+ *
  * @module ProviderAdapterRegistry
  */
 import {
   {
     /**
      * Resolve the adapter for a specific instance id. Returns
-     * `ProviderUnsupportedError` if no such live instance is registered.
+     * `ProviderUnsupportedError` if no such instance is currently registered
+     * (which covers "never configured" and "configured but the driver is
+     * unavailable in this build"; both surface the same failure to callers
+     * that expect a working adapter).
      */
     readonly getByInstance: (
       instanceId: ProviderInstanceId,
     ) => Effect.Effect<ProviderInstanceRoutingInfo, ProviderUnsupportedError>;
     /**
-     * List every live instance id. Unavailable shadow instances are excluded
+     * List all live instance ids. Excludes unavailable/shadow instances because
-     * because callers use these ids with `getByInstance`.
+     * callers of this method want something they can pass to `getByInstance`.
      */
     readonly listInstances: () => Effect.Effect<ReadonlyArray<ProviderInstanceId>>;
     /**
      * List provider kinds whose default instance is currently registered.
      *
-     * @deprecated Prefer `listInstances`; this remains for migration-era
+     * @deprecated Prefer `listInstances`. Retained for migration-era call sites
-     * callers that still address providers by driver kind.
+     * that iterate providers to build UI or metrics.
      */
     readonly listProviders: () => Effect.Effect<ReadonlyArray<ProviderDriverKind>>;
     /**
-     * Emits whenever the live instance set changes. Consumers should re-read
+     * Change notification stream mirroring
-     * `listInstances` and reconcile their per-instance subscriptions.
+     * `ProviderInstanceRegistry.streamChanges`. Emits one `void` tick whenever
+     * the set of live instances changes. Consumers that fan out
+     * `adapter.streamEvents` per instance re-pull `listInstances` on each tick
+     * and fork subscriptions for instances they have not seen yet.
      */
     readonly streamChanges: Stream.Stream<void>;
     /**
-     * Acquire the change subscription synchronously in the caller's scope,
+     * Acquire a change subscription synchronously in the caller's current
-     * avoiding the publish race inherent in forking `Stream.fromPubSub`.
+     * fiber. Consumers that must avoid missing a publish between initial
+     * reconciliation and watcher startup should use this, then fork
+     * `Stream.fromSubscription`.
      */
     readonly subscribeChanges: Effect.Effect<PubSub.Subscription<void>, never, Scope.Scope>;
   }
         const kinds = new Set<ProviderDriverKind>();
         for (const instance of instances) {
           if (instance.instanceId === defaultInstanceIdForDriver(instance.driverKind)) {
+            // Only default instances appear through this legacy view; custom
+            // instances such as `codex_personal` have no driver-kind identity.
             kinds.add(instance.driverKind);
           }
         }
     getInstanceInfo,
     listInstances,
     listProviders,
+    // The facade owns no state; the instance registry already coalesces
+    // add, remove, and rebuild notifications into a single change channel.
     streamChanges: registry.streamChanges,
     subscribeChanges: registry.subscribeChanges,
   });

apps/server/src/provider/ProviderInstanceRegistry.ts+29−16

   ProviderInstanceRegistry,
   {
     /**
-     * Look up one instance by id. Unknown ids return `undefined`; callers map
+     * Look up one instance by id. Returns `undefined` (not `Option`) when the
-     * that absence to the appropriate domain error.
+     * id is unknown; callers branch on absence and emit the appropriate domain
+     * error.
      */
     readonly getInstance: (
       instanceId: ProviderInstanceId,
     ) => Effect.Effect<ProviderInstance | undefined>;
     /**
-     * Every successfully materialized instance, in stable settings-author
+     * Every available (driver-registered, successfully created) instance, in
-     * order.
+     * stable settings-author order.
      */
     readonly listInstances: Effect.Effect<ReadonlyArray<ProviderInstance>>;
     /**
-     * Shadow snapshots for unknown drivers or invalid configurations, ready
+     * Wire-shape shadow snapshots for instances whose driver is unknown to this
-     * to merge into `ProviderRegistry` output.
+     * build or whose config failed to decode. Suitable for merging directly
+     * into `ProviderRegistry` output.
      */
     readonly listUnavailable: Effect.Effect<ReadonlyArray<ServerProvider>>;
     /**
-     * Emits after the registry adds, removes, or rebuilds instances. The
+     * Push notification stream emitted whenever the registry's contents change.
-     * payload is `void` because consumers re-read both registry lists.
+     * The payload is `void` because consumers always re-pull `listInstances`
+     * and `listUnavailable` together.
      *
-     * `Stream.fromPubSub` subscribes only when execution begins, so a newly
+     * `Stream.fromPubSub` defers `PubSub.subscribe` until the stream starts
-     * forked consumer can miss a publish. Consumers that cannot tolerate that
+     * running, so forking a consumer races the next publish. Hot-reload
-     * gap should acquire `subscribeChanges` first.
+     * consumers that cannot miss a publish should use `subscribeChanges`
+     * instead, which acquires the subscription synchronously before the
+     * consumer loop is forked.
      */
     readonly streamChanges: Stream.Stream<void>;
     /**
-     * Acquire a scoped PubSub subscription synchronously before forking the
+     * Acquire a scoped subscription to the change channel synchronously in the
-     * consumer loop, ensuring subsequent publishes cannot land in a gap.
+     * caller's fiber. Consumers typically `yield*` this in the same fiber that
+     * forks their consumer loop, then drain it with `PubSub.take` or
+     * `Stream.fromSubscription`. Because the subscription is registered before
+     * this effect returns, no subsequent publish can land in a gap.
      */
     readonly subscribeChanges: Effect.Effect<PubSub.Subscription<void>, never, Scope.Scope>;
   }
   ProviderInstanceRegistryMutator,
   {
     /**
-     * Reconcile the live registry with a new configuration map. Individual
+     * Bring the live registry in line with the supplied config map. The
-     * driver creation failures become unavailable shadow snapshots so the
+     * operation closes removed or replaced scopes before creating replacements
-     * settings watcher itself never fails.
+     * and publishes a single change tick after the batch. Reapplying an
+     * unchanged map is a no-op.
+     *
+     * The effect never fails: individual driver creation failures become
+     * unavailable shadow snapshots, keeping settings-watcher loops alive when
+     * one entry is invalid.
      */
     readonly reconcile: (configMap: ProviderInstanceConfigMap) => Effect.Effect<void>;
   }

apps/server/src/provider/ProviderRegistry.ts+20−22

   ProviderRegistry,
   {
     /**
-     * Read the latest snapshot for every configured instance. Multiple
+     * Read the latest provider snapshots for every configured instance.
-     * snapshots can share a driver kind and are distinguished by instance id.
+     * Multiple snapshots may share the same driver kind and disambiguate via
+     * `instanceId`.
      */
     readonly getProviders: Effect.Effect<ReadonlyArray<ServerProvider>>;
     /**
-     * Refresh every provider, or the default instance for one driver kind.
+     * Refresh all providers, or the default instance of the specified kind
+     * when supplied.
+     *
+     * Retained for compatibility with legacy call sites such as the WS refresh
+     * RPC and orchestration metrics.
      *
      * @deprecated Prefer `refreshInstance` for new call sites.
      */
     /**
      * Refresh one configured instance. Unknown ids resolve to the current
-     * cached list to preserve the legacy transport behavior.
+     * cached list, matching the legacy `refresh` behavior so transport layers
+     * do not have to special-case unknown ids.
      */
     readonly refreshInstance: (
       instanceId: ProviderInstanceId,
     ) => Effect.Effect<ReadonlyArray<ServerProvider>>;
     /**
-     * Resolve maintenance capabilities for a live instance, falling back to
+     * Resolve maintenance capabilities for one live provider instance,
-     * manual-only capabilities when that instance is unavailable.
+     * falling back to manual-only capabilities when it is unavailable.
      */
     readonly getProviderMaintenanceCapabilitiesForInstance: (
       instanceId: ProviderInstanceId,
     ) => Effect.Effect<ProviderMaintenanceCapabilities>;
     /**
-     * Apply volatile maintenance state for one instance. This state is not
+     * Apply volatile maintenance-action state to one configured instance. This
-     * persisted; update actions are projected onto `ServerProvider.updateState`.
+     * state is never persisted. Today only update actions are projected onto
+     * `ServerProvider.updateState`; install/auth actions can extend this map
+     * without adding driver-scoped APIs.
      */
     readonly setProviderMaintenanceActionState: (input: {
       readonly instanceId: ProviderInstanceId;
       readonly state: ServerProviderUpdateState | null;
     }) => Effect.Effect<ReadonlyArray<ServerProvider>>;
-    /** Emits the full materialized provider list after each aggregated change. */
+    /**
+     * Stream of provider snapshot updates, one emission per aggregated change.
+     * The array contains the full current state.
+     */
     readonly streamChanges: Stream.Stream<ReadonlyArray<ServerProvider>>;
   }
 >()("t3/provider/ProviderRegistry") {}
   // and pending fallbacks fill the gaps.
   yield* upsertProviders(fallbackProviders, { publish: false });
   // Subscribe to registry mutations BEFORE running the initial sync.
-  // `subscribeChanges` acquires the dequeue synchronously in this
-  // fibre; the subscription is active the instant this `yield*`
-  // returns. Forking the consumer loop later cannot lose a publish
-  // because no publish can reach a not-yet-subscribed dequeue.
-  //
-  // (Contrast with the pre-fix code that did
-  // `Stream.runForEach(instanceRegistry.streamChanges, …).pipe(Effect.forkScoped)`.
-  // `Stream.fromPubSub` defers `PubSub.subscribe` to stream start,
-  // and `forkScoped` only schedules the fibre — so a reconcile that
-  // published between "fibre scheduled" and "fibre starts running"
-  // was dropped, which made any settings change that replaced an
-  // instance never propagate to the aggregator's `providersRef`.)
-  // Subscribe to registry mutations BEFORE running the initial sync.
   // `subscribeChanges` acquires the `PubSub.Subscription` synchronously
   // in this fibre; the subscription is registered with the PubSub the
   // instant this `yield*` returns, so any subsequent publish is

apps/server/src/provider/ProviderService.test.ts+18−15

 } from "../persistence/Layers/Sqlite.ts";
 import * as ServerSettings from "../serverSettings.ts";
 import * as AnalyticsService from "../telemetry/AnalyticsService.ts";
+import { makeAdapterRegistryMock } from "./testUtils/providerAdapterRegistryMock.ts";
-const makeProviderServiceLive = (options?: ProviderService.ProviderServiceOptions) =>
+// Several tests build two ProviderService instances in one scope to simulate a
+// process restart. Construct a fresh Layer for each build so Layer memoization
+// cannot reuse the first service instance.
+const makeFreshProviderServiceLayer = (options?: ProviderService.ProviderServiceOptions) =>
   Layer.effect(ProviderService.ProviderService, ProviderService.make(options));
-import { makeAdapterRegistryMock } from "./testUtils/providerAdapterRegistryMock.ts";
 const defaultServerSettingsLayer = ServerSettings.ServerSettingsService.layerTest();
   const layer = it.layer(
     Layer.mergeAll(
-      makeProviderServiceLive().pipe(
+      makeFreshProviderServiceLayer().pipe(
         Layer.provide(providerAdapterLayer),
         Layer.provide(directoryLayer),
         Layer.provide(defaultServerSettingsLayer),
       Layer.provide(runtimeRepositoryLayer),
     );
     const providerLayer = Layer.mergeAll(
-      makeProviderServiceLive().pipe(
+      makeFreshProviderServiceLayer().pipe(
         Layer.provide(providerAdapterLayer),
         Layer.provide(directoryLayer),
         Layer.provide(defaultServerSettingsLayer),
     const directoryLayer = ProviderSessionDirectory.layer.pipe(
       Layer.provide(runtimeRepositoryLayer),
     );
-    const providerLayer = makeProviderServiceLive().pipe(
+    const providerLayer = makeFreshProviderServiceLayer().pipe(
       Layer.provide(providerAdapterLayer),
       Layer.provide(directoryLayer),
       Layer.provide(defaultServerSettingsLayer),
       const directoryLayer = ProviderSessionDirectory.layer.pipe(
         Layer.provide(runtimeRepositoryLayer),
       );
-      const providerLayer = makeProviderServiceLive().pipe(
+      const providerLayer = makeFreshProviderServiceLayer().pipe(
         Layer.provide(providerAdapterLayer),
         Layer.provide(directoryLayer),
         Layer.provide(serverSettingsLayer),
     const directoryLayer = ProviderSessionDirectory.layer.pipe(
       Layer.provide(runtimeRepositoryLayer),
     );
-    const providerLayer = makeProviderServiceLive().pipe(
+    const providerLayer = makeFreshProviderServiceLayer().pipe(
       Layer.provide(providerAdapterLayer),
       Layer.provide(directoryLayer),
       Layer.provide(defaultServerSettingsLayer),
     const directoryLayer = ProviderSessionDirectory.layer.pipe(
       Layer.provide(runtimeRepositoryLayer),
     );
-    const providerLayer = makeProviderServiceLive({
+    const providerLayer = makeFreshProviderServiceLayer({
       canonicalEventLogger: {
         filePath: "memory://provider-canonical-events",
         write: (event, threadId) => {
       });
     }).pipe(Effect.provide(directoryLayer));
-    const providerLayer = makeProviderServiceLive().pipe(
+    const providerLayer = makeFreshProviderServiceLayer().pipe(
       Layer.provide(Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, registry)),
       Layer.provide(directoryLayer),
       Layer.provide(defaultServerSettingsLayer),
       const firstDirectoryLayer = ProviderSessionDirectory.layer.pipe(
         Layer.provide(runtimeRepositoryLayer),
       );
-      const firstProviderLayer = makeProviderServiceLive().pipe(
+      const firstProviderLayer = makeFreshProviderServiceLayer().pipe(
         Layer.provide(
           Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, firstRegistry),
         ),
       const secondDirectoryLayer = ProviderSessionDirectory.layer.pipe(
         Layer.provide(runtimeRepositoryLayer),
       );
-      const secondProviderLayer = makeProviderServiceLive().pipe(
+      const secondProviderLayer = makeFreshProviderServiceLayer().pipe(
         Layer.provide(
           Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, secondRegistry),
         ),
       const firstDirectoryLayer = ProviderSessionDirectory.layer.pipe(
         Layer.provide(runtimeRepositoryLayer),
       );
-      const firstProviderLayer = makeProviderServiceLive().pipe(
+      const firstProviderLayer = makeFreshProviderServiceLayer().pipe(
         Layer.provide(
           Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, firstRegistry),
         ),
       const secondDirectoryLayer = ProviderSessionDirectory.layer.pipe(
         Layer.provide(runtimeRepositoryLayer),
       );
-      const secondProviderLayer = makeProviderServiceLive().pipe(
+      const secondProviderLayer = makeFreshProviderServiceLayer().pipe(
         Layer.provide(
           Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, secondRegistry),
         ),
         const firstDirectoryLayer = ProviderSessionDirectory.layer.pipe(
           Layer.provide(runtimeRepositoryLayer),
         );
-        const firstProviderLayer = makeProviderServiceLive().pipe(
+        const firstProviderLayer = makeFreshProviderServiceLayer().pipe(
           Layer.provide(
             Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, firstRegistry),
           ),
         const secondDirectoryLayer = ProviderSessionDirectory.layer.pipe(
           Layer.provide(runtimeRepositoryLayer),
         );
-        const secondProviderLayer = makeProviderServiceLive().pipe(
+        const secondProviderLayer = makeFreshProviderServiceLayer().pipe(
           Layer.provide(
             Layer.succeed(ProviderAdapterRegistry.ProviderAdapterRegistry, secondRegistry),
           ),

apps/server/src/provider/ProviderService.ts+28−15

  * unified provider event stream for subscribers.
  *
  * It does not implement provider protocol details (adapter concern).
+ * Uses Effect `Context.Service` for dependency injection and returns typed
+ * domain errors for validation, session, codex, and checkpoint workflows.
  *
  * @module ProviderService
  */
 import { type EventNdjsonLogger } from "./Layers/EventNdjsonLogger.ts";
 import * as ProviderEventLoggers from "./ProviderEventLoggers.ts";
 import * as AnalyticsService from "../telemetry/AnalyticsService.ts";
-import * as McpProviderSession from "../mcp/McpProviderSession.ts";
+import {
-import * as McpSessionRegistry from "../mcp/McpSessionRegistry.ts";
+  clearAllMcpProviderSessions,
+  clearMcpProviderSession,
+  setMcpProviderSession,
+} from "../mcp/McpProviderSession.ts";
+import {
+  issueActiveMcpCredential,
+  revokeActiveMcpThread,
+  revokeAllActiveMcpCredentials,
+} from "../mcp/McpSessionRegistry.ts";
 const isModelSelection = Schema.is(ModelSelection);
 export class ProviderService extends Context.Service<
   ProviderService,
   {
-    /** Start a provider session for a thread. */
+    /** Start a provider session. */
     readonly startSession: (
       threadId: ThreadId,
       input: ProviderSessionStartInput,
       input: ProviderStopSessionInput,
     ) => Effect.Effect<void, ProviderServiceError>;
-    /** Aggregate the active sessions reported by all registered adapters. */
+    /**
+     * List active provider sessions.
+     *
+     * Aggregates runtime session lists from all registered adapters.
+     */
     readonly listSessions: () => Effect.Effect<ReadonlyArray<ProviderSession>>;
-    /** Read capabilities for the adapter bound to an instance. */
+    /** Read capabilities for the adapter bound to a configured provider instance. */
     readonly getCapabilities: (
       instanceId: ProviderInstanceId,
     ) => Effect.Effect<ProviderAdapterCapabilities, ProviderServiceError>;
     }) => Effect.Effect<void, ProviderServiceError>;
     /**
-     * Canonical provider runtime event stream. ProviderService owns the
+     * Canonical provider runtime event stream.
-     * per-instance fan-out rather than delegating it to a separate event bus.
+     *
+     * Fan-out is owned by ProviderService (not by a standalone event-bus service).
      */
     readonly streamEvents: Stream.Stream<ProviderRuntimeEvent>;
   }
   const runtimeEventPubSub = yield* PubSub.unbounded<ProviderRuntimeEvent>();
   const nowIso = Effect.map(DateTime.now, DateTime.formatIso);
   const prepareMcpSession = (threadId: ThreadId, providerInstanceId: ProviderInstanceId) =>
-    McpSessionRegistry.issueActiveMcpCredential({ threadId, providerInstanceId }).pipe(
+    issueActiveMcpCredential({ threadId, providerInstanceId }).pipe(
       Effect.tap((credential) =>
-        credential
+        credential ? Effect.sync(() => setMcpProviderSession(credential.config)) : Effect.void,
-          ? Effect.sync(() => McpProviderSession.setMcpProviderSession(credential.config))
-          : Effect.void,
       ),
     );
   const clearMcpSession = (threadId: ThreadId) =>
-    McpSessionRegistry.revokeActiveMcpThread(threadId).pipe(
+    revokeActiveMcpThread(threadId).pipe(
-      Effect.tap(() => Effect.sync(() => McpProviderSession.clearMcpProviderSession(threadId))),
+      Effect.tap(() => Effect.sync(() => clearMcpProviderSession(threadId))),
     );
   const publishRuntimeEvent = (event: ProviderRuntimeEvent): Effect.Effect<void> =>
       ),
     ).pipe(Effect.asVoid);
     yield* Effect.forEach(currentAdapters, ([, adapter]) => adapter.stopAll()).pipe(Effect.asVoid);
-    yield* McpSessionRegistry.revokeAllActiveMcpCredentials();
+    yield* revokeAllActiveMcpCredentials();
-    McpProviderSession.clearAllMcpProviderSessions();
+    clearAllMcpProviderSessions();
     const bindings = yield* directory.listBindings().pipe(Effect.orElseSucceed(() => []));
     yield* Effect.forEach(bindings, (binding) =>
       Effect.gen(function* () {

apps/server/src/provider/ProviderSessionDirectory.test.ts+1−3

 import * as ProviderSessionDirectory from "./ProviderSessionDirectory.ts";
 function makeDirectoryLayer<E, R>(persistenceLayer: Layer.Layer<SqlClient.SqlClient, E, R>) {
-  const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe(
+  const runtimeRepositoryLayer = ProviderSessionRuntime.layer.pipe(Layer.provide(persistenceLayer));
-    Layer.provide(persistenceLayer),
-  );
   return Layer.mergeAll(
     runtimeRepositoryLayer,
     ProviderSessionDirectory.layer.pipe(Layer.provide(runtimeRepositoryLayer)),

apps/server/src/provider/ProviderSessionDirectory.ts+4−1

 import * as Schema from "effect/Schema";
 import { ProviderSessionDirectoryPersistenceError, ProviderValidationError } from "./Errors.ts";
-import * as ProviderSessionRuntime from "../persistence/Services/ProviderSessionRuntime.ts";
+import * as ProviderSessionRuntime from "../persistence/ProviderSessionRuntime.ts";
 export interface ProviderRuntimeBinding {
   readonly threadId: ThreadId;
         ({
           threadId: runtime.threadId,
           provider,
+          // Migration boundary: rows written before provider instances had a
+          // nullable id. Promote them here so runtime routing never has to
+          // infer an instance from its driver kind.
           providerInstanceId: runtime.providerInstanceId ?? defaultInstanceIdForDriver(provider),
           adapterKey: runtime.adapterKey,
           runtimeMode: runtime.runtimeMode,

apps/server/src/provider/ProviderSessionReaper.ts+1−0

@@ -14,6 +14,7 @@ import * as ProviderSessionDirectory from "./ProviderSessionDirectory.ts"; · 13 unmodified lines
14	export class ProviderSessionReaper extends Context.Service<	14	export class ProviderSessionReaper extends Context.Service<
15	ProviderSessionReaper,	15	ProviderSessionReaper,
16	{	16	{
		17	/** Start the background provider session reaper within the provided scope. */
17	readonly start: () => Effect.Effect<void, never, Scope.Scope>;	18	readonly start: () => Effect.Effect<void, never, Scope.Scope>;
18	}	19	}
19	>()("t3/provider/ProviderSessionReaper") {}	20	>()("t3/provider/ProviderSessionReaper") {}

apps/server/src/provider/Services/ProviderAdapterRegistry.ts+0−3

@@ -1,3 +0,0 @@
1	// Compatibility shim for the intentionally excluded orchestration harness.
2	export { ProviderAdapterRegistry } from "../ProviderAdapterRegistry.ts";
3	export type { ProviderInstanceRoutingInfo } from "../ProviderAdapterRegistry.ts";

apps/server/src/provider/Services/ProviderRegistry.ts+0−2

@@ -1,2 +0,0 @@
1	// Compatibility shim for the intentionally excluded orchestration modules.
2	export * from "../ProviderRegistry.ts";

apps/server/src/provider/Services/ProviderService.ts+0−5

@@ -1,5 +0,0 @@
1	// Compatibility shim for the intentionally excluded orchestration modules and harness.
2	export * from "../ProviderService.ts";
3
4	/** @deprecated Use `ProviderService["Service"]` from the canonical module. */
5	export type ProviderServiceShape = import("../ProviderService.ts").ProviderService["Service"];

apps/server/src/provider/opencodeRuntime.ts+9−4

 import * as Stream from "effect/Stream";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-import * as ProcessRunner from "../processRunner.ts";
+import { isWindowsCommandNotFound } from "../processRunner.ts";
 import { collectStreamAsString } from "./providerSnapshot.ts";
 import * as NetService from "@t3tools/shared/Net";
 import { HostProcessPlatform } from "@t3tools/shared/hostProcess";
     operation: Schema.String,
     detail: Schema.String,
     cause: Schema.optional(Schema.Defect()),
+    exitCode: Schema.optionalKey(Schema.Number),
+    stdout: Schema.optionalKey(Schema.String),
+    stderr: Schema.optionalKey(Schema.String),
   },
 ) {
   static readonly is = Schema.is(OpenCodeRuntimeError);
   override get message(): string {
-    return `${this.operation}: ${this.detail}`;
+    return `OpenCode runtime operation ${this.operation} failed.`;
   }
 }
         { concurrency: "unbounded" },
       );
       const exitCode = Number(code);
-      if (yield* ProcessRunner.isWindowsCommandNotFound(exitCode, stderr)) {
+      if (yield* isWindowsCommandNotFound(exitCode, stderr)) {
         return yield* new OpenCodeRuntimeError({
           operation: "runOpenCodeCommand",
           detail: `spawn ${input.binaryPath} ENOENT`,
                 ]
                   .filter(Boolean)
                   .join("\n\n"),
-                cause: { exitCode, stdout, stderr },
+                exitCode,
+                stdout,
+                stderr,
               }),
             ).pipe(Effect.ignore);
           }),

apps/server/src/provider/providerMaintenanceRunner.test.ts+31−0

@@ -11,6 +11,7 @@ import * as Effect from "effect/Effect"; · 10 unmodified lines
11	import * as Exit from "effect/Exit";	11	import * as Exit from "effect/Exit";
12	import * as Fiber from "effect/Fiber";	12	import * as Fiber from "effect/Fiber";
13	import * as Layer from "effect/Layer";	13	import * as Layer from "effect/Layer";
		14	import * as PlatformError from "effect/PlatformError";
14	import * as Ref from "effect/Ref";	15	import * as Ref from "effect/Ref";
15	import * as Schema from "effect/Schema";	16	import * as Schema from "effect/Schema";
16	import * as Sink from "effect/Sink";	17	import * as Sink from "effect/Sink";
@@ -140,6 +141,13 @@ function mockSpawnerLayer( · 123 unmodified lines
140	);	141	);
141	}	142	}
142		143
		144	function failingSpawnerLayer(cause: PlatformError.PlatformError) {
		145	return Layer.succeed(
		146	ChildProcessSpawner.ChildProcessSpawner,
		147	ChildProcessSpawner.make(() => Effect.fail(cause)),
		148	);
		149	}
		150
143	function makeRegistry(	151	function makeRegistry(
144	initialProviders: ServerProvider \| ReadonlyArray<ServerProvider> = baseProvider,	152	initialProviders: ServerProvider \| ReadonlyArray<ServerProvider> = baseProvider,
145	) {	153	) {
@@ -320,6 +328,29 @@ describe("providerMaintenanceRunner", () => { · 174 unmodified lines
320	},	328	},
321	);	329	);
322		330
		331	it.effect("preserves update spawn failure messages", () => {
		332	const cause = PlatformError.systemError({
		333	_tag: "PermissionDenied",
		334	module: "ChildProcess",
		335	method: "spawn",
		336	pathOrDescriptor: "npm",
		337	description: "",
		338	});
		339	return Effect.gen(function* () {
		340	const { registry } = yield* makeRegistry(baseProvider);
		341	const runner = yield* makeTestRunner(registry);
		342
		343	const result = yield* runner.updateProvider(CODEX_DRIVER);
		344	assert.strictEqual(result.providers[0]?.updateState?.status, "failed");
		345	assert.strictEqual(
		346	result.providers[0]?.updateState?.message,
		347	`Failed to run update command npm: ${cause.message}`,
		348	);
		349	}).pipe(
		350	Effect.provide(Layer.mergeAll(latestVersionHttpClient("0.0.0"), failingSpawnerLayer(cause))),
		351	);
		352	});
		353
323	it.effect("updates a single provider instance without touching sibling instances", () => {	354	it.effect("updates a single provider instance without touching sibling instances", () => {
324	const calls: Array<{ command: string; args: ReadonlyArray<string> }> = [];	355	const calls: Array<{ command: string; args: ReadonlyArray<string> }> = [];
325	return Effect.gen(function* () {	356	return Effect.gen(function* () {

apps/server/src/provider/providerMaintenanceRunner.ts+63−13

@@ -14,6 +14,7 @@ import * as Duration from "effect/Duration"; · 13 unmodified lines
14	import * as Effect from "effect/Effect";	14	import * as Effect from "effect/Effect";
15	import * as Layer from "effect/Layer";	15	import * as Layer from "effect/Layer";
16	import * as Option from "effect/Option";	16	import * as Option from "effect/Option";
		17	import * as PlatformError from "effect/PlatformError";
17	import * as Ref from "effect/Ref";	18	import * as Ref from "effect/Ref";
18	import * as Schema from "effect/Schema";	19	import * as Schema from "effect/Schema";
19	import { HttpClient } from "effect/unstable/http";	20	import { HttpClient } from "effect/unstable/http";
@@ -52,20 +53,68 @@ export class ProviderMaintenanceRunner extends Context.Service< · 32 unmodified lines
52	}	53	}
53	>()("t3/provider/providerMaintenanceRunner") {}	54	>()("t3/provider/providerMaintenanceRunner") {}
54		55
55	class ProviderMaintenanceCommandError extends Schema.TaggedErrorClass<ProviderMaintenanceCommandError>()(	56	const platformFailureFields = {
56	"ProviderMaintenanceCommandError",	57	failureTag: Schema.NullOr(Schema.String),
		58	failureModule: Schema.String,
		59	failureMethod: Schema.String,
		60	failureDescription: Schema.NullOr(Schema.String),
		61	failurePathOrDescriptor: Schema.NullOr(Schema.Union([Schema.String, Schema.Number])),
		62	} as const;
		63
		64	interface PlatformFailureAttributes {
		65	readonly failureTag: string \| null;
		66	readonly failureModule: string;
		67	readonly failureMethod: string;
		68	readonly failureDescription: string \| null;
		69	readonly failurePathOrDescriptor: string \| number \| null;
		70	}
		71
		72	function platformFailureAttributes(cause: PlatformError.PlatformError): PlatformFailureAttributes {
		73	const { reason } = cause;
		74	return {
		75	failureTag: reason._tag === "BadArgument" ? null : reason._tag,
		76	failureModule: reason.module,
		77	failureMethod: reason.method,
		78	failureDescription: reason.description \|\| null,
		79	failurePathOrDescriptor:
		80	"pathOrDescriptor" in reason ? (reason.pathOrDescriptor ?? null) : null,
		81	};
		82	}
		83
		84	function formatPlatformFailure(attributes: PlatformFailureAttributes): string {
		85	const tag = attributes.failureTag === null ? "" : `${attributes.failureTag}: `;
		86	const path =
		87	attributes.failurePathOrDescriptor === null
		88	? ""
		89	: ` (${String(attributes.failurePathOrDescriptor)})`;
		90	const description =
		91	attributes.failureDescription === null ? "" : `: ${attributes.failureDescription}`;
		92	return `${tag}${attributes.failureModule}.${attributes.failureMethod}${path}${description}`;
		93	}
		94
		95	class ProviderMaintenanceCommandSpawnError extends Schema.TaggedErrorClass<ProviderMaintenanceCommandSpawnError>()(
		96	"ProviderMaintenanceCommandSpawnError",
57	{	97	{
58	operation: Schema.Literals(["spawn", "collect"]),	98	command: Schema.String,
59	command: Schema.optional(Schema.String),	99	...platformFailureFields,
60	cause: Schema.Defect(),	100	cause: Schema.Defect(),
61	},	101	},
62	) {	102	) {
63	override get message(): string {	103	override get message(): string {
64	const causeMessage = this.cause instanceof Error ? this.cause.message : undefined;	104	return `Failed to run update command ${this.command}: ${formatPlatformFailure(this)}`;
65	if (this.operation === "spawn") {	105	}
66	return `Failed to run update command ${this.command ?? "unknown"}${causeMessage ? `: ${causeMessage}` : "."}`;	106	}
67	}	107
68	return causeMessage ?? "Update command failed to run.";	108	class ProviderMaintenanceCommandCollectError extends Schema.TaggedErrorClass<ProviderMaintenanceCommandCollectError>()(
		109	"ProviderMaintenanceCommandCollectError",
		110	{
		111	command: Schema.String,
		112	...platformFailureFields,
		113	cause: Schema.Defect(),
		114	},
		115	) {
		116	override get message(): string {
		117	return formatPlatformFailure(this);
69	}	118	}
70	}	119	}
71		120
@@ -89,9 +138,9 @@ const runProviderMaintenanceCommandWithSpawner = Effect.fn("ProviderMaintenanceR · 17 unmodified lines
89	.pipe(	138	.pipe(
90	Effect.mapError(	139	Effect.mapError(
91	(cause) =>	140	(cause) =>
92	new ProviderMaintenanceCommandError({	141	new ProviderMaintenanceCommandSpawnError({
93	operation: "spawn",
94	command: input.command,	142	command: input.command,
		143	...platformFailureAttributes(cause),
95	cause,	144	cause,
96	}),	145	}),
97	),	146	),
@@ -114,8 +163,9 @@ const runProviderMaintenanceCommandWithSpawner = Effect.fn("ProviderMaintenanceR · 16 unmodified lines
114	).pipe(	163	).pipe(
115	Effect.mapError(	164	Effect.mapError(
116	(cause) =>	165	(cause) =>
117	new ProviderMaintenanceCommandError({	166	new ProviderMaintenanceCommandCollectError({
118	operation: "collect",	167	command: input.command,
		168	...platformFailureAttributes(cause),
119	cause,	169	cause,
120	}),	170	}),
121	),	171	),

docs/architecture/overview.md+1−1

@@ -132,7 +132,7 @@ sequenceDiagram · 131 unmodified lines
132	[5]: ../apps/server/src/wsServer/pushBus.ts	132	[5]: ../apps/server/src/wsServer/pushBus.ts
133	[6]: ../packages/contracts/src/ws.ts	133	[6]: ../packages/contracts/src/ws.ts
134	[7]: ../apps/server/src/serverLayers.ts	134	[7]: ../apps/server/src/serverLayers.ts
135	[8]: ../apps/server/src/provider/Layers/ProviderService.ts	135	[8]: ../apps/server/src/provider/ProviderService.ts
136	[9]: ../apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts	136	[9]: ../apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts
137	[10]: ../apps/server/src/orchestration/Layers/OrchestrationEngine.ts	137	[10]: ../apps/server/src/orchestration/Layers/OrchestrationEngine.ts
138	[11]: ../packages/contracts/src/orchestration.ts	138	[11]: ../packages/contracts/src/orchestration.ts

docs/operations/effect-fn-checklist.md+17−17

docs/reference/encyclopedia.md+1−1

@@ -167,7 +167,7 @@ The file patch and changed-file summary for one turn. It is usually computed in · 166 unmodified lines
167	[11]: ../apps/server/src/orchestration/Layers/ProjectionPipeline.ts	167	[11]: ../apps/server/src/orchestration/Layers/ProjectionPipeline.ts
168	[12]: ../apps/server/src/orchestration/Layers/ProviderCommandReactor.ts	168	[12]: ../apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
169	[13]: ../apps/server/src/orchestration/Services/RuntimeReceiptBus.ts	169	[13]: ../apps/server/src/orchestration/Services/RuntimeReceiptBus.ts
170	[14]: ../apps/server/src/provider/Layers/ProviderService.ts	170	[14]: ../apps/server/src/provider/ProviderService.ts
171	[15]: ../apps/server/src/provider/Services/ProviderAdapter.ts	171	[15]: ../apps/server/src/provider/Services/ProviderAdapter.ts
172	[16]: ./provider-architecture.md	172	[16]: ./provider-architecture.md
173	[17]: ../apps/server/src/provider/Layers/CodexAdapter.ts	173	[17]: ../apps/server/src/provider/Layers/CodexAdapter.ts

@@ -25,7 +25,7 @@ import { · 24 unmodified lines
25	resolveThreadWorkspaceCwd,	25	resolveThreadWorkspaceCwd,
26	} from "../../checkpointing/Utils.ts";	26	} from "../../checkpointing/Utils.ts";
27	import * as CheckpointStore from "../../checkpointing/CheckpointStore.ts";	27	import * as CheckpointStore from "../../checkpointing/CheckpointStore.ts";
28	import { ProviderService } from "../../provider/Services/ProviderService.ts";	28	import * as ProviderService from "../../provider/ProviderService.ts";
29	import { CheckpointReactor, type CheckpointReactorShape } from "../Services/CheckpointReactor.ts";	29	import { CheckpointReactor, type CheckpointReactorShape } from "../Services/CheckpointReactor.ts";
30	import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";	30	import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";
31	import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts";	31	import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts";
@@ -80,7 +80,7 @@ const make = Effect.gen(function* () { · 48 unmodified lines
80	randomUUID.pipe(Effect.map((uuid) => CommandId.make(`server:${tag}:${uuid}`)));	80	randomUUID.pipe(Effect.map((uuid) => CommandId.make(`server:${tag}:${uuid}`)));
81	const orchestrationEngine = yield* OrchestrationEngineService;	81	const orchestrationEngine = yield* OrchestrationEngineService;
82	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;	82	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
83	const providerService = yield* ProviderService;	83	const providerService = yield* ProviderService.ProviderService;
84	const checkpointStore = yield* CheckpointStore.CheckpointStore;	84	const checkpointStore = yield* CheckpointStore.CheckpointStore;
85	const receiptBus = yield* RuntimeReceiptBus;	85	const receiptBus = yield* RuntimeReceiptBus;
86	const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;	86	const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;

@@ -30,8 +30,8 @@ import { increment, orchestrationEventsProcessedTotal } from "../../observabilit · 29 unmodified lines
30	import { ProviderAdapterRequestError } from "../../provider/Errors.ts";	30	import { ProviderAdapterRequestError } from "../../provider/Errors.ts";
31	import type { ProviderServiceError } from "../../provider/Errors.ts";	31	import type { ProviderServiceError } from "../../provider/Errors.ts";
32	import { TextGeneration } from "../../textGeneration/TextGeneration.ts";	32	import { TextGeneration } from "../../textGeneration/TextGeneration.ts";
33	import { ProviderService } from "../../provider/Services/ProviderService.ts";	33	import * as ProviderService from "../../provider/ProviderService.ts";
34	import { ProviderRegistry } from "../../provider/Services/ProviderRegistry.ts";	34	import * as ProviderRegistry from "../../provider/ProviderRegistry.ts";
35	import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";	35	import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";
36	import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts";	36	import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts";
37	import {	37	import {
@@ -190,8 +190,8 @@ const make = Effect.gen(function* () { · 152 unmodified lines
190	const crypto = yield* Crypto.Crypto;	190	const crypto = yield* Crypto.Crypto;
191	const orchestrationEngine = yield* OrchestrationEngineService;	191	const orchestrationEngine = yield* OrchestrationEngineService;
192	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;	192	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
193	const providerService = yield* ProviderService;	193	const providerService = yield* ProviderService.ProviderService;
194	const providerRegistry = yield* ProviderRegistry;	194	const providerRegistry = yield* ProviderRegistry.ProviderRegistry;
195	const gitWorkflow = yield* GitWorkflowService;	195	const gitWorkflow = yield* GitWorkflowService;
196	const vcsStatusBroadcaster = yield* VcsStatusBroadcaster;	196	const vcsStatusBroadcaster = yield* VcsStatusBroadcaster;
197	const textGeneration = yield* TextGeneration;	197	const textGeneration = yield* TextGeneration;

@@ -27,7 +27,7 @@ import * as Option from "effect/Option"; · 26 unmodified lines
27	import * as Stream from "effect/Stream";	27	import * as Stream from "effect/Stream";
28	import { makeDrainableWorker } from "@t3tools/shared/DrainableWorker";	28	import { makeDrainableWorker } from "@t3tools/shared/DrainableWorker";
29		29
30	import { ProviderService } from "../../provider/Services/ProviderService.ts";	30	import * as ProviderService from "../../provider/ProviderService.ts";
31	import { ProjectionTurnRepository } from "../../persistence/Services/ProjectionTurns.ts";	31	import { ProjectionTurnRepository } from "../../persistence/Services/ProjectionTurns.ts";
32	import { ProjectionTurnRepositoryLive } from "../../persistence/Layers/ProjectionTurns.ts";	32	import { ProjectionTurnRepositoryLive } from "../../persistence/Layers/ProjectionTurns.ts";
33	import { isGitRepository } from "../../git/Utils.ts";	33	import { isGitRepository } from "../../git/Utils.ts";
@@ -631,7 +631,7 @@ const make = Effect.gen(function* () { · 597 unmodified lines
631	const crypto = yield* Crypto.Crypto;	631	const crypto = yield* Crypto.Crypto;
632	const orchestrationEngine = yield* OrchestrationEngineService;	632	const orchestrationEngine = yield* OrchestrationEngineService;
633	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;	633	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
634	const providerService = yield* ProviderService;	634	const providerService = yield* ProviderService.ProviderService;
635	const projectionTurnRepository = yield* ProjectionTurnRepository;	635	const projectionTurnRepository = yield* ProjectionTurnRepository;
636	const serverSettingsService = yield* ServerSettingsService;	636	const serverSettingsService = yield* ServerSettingsService;
637	const providerCommandId = (event: ProviderRuntimeEvent, tag: string) =>	637	const providerCommandId = (event: ProviderRuntimeEvent, tag: string) =>

@@ -41,7 +41,7 @@ Effect.fn("name")( · 40 unmodified lines
41		41
42	## Suggested Order	42	## Suggested Order
43		43
44	- [ ] `apps/server/src/provider/Layers/ProviderService.ts`	44	- [ ] `apps/server/src/provider/ProviderService.ts`
45	- [x] `apps/server/src/provider/Layers/ClaudeAdapter.ts`	45	- [x] `apps/server/src/provider/Layers/ClaudeAdapter.ts`
46	- [x] `apps/server/src/provider/Layers/CodexAdapter.ts`	46	- [x] `apps/server/src/provider/Layers/CodexAdapter.ts`
47	- [x] `apps/server/src/git/Layers/GitCore.ts`	47	- [x] `apps/server/src/git/Layers/GitCore.ts`
@@ -98,20 +98,20 @@ Effect.fn("name")( · 50 unmodified lines
98	- [x] `Effect.forEach(..., entry => Effect.gen(...))` callbacks around `L305`	98	- [x] `Effect.forEach(..., entry => Effect.gen(...))` callbacks around `L305`
99	- [x] Remaining apply helpers in this file	99	- [x] Remaining apply helpers in this file
100		100
101	### `apps/server/src/provider/Layers/ProviderService.ts` (`24`)	101	### `apps/server/src/provider/ProviderService.ts` (`24`)
102		102
103	- [ ] [makeProviderService](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ProviderService.ts#L134)	103	- [ ] [makeProviderService](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/ProviderService.ts#L134)
104	- [ ] [recoverSessionForThread](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ProviderService.ts#L196)	104	- [ ] [recoverSessionForThread](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/ProviderService.ts#L196)
105	- [ ] [resolveRoutableSession](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ProviderService.ts#L255)	105	- [ ] [resolveRoutableSession](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/ProviderService.ts#L255)
106	- [ ] [startSession](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ProviderService.ts#L284)	106	- [ ] [startSession](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/ProviderService.ts#L284)
107	- [ ] [sendTurn](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ProviderService.ts#L347)	107	- [ ] [sendTurn](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/ProviderService.ts#L347)
108	- [ ] [interruptTurn](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ProviderService.ts#L393)	108	- [ ] [interruptTurn](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/ProviderService.ts#L393)
109	- [ ] [respondToRequest](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ProviderService.ts#L411)	109	- [ ] [respondToRequest](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/ProviderService.ts#L411)
110	- [ ] [respondToUserInput](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ProviderService.ts#L430)	110	- [ ] [respondToUserInput](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/ProviderService.ts#L430)
111	- [ ] [stopSession](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ProviderService.ts#L445)	111	- [ ] [stopSession](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/ProviderService.ts#L445)
112	- [ ] [listSessions](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ProviderService.ts#L466)	112	- [ ] [listSessions](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/ProviderService.ts#L466)
113	- [ ] [rollbackConversation](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ProviderService.ts#L516)	113	- [ ] [rollbackConversation](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/ProviderService.ts#L516)
114	- [ ] [runStopAll](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ProviderService.ts#L538)	114	- [ ] [runStopAll](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/ProviderService.ts#L538)
115		115
116	### `apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts` (`14`)	116	### `apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts` (`14`)
117		117
@@ -174,7 +174,7 @@ Effect.fn("name")( · 56 unmodified lines
174	- [ ] [packages/shared/src/DrainableWorker.ts](/Users/julius/Development/Work/codething-mvp/packages/shared/src/DrainableWorker.ts) (`4`)	174	- [ ] [packages/shared/src/DrainableWorker.ts](/Users/julius/Development/Work/codething-mvp/packages/shared/src/DrainableWorker.ts) (`4`)
175	- [ ] [apps/server/src/wsServer/pushBus.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/wsServer/pushBus.ts) (`4`)	175	- [ ] [apps/server/src/wsServer/pushBus.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/wsServer/pushBus.ts) (`4`)
176	- [ ] [apps/server/src/wsServer.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/wsServer.ts) (`4`)	176	- [ ] [apps/server/src/wsServer.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/wsServer.ts) (`4`)
177	- [ ] [apps/server/src/provider/Layers/ProviderRegistry.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ProviderRegistry.ts) (`4`)	177	- [ ] [apps/server/src/provider/ProviderRegistry.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/ProviderRegistry.ts) (`4`)
178	- [ ] [apps/server/src/persistence/Layers/Sqlite.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/persistence/Layers/Sqlite.ts) (`4`)	178	- [ ] [apps/server/src/persistence/Layers/Sqlite.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/persistence/Layers/Sqlite.ts) (`4`)
179	- [ ] [apps/server/src/orchestration/Layers/ProviderCommandReactor.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts) (`4`)	179	- [ ] [apps/server/src/orchestration/Layers/ProviderCommandReactor.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts) (`4`)
180	- [ ] [apps/server/src/main.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/main.ts) (`4`)	180	- [ ] [apps/server/src/main.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/main.ts) (`4`)
@@ -183,7 +183,7 @@ Effect.fn("name")( · 2 unmodified lines
183	- [ ] [apps/server/src/serverLayers.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/serverLayers.ts) (`3`)	183	- [ ] [apps/server/src/serverLayers.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/serverLayers.ts) (`3`)
184	- [ ] [apps/server/src/telemetry/Layers/AnalyticsService.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/telemetry/Layers/AnalyticsService.ts) (`2`)	184	- [ ] [apps/server/src/telemetry/Layers/AnalyticsService.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/telemetry/Layers/AnalyticsService.ts) (`2`)
185	- [ ] [apps/server/src/telemetry/Identify.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/telemetry/Identify.ts) (`2`)	185	- [ ] [apps/server/src/telemetry/Identify.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/telemetry/Identify.ts) (`2`)
186	- [ ] [apps/server/src/provider/Layers/ProviderAdapterRegistry.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts) (`2`)	186	- [ ] [apps/server/src/provider/ProviderAdapterRegistry.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/ProviderAdapterRegistry.ts) (`2`)
187	- [ ] [apps/server/src/provider/Layers/CodexProvider.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/CodexProvider.ts) (`2`)	187	- [ ] [apps/server/src/provider/Layers/CodexProvider.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/CodexProvider.ts) (`2`)
188	- [ ] [apps/server/src/provider/Layers/ClaudeProvider.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ClaudeProvider.ts) (`2`)	188	- [ ] [apps/server/src/provider/Layers/ClaudeProvider.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/provider/Layers/ClaudeProvider.ts) (`2`)
189	- [ ] [apps/server/src/persistence/NodeSqliteClient.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/persistence/NodeSqliteClient.ts) (`2`)	189	- [ ] [apps/server/src/persistence/NodeSqliteClient.ts](/Users/julius/Development/Work/codething-mvp/apps/server/src/persistence/NodeSqliteClient.ts) (`2`)