@pmelab/gtd 63.0.0 → 64.1.0

package/src/install/Version.ts

@@ -1,9 +1,4 @@
-import { existsSync } from "node:fs"
-import { createRequire } from "node:module"
-import { dirname, join } from "node:path"
-import { fileURLToPath } from "node:url"
-
-const _require = createRequire(import.meta.url)
+import { NodeRuntime, nodeSyncIo } from "../platform/index.js"
 
 // A source-relative literal (`../../package.json`) breaks the built single-file
 // bundle: bundling doesn't rewrite `import.meta.url` per original module, so a
@@ -11,13 +6,19 @@ const _require = createRequire(import.meta.url)
 // dist/ vs src/ — they differ (dist/gtd.bundle.mjs is always one level below
 // repo root; src/install/Version.ts is two). Walking up from wherever this module
 // actually runs from resolves correctly in both the unbundled (vitest/tsc) and
-// bundled (dist/gtd.bundle.mjs) case.
-const findPackageJson = (fromUrl: string): string => {
-  let dir = dirname(fileURLToPath(fromUrl))
+// bundled (dist/gtd.bundle.mjs) case. URLs, not Path: this runs at import,
+// before any Effect service exists.
+const readPackageJson = (fromUrl: string): string => {
+  let dir = new URL(".", fromUrl)
   for (let i = 0; i < 5; i++) {
-    const candidate = join(dir, "package.json")
-    if (existsSync(candidate)) return candidate
-    dir = dirname(dir)
+    const candidate = new URL("package.json", dir)
+    try {
+      const source = nodeSyncIo.readText(NodeRuntime.fileURLToPath(candidate))
+      if (source !== undefined) return source
+    } catch {
+      // Unreadable counts as absent, as it did for `existsSync`.
+    }
+    dir = new URL("..", dir)
   }
   throw new Error(`package.json not found by walking up from ${fromUrl}`)
 }
@@ -30,4 +31,4 @@ export const PIN_KEY = Symbol.for("@pmelab/gtd/pin")
 const pinned = (globalThis as { [PIN_KEY]?: { readonly version: string } })[PIN_KEY]?.version
 
 export const GTD_VERSION: string =
-  pinned ?? (_require(findPackageJson(import.meta.url)) as { version: string }).version
+  pinned ?? (JSON.parse(readPackageJson(import.meta.url)) as { version: string }).version

package/src/platform/Host.ts

@@ -1,6 +1,6 @@
-import { realpathSync } from "node:fs"
-import { homedir, tmpdir } from "node:os"
 import { Context, Effect, Layer } from "effect"
+import { homedir, tmpdir } from "./NodeRuntime.js"
+import { nodeSyncIo } from "./NodeSync.js"
 
 const toError = (e: unknown): Error => (e instanceof Error ? e : new Error(String(e)))
 
@@ -8,35 +8,88 @@ export interface HostOps {
   readonly root: string
   readonly home: string
   readonly env: Readonly<Record<string, string | undefined>>
-  /** `env["TMPDIR"]` when set, `node:os`'s `tmpdir()` otherwise — never a `/tmp` literal or `mktemp` (`tests/tooling/no-tmp-assumption.test.ts` scans for both). */
+  /** `env["TMPDIR"]` when set, the host's temp dir otherwise — never a `/tmp` literal or `mktemp` (`tests/tooling/no-tmp-assumption.test.ts` scans for both). */
   readonly scratchDir: string
   /** The real, symlink-resolved form of `path` — used to compare a possibly-symlinked cwd (macOS `/tmp` → `/private/tmp`) against git's own resolution. */
   readonly realPath: (path: string) => Effect.Effect<string, Error>
+  /** Carried by every scratch or temp file name, so concurrent gtd runs never share one. */
+  readonly pid: number
+  /** `undefined` where the platform has no POSIX user ids. */
+  readonly uid: number | undefined
+  /** The command that runs this gtd again: its script under the running runtime, or `gtd` off `PATH` when there is none. */
+  readonly self: readonly [string, ...string[]]
+  /** Standard input read to its end, as UTF-8. */
+  readonly stdin: Effect.Effect<string, Error>
 }
 
-interface HostOpsInput {
-  readonly root: string
-  readonly home: string
-  readonly env: Readonly<Record<string, string | undefined>>
-  readonly scratchDir?: string
-  readonly realPath?: (path: string) => Effect.Effect<string, Error>
+/** The output half of the process's stdio, which the CLI writes before any layer is built. */
+export interface Stdio {
+  readonly stdout: (chunk: string | Uint8Array) => void
+  readonly stderr: (chunk: string) => void
+  readonly exit: (code: number) => void
+}
+
+/** The slice of Node's `process` the live host reads; a contract test hands in a fake one. */
+export type NodeProcess = Pick<
+  NodeJS.Process,
+  "argv" | "execPath" | "pid" | "getuid" | "stdin" | "stdout" | "stderr" | "exitCode"
+>
+
+type HostOpsInput = Pick<HostOps, "root" | "home" | "env"> & Partial<HostOps>
+
+/** `TMPDIR` when set and non-empty, else the host's own `fallback`. */
+export const scratchDirOf = (env: HostOps["env"], fallback: string): string => {
+  const dir = env["TMPDIR"]
+  return dir !== undefined && dir.length > 0 ? dir : fallback
+}
+
+const readAll = (stream: AsyncIterable<Buffer | string>): Effect.Effect<string, Error> =>
+  Effect.tryPromise({
+    try: async () => {
+      const chunks: Buffer[] = []
+      for await (const chunk of stream) chunks.push(Buffer.from(chunk))
+      return Buffer.concat(chunks).toString("utf8")
+    },
+    catch: toError,
+  })
+
+const makeHostOps = (opts: HostOpsInput, proc: NodeProcess): HostOps => {
+  const script = proc.argv[1]
+  return {
+    scratchDir: scratchDirOf(opts.env, tmpdir()),
+    realPath: (path: string) =>
+      Effect.try({ try: () => nodeSyncIo.realPath(path), catch: toError }),
+    pid: proc.pid,
+    uid: proc.getuid?.(),
+    self: script === undefined ? ["gtd"] : [proc.execPath, script],
+    // Lazy: touching `process.stdin` opens it, which the LSP and the pin hand-over must not see.
+    stdin: Effect.suspend(() => readAll(proc.stdin)),
+    ...opts,
+  }
 }
 
-const makeHostOps = (opts: HostOpsInput): HostOps => ({
-  root: opts.root,
-  home: opts.home,
-  env: opts.env,
-  scratchDir:
-    opts.scratchDir ??
-    (opts.env["TMPDIR"] !== undefined && opts.env["TMPDIR"]!.length > 0
-      ? opts.env["TMPDIR"]!
-      : tmpdir()),
-  realPath:
-    opts.realPath ??
-    ((path: string) => Effect.try({ try: () => realpathSync(path), catch: toError })),
+export const nodeStdio = (proc: NodeProcess = process): Stdio => ({
+  // `stdout.write` is asynchronous whenever stdout is a pipe or socket —
+  // passing a completion callback (and never force-closing, see `exit`
+  // below) keeps a queued remainder from being discarded, so a large
+  // artifact still reaches a slow reader even after a non-zero exit.
+  stdout: (chunk) => {
+    proc.stdout.write(chunk, () => {})
+  },
+  stderr: (chunk) => {
+    proc.stderr.write(chunk)
+  },
+  // Never `process.exit(code)`: that tears the process down out from under
+  // an undrained `stdout.write` above and truncates the artifact mid-pipe.
+  // Setting `exitCode` lets the event loop drain any queued write first.
+  exit: (code) => {
+    proc.exitCode = code
+  },
 })
 
+/** Every member not given in `opts` comes from Node: `proc`, its OS and its file system. */
 export class Host extends Context.Service<Host, HostOps>()("Host") {
-  static layer = (opts: HostOpsInput): Layer.Layer<Host> => Layer.succeed(Host, makeHostOps(opts))
+  static layer = (opts: HostOpsInput, proc: NodeProcess = process): Layer.Layer<Host> =>
+    Layer.succeed(Host, makeHostOps(opts, proc))
   static Live = Host.layer({ root: process.cwd(), home: homedir(), env: process.env })
 }

package/src/platform/NodePinFile.ts

@@ -0,0 +1,44 @@
+import { registerHooks } from "node:module"
+import { join } from "node:path"
+import { pathToFileURL } from "node:url"
+import { nodeSyncIo } from "./NodeSync.js"
+import type { PinFile } from "./PinFile.js"
+
+// `cwd`, as the engine's own root is: gtd runs only at the worktree root, and
+// a relocated `$GIT_DIR` leaves no `.git` to walk up to. A file that cannot be
+// read counts as no pin, so the launcher refuses it rather than crashing.
+export const livePinFile =
+  (cwd: string, path: string): PinFile =>
+  () => {
+    const file = join(cwd, path)
+    try {
+      const bytes = nodeSyncIo.readFile(file)
+      if (bytes !== undefined) return { path: file, bytes }
+    } catch {
+      return { path: file, bytes: new Uint8Array() }
+    }
+    try {
+      return { path: file, bytes: nodeSyncIo.gitBytes(cwd, ["show", `HEAD:${path}`]) }
+    } catch {
+      return undefined
+    }
+  }
+
+/**
+ * Runs a pin's module as this process's main program. Node refuses an unknown
+ * extension, so a load hook serves the unpacked source under the pin's own
+ * URL — `import.meta.url` stays a file in the repository.
+ */
+export const runPinModule = async (path: string, source: string): Promise<void> => {
+  const url = pathToFileURL(path).href
+  // A pin read from HEAD has no file behind its URL, which Node's own resolve refuses.
+  registerHooks({
+    resolve: (specifier, context, nextResolve) =>
+      specifier === url ? { url, shortCircuit: true } : nextResolve(specifier, context),
+    load: (requested, context, nextLoad) =>
+      requested === url
+        ? { format: "module", source, shortCircuit: true }
+        : nextLoad(requested, context),
+  })
+  await import(url)
+}

package/src/platform/NodeRuntime.ts

@@ -0,0 +1,19 @@
+import { createRequire, isBuiltin } from "node:module"
+import { homedir, tmpdir } from "node:os"
+import { fileURLToPath } from "node:url"
+import { stripVTControlCharacters } from "node:util"
+import { runInThisContext } from "node:vm"
+import { gunzipSync, gzipSync } from "node:zlib"
+
+// What the core needs of Node beyond the sync port: module loading, the
+// user's directories, file URLs and gzip. Each is a Node fact with no in-memory twin.
+
+export { createRequire, fileURLToPath, homedir, isBuiltin, stripVTControlCharacters, tmpdir }
+
+export const gzip = (source: string): Uint8Array => gzipSync(source, { level: 9 })
+
+export const gunzip = (bytes: Uint8Array): string => gunzipSync(bytes).toString("utf8")
+
+/** Compiles `source` as a script in this realm, reporting errors against `filename`. */
+export const compileScript = (source: string, filename: string): unknown =>
+  runInThisContext(source, { filename })

package/src/platform/NodeSync.ts

@@ -0,0 +1,64 @@
+import { execFileSync } from "node:child_process"
+import { createHash } from "node:crypto"
+import {
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readlinkSync,
+  realpathSync,
+  renameSync,
+  statSync,
+  writeFileSync,
+  type Stats,
+} from "node:fs"
+import type { FileInfo, SyncIo } from "./SyncIo.js"
+
+// A tree listing, or one committed file, can overflow execFileSync's 1 MB default.
+const MAX_BUFFER = 256 * 1024 * 1024
+
+const isAbsent = (e: unknown): boolean => {
+  const code = (e as NodeJS.ErrnoException).code
+  return code === "ENOENT" || code === "ENOTDIR"
+}
+
+const orAbsent = <A>(read: () => A): A | undefined => {
+  try {
+    return read()
+  } catch (e) {
+    if (isAbsent(e)) return undefined
+    throw e
+  }
+}
+
+const infoOf = (stats: Stats): FileInfo => ({
+  type: stats.isSymbolicLink()
+    ? "symlink"
+    : stats.isDirectory()
+      ? "directory"
+      : stats.isFile()
+        ? "file"
+        : "other",
+  uid: process.platform === "win32" ? undefined : stats.uid,
+})
+
+export const nodeSyncIo: SyncIo = {
+  readFile: (path) => orAbsent(() => readFileSync(path)),
+  readText: (path) => orAbsent(() => readFileSync(path, "utf8")),
+  writeText: (path, content) => writeFileSync(path, content, "utf8"),
+  makeDirectory: (path) => {
+    mkdirSync(path, { recursive: true })
+  },
+  rename: renameSync,
+  stat: (path) => orAbsent(() => infoOf(statSync(path))),
+  lstat: (path) => orAbsent(() => infoOf(lstatSync(path))),
+  readLink: (path) => readlinkSync(path, "utf8"),
+  realPath: (path) => realpathSync(path),
+  git: (cwd, args) => execFileSync("git", args, { cwd, encoding: "utf8", maxBuffer: MAX_BUFFER }),
+  gitBytes: (cwd, args) =>
+    execFileSync("git", args, { cwd, maxBuffer: MAX_BUFFER, stdio: ["ignore", "pipe", "ignore"] }),
+  hash: (algorithm, ...parts) => {
+    const hash = createHash(algorithm)
+    for (const part of parts) hash.update(part)
+    return hash.digest("hex")
+  },
+}

package/src/platform/PinFile.ts

@@ -1,9 +1,3 @@
-import { execFileSync } from "node:child_process"
-import { existsSync, readFileSync } from "node:fs"
-import { registerHooks } from "node:module"
-import { join } from "node:path"
-import { pathToFileURL } from "node:url"
-
 /** A process's pin as the launcher found it: the file's bytes and where its engine runs from. */
 export interface FoundPin {
   readonly path: string
@@ -15,47 +9,3 @@ export interface FoundPin {
  * the landing after an unpin beat deleted the file still runs on the pin.
  */
 export type PinFile = () => FoundPin | undefined
-
-// `cwd`, as the engine's own root is: gtd runs only at the worktree root, and
-// a relocated `$GIT_DIR` leaves no `.git` to walk up to. A file that cannot be
-// read counts as no pin, so the launcher refuses it rather than crashing.
-export const livePinFile =
-  (cwd: string, path: string): PinFile =>
-  () => {
-    const file = join(cwd, path)
-    if (existsSync(file)) {
-      try {
-        return { path: file, bytes: readFileSync(file) }
-      } catch {
-        return { path: file, bytes: new Uint8Array() }
-      }
-    }
-    try {
-      const bytes = execFileSync("git", ["show", `HEAD:${path}`], {
-        cwd,
-        stdio: ["ignore", "pipe", "ignore"],
-      })
-      return { path: file, bytes }
-    } catch {
-      return undefined
-    }
-  }
-
-/**
- * Runs a pin's module as this process's main program. Node refuses an unknown
- * extension, so a load hook serves the unpacked source under the pin's own
- * URL — `import.meta.url` stays a file in the repository.
- */
-export const runPinModule = async (path: string, source: string): Promise<void> => {
-  const url = pathToFileURL(path).href
-  // A pin read from HEAD has no file behind its URL, which Node's own resolve refuses.
-  registerHooks({
-    resolve: (specifier, context, nextResolve) =>
-      specifier === url ? { url, shortCircuit: true } : nextResolve(specifier, context),
-    load: (requested, context, nextLoad) =>
-      requested === url
-        ? { format: "module", source, shortCircuit: true }
-        : nextLoad(requested, context),
-  })
-  await import(url)
-}

package/src/platform/Sha.ts

@@ -0,0 +1,121 @@
+import type { HashAlgorithm } from "./SyncIo.js"
+
+// The digest for a runtime without Node's crypto, which the in-memory tier runs on.
+
+const K256 = Uint32Array.from([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+])
+
+const rotl = (x: number, n: number): number => (x << n) | (x >>> (32 - n))
+const rotr = (x: number, n: number): number => (x >>> n) | (x << (32 - n))
+
+/** `data` padded to whole 64-byte blocks, its bit length big-endian at the end. */
+const padded = (data: Uint8Array): DataView => {
+  const length = Math.ceil((data.length + 9) / 64) * 64
+  const bytes = new Uint8Array(length)
+  bytes.set(data)
+  bytes[data.length] = 0x80
+  const view = new DataView(bytes.buffer)
+  view.setUint32(length - 8, Math.floor(data.length / 0x20000000))
+  view.setUint32(length - 4, (data.length * 8) >>> 0)
+  return view
+}
+
+/** Round `i`'s boolean function of `b`, `c`, `d`, plus its constant. */
+const sha1Mix = (i: number, b: number, c: number, d: number): number =>
+  i < 20
+    ? ((b & c) | (~b & d)) + 0x5a827999
+    : i < 40
+      ? (b ^ c ^ d) + 0x6ed9eba1
+      : i < 60
+        ? ((b & c) | (b & d) | (c & d)) + 0x8f1bbcdc
+        : (b ^ c ^ d) + 0xca62c1d6
+
+const sha1 = (view: DataView): Uint32Array => {
+  const h = Uint32Array.from([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0])
+  const w = new Uint32Array(80)
+  for (let block = 0; block < view.byteLength; block += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(block + i * 4)
+    for (let i = 16; i < 80; i++) w[i] = rotl(w[i - 3]! ^ w[i - 8]! ^ w[i - 14]! ^ w[i - 16]!, 1)
+    let [a, b, c, d, e] = [h[0]!, h[1]!, h[2]!, h[3]!, h[4]!]
+    for (let i = 0; i < 80; i++) {
+      const t = (rotl(a, 5) + sha1Mix(i, b, c, d) + e + w[i]!) | 0
+      e = d
+      d = c
+      c = rotl(b, 30)
+      b = a
+      a = t
+    }
+    h[0]! += a
+    h[1]! += b
+    h[2]! += c
+    h[3]! += d
+    h[4]! += e
+  }
+  return h
+}
+
+const sha256 = (view: DataView): Uint32Array => {
+  const h = Uint32Array.from([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+  ])
+  const w = new Uint32Array(64)
+  for (let block = 0; block < view.byteLength; block += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(block + i * 4)
+    for (let i = 16; i < 64; i++) {
+      const x = w[i - 15]!
+      const y = w[i - 2]!
+      const s0 = rotr(x, 7) ^ rotr(x, 18) ^ (x >>> 3)
+      const s1 = rotr(y, 17) ^ rotr(y, 19) ^ (y >>> 10)
+      w[i] = w[i - 16]! + s0 + w[i - 7]! + s1
+    }
+    let [a, b, c, d, e, f, g, hh] = [h[0]!, h[1]!, h[2]!, h[3]!, h[4]!, h[5]!, h[6]!, h[7]!]
+    for (let i = 0; i < 64; i++) {
+      const t1 =
+        (hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + ((e & f) ^ (~e & g)) + K256[i]! + w[i]!) |
+        0
+      const t2 = ((rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) | 0
+      hh = g
+      g = f
+      f = e
+      e = (d + t1) | 0
+      d = c
+      c = b
+      b = a
+      a = (t1 + t2) | 0
+    }
+    h[0]! += a
+    h[1]! += b
+    h[2]! += c
+    h[3]! += d
+    h[4]! += e
+    h[5]! += f
+    h[6]! += g
+    h[7]! += hh
+  }
+  return h
+}
+
+const encoder = new TextEncoder()
+
+export const pureHash = (
+  algorithm: HashAlgorithm,
+  ...parts: readonly (string | Uint8Array)[]
+): string => {
+  const chunks = parts.map((part) => (typeof part === "string" ? encoder.encode(part) : part))
+  const data = new Uint8Array(chunks.reduce((n, chunk) => n + chunk.length, 0))
+  let at = 0
+  for (const chunk of chunks) {
+    data.set(chunk, at)
+    at += chunk.length
+  }
+  const words = (algorithm === "sha1" ? sha1 : sha256)(padded(data))
+  return [...words].map((word) => word.toString(16).padStart(8, "0")).join("")
+}

package/src/platform/SyncIo.ts

@@ -0,0 +1,35 @@
+export type HashAlgorithm = "sha1" | "sha256"
+
+export interface FileInfo {
+  readonly type: "file" | "directory" | "symlink" | "other"
+  /** `undefined` where the platform has no POSIX user ids. */
+  readonly uid: number | undefined
+}
+
+/**
+ * The machine reads that must stay synchronous: workflows read the tree
+ * between two awaits during replay, so neither the reads nor the hashing
+ * behind them can wait on IO. Absence is a value (`undefined`); any other
+ * fault throws.
+ */
+export interface SyncIo {
+  readonly readFile: (path: string) => Uint8Array | undefined
+  readonly readText: (path: string) => string | undefined
+  readonly writeText: (path: string, content: string) => void
+  /** Creates every missing parent too. */
+  readonly makeDirectory: (path: string) => void
+  readonly rename: (from: string, to: string) => void
+  /** Follows a symlink. */
+  readonly stat: (path: string) => FileInfo | undefined
+  /** Reports a symlink as one. */
+  readonly lstat: (path: string) => FileInfo | undefined
+  readonly readLink: (path: string) => string
+  /** Throws when `path` does not exist. */
+  readonly realPath: (path: string) => string
+  /** git's stdout; throws on a non-zero exit, with git's stderr passed through. */
+  readonly git: (cwd: string, args: readonly string[]) => string
+  /** `git`'s raw stdout, with its stderr discarded. */
+  readonly gitBytes: (cwd: string, args: readonly string[]) => Uint8Array
+  /** Lowercase hex digest of the parts, concatenated; a string part is UTF-8. */
+  readonly hash: (algorithm: HashAlgorithm, ...parts: readonly (string | Uint8Array)[]) => string
+}

package/src/platform/Workspace.test.ts

@@ -54,7 +54,9 @@ const makeLiveTier = (): WorkspaceTier => {
 
   const hostLayer = Host.layer({ root, home: root, env: {} })
   const gitLayer = GitService.Live.pipe(Layer.provide(Layer.merge(hostLayer, NodeServices.layer)))
-  const workspaceLayer = Workspace.Live.pipe(Layer.provide(Layer.merge(hostLayer, gitLayer)))
+  const workspaceLayer = Workspace.Live.pipe(
+    Layer.provide(Layer.mergeAll(hostLayer, gitLayer, NodeServices.layer)),
+  )
 
   return {
     root,
@@ -270,8 +272,9 @@ describe("Workspace [Live] worktreeSync", () => {
         Effect.provide(
           Workspace.Live.pipe(
             Layer.provide(
-              Layer.merge(
+              Layer.mergeAll(
                 Host.layer({ root, home: root, env: {} }),
+                NodeServices.layer,
                 GitService.Live.pipe(
                   Layer.provide(
                     Layer.merge(Host.layer({ root, home: root, env: {} }), NodeServices.layer),
@@ -361,7 +364,9 @@ const makeLiveEpisodeTier = () => {
 
   const hostLayer = Host.layer({ root, home: root, env: {} })
   const gitLayer = GitService.Live.pipe(Layer.provide(Layer.merge(hostLayer, NodeServices.layer)))
-  const workspaceLayer = Workspace.Live.pipe(Layer.provide(Layer.merge(hostLayer, gitLayer)))
+  const workspaceLayer = Workspace.Live.pipe(
+    Layer.provide(Layer.mergeAll(hostLayer, gitLayer, NodeServices.layer)),
+  )
   const ops = (): Promise<WorkspaceOps> =>
     Effect.runPromise(
       Effect.gen(function* () {