alchemy 2.0.0-beta.76 → 2.0.0-beta.77

package/src/Interaction.ts

@@ -0,0 +1,354 @@
+/**
+ * The engine's capability contract for talking to a human.
+ *
+ * `Interaction` is the narrow, presentation-free slice of terminal
+ * interaction that non-CLI code (auth flows, the state store, engine
+ * surfaces) may use: plain-string messages, a handful of prompt shapes,
+ * and `task`. Nothing in its vocabulary knows a renderer exists — the CLI
+ * provides an implementation backed by its terminal UI kit (see
+ * `Cli/CliKit/interaction.ts`), while every other process gets
+ * {@link layerNonInteractive}: messages render as plain status lines and
+ * every prompt fails with the typed {@link NonInteractiveTerminal}.
+ *
+ * Child processes (the RPC sidecar, spawned dev children) deliberately do
+ * NOT provide this service at all — interaction capability is structural,
+ * not configured. Code that might need a human declares it; a process that
+ * cannot reach one simply doesn't have the service in its graph.
+ */
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { ChildProcess } from "effect/unstable/process";
+import { UserFacingError } from "./UserFacingError.ts";
+import {
+  ANSI_DIM,
+  ANSI_RESET,
+  ansiFg,
+  colorsEnabled,
+} from "./Util/Terminal.ts";
+import { glyphsFor, statusColor, type StatusVariant } from "./Util/Theme.ts";
+import { unicodeEnabled } from "./Util/Terminal.ts";
+
+/** The user dismissed the active terminal interaction. */
+export class TerminalCancelled extends Data.TaggedError("TerminalCancelled") {}
+
+/** An interactive operation was requested without an interactive terminal. */
+export class NonInteractiveTerminal extends Data.TaggedError(
+  "NonInteractiveTerminal",
+)<{
+  readonly operation: string;
+  readonly message: string;
+}> {
+  readonly [UserFacingError] = true;
+}
+
+/** The platform's browser launcher exited unsuccessfully. */
+export class BrowserOpenFailed extends Data.TaggedError("BrowserOpenFailed")<{
+  readonly command: string;
+  readonly exitCode: number;
+}> {}
+
+export type InteractionError = TerminalCancelled | NonInteractiveTerminal;
+
+export interface MessageOptions {
+  readonly message: string;
+  readonly detail?: string;
+}
+
+export interface TextInputOptions {
+  readonly message: string;
+  /** Secondary guidance rendered beneath the field in muted text. */
+  readonly description?: string;
+  /** Place the editable field beside the message or beneath it. @default "inline" */
+  readonly layout?: "inline" | "stacked";
+  readonly placeholder?: string;
+  readonly initialValue?: string;
+  readonly defaultValue?: string;
+  readonly validate?: (value: string) => string | Error | undefined;
+}
+
+export interface PasswordInputOptions extends Omit<
+  TextInputOptions,
+  "initialValue" | "defaultValue"
+> {}
+
+export interface ConfirmOptions {
+  readonly message: string;
+  readonly initialValue?: boolean;
+  readonly confirmLabel?: string;
+  readonly cancelLabel?: string;
+}
+
+export interface Choice<Value> {
+  readonly value: Value;
+  readonly label: string;
+  /** Optional section heading shared by adjacent choices. */
+  readonly group?: string;
+  /** Indent the entire rendered row, including its selection indicator. */
+  readonly indent?: number;
+  /** Keep this row visible as the heading for following rows while scrolling. */
+  readonly sticky?: boolean;
+  /** Visually distinguish structural rows from ordinary choices. */
+  readonly tone?: "info";
+  readonly description?: string;
+  readonly disabled?: boolean | string;
+}
+
+export interface SelectOptions<Value> {
+  readonly message: string;
+  readonly options: ReadonlyArray<Choice<Value>>;
+  readonly initialValue?: Value;
+  readonly visibleCount?: number;
+  /** Allow typing to filter choices by label and description. */
+  readonly searchable?: boolean;
+  /** Place descriptions beside labels instead of on a second line. */
+  readonly descriptionPlacement?: "below" | "inline";
+}
+
+export interface MultiSelectOptions<Value> extends Omit<
+  SelectOptions<Value>,
+  "initialValue"
+> {
+  readonly initialValues?: ReadonlyArray<Value>;
+  readonly required?: boolean;
+}
+
+export interface AwaitExternalOptions {
+  readonly message: string;
+  readonly waitingLabel: string;
+  readonly url?: string;
+  /** Short code the user must enter on the authorization page. */
+  readonly code?: string;
+  readonly openFailed?: boolean;
+  /** Open the authorization URL again from the waiting screen. */
+  readonly onOpen?: () => Promise<void>;
+  /** Allow Enter to switch to manual code entry. @default true */
+  readonly allowManualInput?: boolean;
+  readonly inputLabel?: string;
+  readonly placeholder?: string;
+  readonly validate?: (value: string) => string | Error | undefined;
+}
+
+export interface ProgressOptions {
+  readonly label: string;
+  readonly detail?: string;
+  /** Terminal window title while this progress view is active. */
+  readonly title?: string;
+  /** Animate the leading status glyph. @default true */
+  readonly spinning?: boolean;
+}
+
+/**
+ * The capability to ask or tell the human driving this process. Provided
+ * by the CLI (terminal-backed) or {@link layerNonInteractive} (plain
+ * output, typed prompt failures); never provided in child processes.
+ */
+export class Interaction extends Context.Service<
+  Interaction,
+  {
+    readonly output: {
+      readonly info: (message: string | MessageOptions) => Effect.Effect<void>;
+      readonly success: (
+        message: string | MessageOptions,
+      ) => Effect.Effect<void>;
+      readonly warning: (
+        message: string | MessageOptions,
+      ) => Effect.Effect<void>;
+      readonly error: (message: string | MessageOptions) => Effect.Effect<void>;
+    };
+
+    readonly prompt: {
+      readonly text: (
+        options: TextInputOptions,
+      ) => Effect.Effect<string, InteractionError>;
+      readonly password: (
+        options: PasswordInputOptions,
+      ) => Effect.Effect<string, InteractionError>;
+      readonly confirm: (
+        options: ConfirmOptions,
+      ) => Effect.Effect<boolean, InteractionError>;
+      readonly select: <Value>(
+        options: SelectOptions<Value>,
+      ) => Effect.Effect<Value, InteractionError>;
+      readonly multiSelect: <Value>(
+        options: MultiSelectOptions<Value>,
+      ) => Effect.Effect<ReadonlyArray<Value>, InteractionError>;
+      readonly awaitExternal: (
+        options: AwaitExternalOptions,
+      ) => Effect.Effect<string, InteractionError>;
+    };
+
+    /** Run work behind a progress row and collapse it to a final status line. */
+    readonly task: <A, E, R>(
+      options: ProgressOptions,
+      effect: Effect.Effect<A, E, R>,
+    ) => Effect.Effect<A, E, R>;
+  }
+>()("Alchemy::Interaction") {}
+
+/** Effectful service accessors for code that must defer acquisition to use time. */
+export const accessors = {
+  output: {
+    info: (message: string | MessageOptions) =>
+      Effect.flatMap(Interaction, (service) => service.output.info(message)),
+    success: (message: string | MessageOptions) =>
+      Effect.flatMap(Interaction, (service) => service.output.success(message)),
+    warning: (message: string | MessageOptions) =>
+      Effect.flatMap(Interaction, (service) => service.output.warning(message)),
+    error: (message: string | MessageOptions) =>
+      Effect.flatMap(Interaction, (service) => service.output.error(message)),
+  },
+  prompt: {
+    text: (options: TextInputOptions) =>
+      Effect.flatMap(Interaction, (service) => service.prompt.text(options)),
+    password: (options: PasswordInputOptions) =>
+      Effect.flatMap(Interaction, (service) =>
+        service.prompt.password(options),
+      ),
+    confirm: (options: ConfirmOptions) =>
+      Effect.flatMap(Interaction, (service) => service.prompt.confirm(options)),
+    select: <Value>(options: SelectOptions<Value>) =>
+      Effect.flatMap(Interaction, (service) => service.prompt.select(options)),
+    multiSelect: <Value>(options: MultiSelectOptions<Value>) =>
+      Effect.flatMap(Interaction, (service) =>
+        service.prompt.multiSelect(options),
+      ),
+  },
+};
+
+/**
+ * Open a URL in the platform's default browser without invoking a shell.
+ *
+ * Fails with {@link BrowserOpenFailed} when the launcher exits non-zero (e.g.
+ * `xdg-open` with no handler installed). Some `xdg-open` configurations block
+ * until the browser itself exits — a launcher still running after a short
+ * grace period is treated as a successful launch rather than awaited.
+ */
+export const openUrl = (url: string) =>
+  Effect.gen(function* () {
+    const [command, args] =
+      process.platform === "win32"
+        ? (["rundll32.exe", ["url.dll,FileProtocolHandler", url]] as const)
+        : process.platform === "darwin"
+          ? (["open", [url]] as const)
+          : (["xdg-open", [url]] as const);
+    const handle = yield* ChildProcess.make(command, [...args], {
+      shell: false,
+    });
+    const exitCode = yield* handle.exitCode.pipe(
+      Effect.timeoutOption("3 seconds"),
+    );
+    if (Option.isSome(exitCode) && exitCode.value !== 0) {
+      return yield* Effect.fail(
+        new BrowserOpenFailed({ command, exitCode: exitCode.value }),
+      );
+    }
+  }).pipe(Effect.scoped);
+
+export interface NonInteractiveOptions {
+  readonly stdout?: NodeJS.WriteStream;
+  readonly colors?: boolean;
+  readonly unicode?: boolean;
+}
+
+const makeNonInteractive = (
+  options: NonInteractiveOptions,
+): Interaction["Service"] => {
+  const stdout = options.stdout ?? process.stdout;
+  const colors = options.colors ?? colorsEnabled(stdout);
+  const glyphs = glyphsFor(options.unicode ?? unicodeEnabled());
+
+  const colorize = (hex: string, value: string) =>
+    colors ? `${ansiFg(hex)}${value}${ANSI_RESET}` : value;
+  const muted = (value: string) =>
+    colors ? `${ANSI_DIM}${value}${ANSI_RESET}` : value;
+
+  // Plain-string equivalent of the CLI's `Status` component: colored glyph,
+  // the message (painted for errors), and a muted `· detail` suffix.
+  const statusText = (
+    variant: StatusVariant,
+    message: string,
+    detail?: string,
+  ) => {
+    const glyph = colorize(statusColor(variant), glyphs[variant]);
+    const body =
+      variant === "error" ? colorize(statusColor(variant), message) : message;
+    return `${glyph} ${body}${detail === undefined ? "" : ` ${muted(`· ${detail}`)}`}`;
+  };
+
+  const log = (variant: StatusVariant) => (message: string | MessageOptions) =>
+    Effect.sync(() => {
+      const { message: text, detail } =
+        typeof message === "string" ? { message } : message;
+      stdout.write(`${statusText(variant, text, detail)}\n`);
+    });
+
+  const unavailable = (operation: string) =>
+    Effect.fail(
+      new NonInteractiveTerminal({
+        operation,
+        message: `Cannot run ${operation} without an interactive terminal. Provide the equivalent command flags instead.`,
+      }),
+    );
+
+  return {
+    output: {
+      info: log("info"),
+      success: log("success"),
+      warning: log("warning"),
+      error: log("error"),
+    },
+    prompt: {
+      text: () => unavailable("text input"),
+      password: () => unavailable("password input"),
+      confirm: () => unavailable("confirmation"),
+      select: () => unavailable("selection"),
+      multiSelect: () => unavailable("multiple selection"),
+      awaitExternal: () => unavailable("external authorization"),
+    },
+    task: (taskOptions, effect) =>
+      Effect.suspend(() => {
+        let settled = false;
+        const settle = (variant: "success" | "error", message?: string) =>
+          Effect.suspend(() => {
+            if (settled) return Effect.void;
+            settled = true;
+            return log(variant)(message ?? taskOptions.label);
+          });
+        return log("info")({
+          message: taskOptions.label,
+          detail: taskOptions.detail,
+        }).pipe(
+          Effect.andThen(
+            effect.pipe(
+              Effect.onExit((exit) =>
+                Exit.isSuccess(exit)
+                  ? settle("success")
+                  : // Interruption (Ctrl+C) is not a failure — leave the row
+                    // unsettled instead of painting a red error status.
+                    Cause.hasInterruptsOnly(exit.cause)
+                    ? Effect.void
+                    : settle("error"),
+              ),
+            ),
+          ),
+        );
+      }),
+  };
+};
+
+/**
+ * The default Interaction for processes without a terminal renderer: the
+ * programmatic engine API, tests, and any headless embedding. Messages
+ * print as plain status lines; every prompt fails immediately with the
+ * typed {@link NonInteractiveTerminal}.
+ */
+export const layerNonInteractive = (options: NonInteractiveOptions = {}) =>
+  Layer.effect(
+    Interaction,
+    Effect.sync(() => makeNonInteractive(options)),
+  );

package/src/Kubernetes/ClusterAdapter.ts

@@ -164,11 +164,10 @@ export interface WorkloadImageSource {
   main?: string;
   handler?: string;
   /**
-   * Bundler configuration for `main`: rolldown `input`/`output` overrides
-   * plus pure-annotation options (`pure`). `effect`, `@effect/*`,
-   * `alchemy`, `@alchemy.run/*`, and `@distilled.cloud/*` are annotated as
-   * pure by default so unused code from those packages is tree-shaken; list
-   * additional packages via `pure.packages`, or disable with `pure: false`.
+   * Bundler configuration for `main`. Unused code is tree-shaken.
+   * `effect`, alchemy, and `@distilled.cloud` are marked pure so unused
+   * parts prune more aggressively. List extra packages with
+   * `pure.packages`, or disable with `pure: false`.
    */
   build?: Bundle.BundleConfig;
   context?: string;

package/src/Kubernetes/Deployment.ts

@@ -355,16 +355,13 @@ export interface DeploymentRuntimeContext extends HostRuntimeContext {
  * ```
  *
  * ### Bundling & Tree-shaking
- * `main` is bundled with rolldown at deploy time. Top-level calls in the
- * `effect`, `@effect/*`, `alchemy`, `@alchemy.run/*`, and
- * `@distilled.cloud/*` packages receive `#__PURE__` annotations by
- * default, so anything the deployment doesn't use from those packages is
- * tree-shaken out of the bundle. Any other package — including your own
- * app — is left untouched unless you list it explicitly.
+ * `main` is bundled with rolldown at deploy time. Unused code is
+ * tree-shaken. `effect`, alchemy, and `@distilled.cloud` are marked
+ * pure so unused parts prune more aggressively. Your app is not
+ * marked pure.
  *
- * **Example:** Treat additional packages as pure
- * Pass package names (or picomatch globs) via `build.pure.packages` to
- * annotate them in addition to the defaults.
+ * **Example:** Mark additional packages as pure
+ * Only list packages with no top-level side effects.
  * ```typescript
  * {
  *   main: import.meta.url,
@@ -374,18 +371,7 @@ export interface DeploymentRuntimeContext extends HostRuntimeContext {
  * }
  * ```
  *
- * Listing a package annotates calls whose result is bound (variable
- * initializers, exports) — safe anywhere. If a listed package also
- * declares `"sideEffects": false` (or `[]`) in its `package.json`, that
- * combination opts it into full annotation: top-level calls whose result
- * is discarded (e.g. `router.on("/path", handler)` registrations) are
- * also marked pure and deleted under minification when unused. Only list
- * a `sideEffects: false` package if its modules really are free of
- * meaningful top-level side effects. The `effect`, `alchemy`, and
- * `@distilled.cloud` defaults declare exactly that, on purpose — their
- * modules are designed to be fully tree-shakeable.
- *
- * **Example:** Disable pure annotations
+ * **Example:** Turn it off
  * ```typescript
  * {
  *   main: import.meta.url,

package/src/Kubernetes/Job.ts

@@ -315,16 +315,13 @@ export interface JobRuntimeContext extends HostRuntimeContext {
  * ```
  *
  * ### Bundling & Tree-shaking
- * `main` is bundled with rolldown at deploy time. Top-level calls in the
- * `effect`, `@effect/*`, `alchemy`, `@alchemy.run/*`, and
- * `@distilled.cloud/*` packages receive `#__PURE__` annotations by
- * default, so anything the job doesn't use from those packages is
- * tree-shaken out of the bundle. Any other package — including your own
- * app — is left untouched unless you list it explicitly.
+ * `main` is bundled with rolldown at deploy time. Unused code is
+ * tree-shaken. `effect`, alchemy, and `@distilled.cloud` are marked
+ * pure so unused parts prune more aggressively. Your app is not
+ * marked pure.
  *
- * **Example:** Treat additional packages as pure
- * Pass package names (or picomatch globs) via `build.pure.packages` to
- * annotate them in addition to the defaults.
+ * **Example:** Mark additional packages as pure
+ * Only list packages with no top-level side effects.
  * ```typescript
  * {
  *   main: import.meta.url,
@@ -334,18 +331,7 @@ export interface JobRuntimeContext extends HostRuntimeContext {
  * }
  * ```
  *
- * Listing a package annotates calls whose result is bound (variable
- * initializers, exports) — safe anywhere. If a listed package also
- * declares `"sideEffects": false` (or `[]`) in its `package.json`, that
- * combination opts it into full annotation: top-level calls whose result
- * is discarded (e.g. `router.on("/path", handler)` registrations) are
- * also marked pure and deleted under minification when unused. Only list
- * a `sideEffects: false` package if its modules really are free of
- * meaningful top-level side effects. The `effect`, `alchemy`, and
- * `@distilled.cloud` defaults declare exactly that, on purpose — their
- * modules are designed to be fully tree-shakeable.
- *
- * **Example:** Disable pure annotations
+ * **Example:** Turn it off
  * ```typescript
  * {
  *   main: import.meta.url,

package/src/Local/DevLog.ts

@@ -0,0 +1,135 @@
+/**
+ * Per-resource dev log files.
+ *
+ * Layout under `{dotAlchemy}/log`:
+ *
+ *   log/{stage}/{fqn…}/{timestamp}.log        — one file per instance start
+ *                                               (a restart opens a new file;
+ *                                               the FQN nests as directories,
+ *                                               e.g. log/dev/Site/Worker/)
+ *   log/{stage}/{timestamp}.log               — the dev child's mixed tail
+ *
+ * Retention: opening a new log prunes its sibling `*.log` files first — the
+ * newest `LOG_RETENTION_GENERATIONS` survive, and anything older than
+ * `LOG_RETENTION_MS` (7 days, judged by stat mtime — file names are never
+ * trusted) is deleted regardless. Pruning is best-effort: any failure is
+ * swallowed so it can never break dev startup.
+ */
+import * as Clock from "effect/Clock";
+import * as Effect from "effect/Effect";
+import * as Duration from "effect/Duration";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Queue from "effect/Queue";
+import * as Stream from "effect/Stream";
+import { AlchemyContext } from "../AlchemyContext.ts";
+import { stripVTControlCharacters } from "node:util";
+
+const LOG_RETENTION = Duration.days(7);
+const LOG_RETENTION_GENERATIONS = 10;
+
+/**
+ * Delete a resource's stale sibling logs before a new one is opened: keep
+ * the newest `LOG_RETENTION_GENERATIONS - 1` (the file about to be created
+ * fills the last slot) and drop anything older than `LOG_RETENTION_MS`.
+ * Ages come from stat mtime — file names are never trusted. Best-effort:
+ * every step (including a missing directory) is swallowed.
+ */
+const pruneDevLogs = (
+  fs: FileSystem.FileSystem,
+  path: Path.Path,
+  dir: string,
+): Effect.Effect<void> =>
+  Effect.gen(function* () {
+    const entries = yield* fs
+      .readDirectory(dir)
+      .pipe(Effect.orElseSucceed(() => [] as Array<string>));
+    const logs: Array<{ file: string; mtime: number }> = [];
+    for (const entry of entries) {
+      if (!entry.endsWith(".log")) continue;
+      const file = path.join(dir, entry);
+      const info = yield* fs
+        .stat(file)
+        .pipe(Effect.orElseSucceed(() => undefined));
+      const mtime =
+        info === undefined ? undefined : Option.getOrUndefined(info.mtime);
+      if (mtime !== undefined) logs.push({ file, mtime: mtime.getTime() });
+    }
+    const cutoff =
+      (yield* Clock.currentTimeMillis) - Duration.toMillis(LOG_RETENTION);
+    logs.sort((a, b) => b.mtime - a.mtime);
+    for (const [index, log] of logs.entries()) {
+      if (index >= LOG_RETENTION_GENERATIONS - 1 || log.mtime < cutoff) {
+        yield* fs.remove(log.file).pipe(Effect.ignore);
+      }
+    }
+  }).pipe(Effect.ignore);
+
+/**
+ * Resolves the directory a resource's dev logs land in, for surfacing in
+ * startup messages ("Started … → url (logs: …)") without opening a file.
+ * Must join the same segments the opener is later called with.
+ */
+export const makeDevLogDirectory = Effect.gen(function* () {
+  const path = yield* Path.Path;
+  const { dotAlchemy } = yield* AlchemyContext;
+  return (...segments: ReadonlyArray<string>) =>
+    path.join(dotAlchemy, "log", ...segments);
+});
+
+/**
+ * Resolves the file-system services once (at provider/process init) and
+ * returns an opener whose only requirement is the ambient `Scope` — local
+ * provider `start` signatures are Scope-only, so the opener composes into
+ * them without widening their requirements.
+ *
+ * The opener creates `{dotAlchemy}/log/{...segments}/{timestamp}.log`
+ * (pruning stale siblings per the module retention policy first) and
+ * returns the file's `path` plus synchronous `write`/`writeLine` sinks —
+ * chunks queue through a drain fiber, so they're safe to call from
+ * non-Effect callbacks (workerd output pumps, stream mirrors). The file and
+ * drain close with the scope, which ties one log file to one
+ * process/serve generation.
+ */
+export const makeDevLogOpener = Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const devLogDirectory = yield* makeDevLogDirectory;
+  const encoder = new TextEncoder();
+
+  return Effect.fn(function* (...segments: ReadonlyArray<string>) {
+    const dir = devLogDirectory(...segments);
+    yield* fs.makeDirectory(dir, { recursive: true });
+    yield* pruneDevLogs(fs, path, dir);
+    const name = yield* Effect.sync(
+      () => `${new Date().toISOString().replaceAll(":", "-")}.log`,
+    );
+    const filePath = path.join(dir, name);
+    const file = yield* fs.open(filePath, { flag: "a" });
+    const queue = yield* Queue.make<Uint8Array>();
+    yield* Stream.fromQueue(queue).pipe(
+      Stream.runForEach((chunk) => file.write(chunk).pipe(Effect.ignore)),
+      Effect.forkScoped,
+    );
+    // ANSI is stripped: colors belong to the terminal path (FORCE_COLOR
+    // rides the sidecar pipes); the files stay plain-text grep-able.
+    return {
+      /** Absolute path of this generation's log file. */
+      path: filePath,
+      write: (chunk: string): void => {
+        Queue.offerUnsafe(
+          queue,
+          encoder.encode(stripVTControlCharacters(chunk)),
+        );
+      },
+      /** `write` + a trailing newline — for line-based sources. */
+      writeLine: (line: string): void => {
+        Queue.offerUnsafe(
+          queue,
+          encoder.encode(`${stripVTControlCharacters(line)}\n`),
+        );
+      },
+    };
+  });
+});

package/src/Local/LocalProvider.ts

@@ -6,7 +6,7 @@ import * as Fiber from "effect/Fiber";
 import * as Redacted from "effect/Redacted";
 import * as Scope from "effect/Scope";
 import * as Semaphore from "effect/Semaphore";
-import type { ScopedPlanStatusSession } from "../Cli/Cli.ts";
+import type { ScopedPlanStatusSession } from "../Report.ts";
 import { isResolved, stripEffects, type Diff } from "../Diff.ts";
 import type { Platform } from "../Platform.ts";
 import type { ProviderService } from "../Provider.ts";
@@ -456,7 +456,7 @@ export const make = <
               if (existing) {
                 if (existing.configHash === configHash) {
                   yield* Effect.log(
-                    `[${id}] No changes, using existing instance`,
+                    `[${fqn}] No changes, using existing instance`,
                   );
                   // Adopt the newest instanceId so a later replacement's
                   // old-generation delete cannot tear this instance down.
@@ -464,7 +464,7 @@ export const make = <
                   return yield* Fiber.join(existing.fiber);
                 }
                 yield* Effect.log(
-                  `[${id}] Changes detected, restarting instance`,
+                  `[${fqn}] Changes detected, restarting instance`,
                 );
                 yield* teardown(existing);
                 instances.delete(fqn);

package/src/Local/RpcServer.ts

@@ -3,8 +3,10 @@ import * as Context from "effect/Context";
 import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
 import type * as Scope from "effect/Scope";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import { makePlainConsoleSink } from "../Util/ConsoleSink.ts";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
 import { ArtifactStore, createArtifactStore } from "../Artifacts.ts";
 import type { ProviderService } from "../Provider.ts";
@@ -214,6 +216,15 @@ export const launch = <ROut, E>(
         Layer.sync(ArtifactStore, createArtifactStore),
       ),
     ),
+    // Sidecar stdio is piped, so effect's default pretty logger disables
+    // colors (it only checks `isTTY`, never FORCE_COLOR). The spawner sets
+    // FORCE_COLOR exactly when the destination terminal supports color —
+    // honor it here so sidecar log lines match the rest of the dev output.
+    Layer.provide(
+      process.env.FORCE_COLOR
+        ? Logger.layer([makePlainConsoleSink(true)])
+        : Layer.empty,
+    ),
     Layer.launch,
     Effect.scoped,
     runMain,

package/src/Local/RpcServerEnvironment.ts

@@ -6,7 +6,8 @@ import * as Option from "effect/Option";
 import { AlchemyContext } from "../AlchemyContext.ts";
 import { AuthProviders } from "../Auth/AuthProvider.ts";
 import { CredentialsStoreLive } from "../Auth/Credentials.ts";
-import { ProfileLive, withProfileOverride } from "../Auth/Profile.ts";
+import { ProfileStoreLive } from "../Auth/Profile.ts";
+import { withProfileOverride } from "../Auth/Resolve.ts";
 import { Stack } from "../Stack.ts";
 import { Stage } from "../Stage.ts";
 import { loadConfigProvider } from "../Util/ConfigProvider.ts";
@@ -57,7 +58,7 @@ export const layer = (
     SessionEnvironment,
 ) =>
   Layer.mergeAll(
-    ProfileLive,
+    ProfileStoreLive,
     CredentialsStoreLive,
     Layer.succeed(AuthProviders, {}),
     ConfigProvider.layer(