@pmelab/gtd 60.0.0 → 60.1.0

package/src/cli/Program.ts

@@ -1,5 +1,6 @@
 import { Effect, Option, Schema } from "effect"
 import {
+  GtdError,
   GtdUsageError,
   Narrator,
   GitService,
@@ -15,6 +16,8 @@ import {
 import {
   WORKFLOW_MODULE,
   ConfigDiscovery,
+  EngineCore,
+  pin,
   refuseLegacyRc,
   ConfigService,
   formatDiagnostic,
@@ -88,7 +91,7 @@ import {
   abandonNoopOutcome,
   restoredOutcome,
 } from "../emit/index.js"
-import { renderBriefing, WORKFLOWS_REPO } from "../install/index.js"
+import { GTD_VERSION, renderBriefing, WORKFLOWS_REPO } from "../install/index.js"
 import { ToolCommands, type SelfGtd } from "./ToolCommands.js"
 import {
   normalizeScriptNewline,
@@ -119,7 +122,7 @@ import { runHistoryMetricsCommand } from "./Metrics.js"
  * SAME type structurally off `currentRest`'s own success type rather than
  * importing the name.
  */
-type Rest = Effect.Effect.Success<typeof currentRest>
+type Rest = Effect.Success<typeof currentRest>
 
 export type Command =
   | { readonly kind: "lsp" }
@@ -161,6 +164,7 @@ export type Command =
     }
   | { readonly kind: "uncheck"; readonly file: string }
   | { readonly kind: "guide" }
+  | { readonly kind: "bundle" }
   | { readonly kind: "summary" }
   | { readonly kind: "base" }
   | { readonly kind: "judge" }
@@ -219,15 +223,34 @@ const runGuideCommand = (
     const briefing = renderBriefing()
     out.write(briefing.endsWith("\n") ? briefing : briefing + "\n")
     const host = yield* Host
-    const topLevel = yield* Effect.either((yield* GitService).topLevel())
-    if (topLevel._tag === "Left") return
-    if ((yield* host.realPath(topLevel.right)) !== (yield* host.realPath(host.root))) return
+    const topLevel = yield* Effect.result((yield* GitService).topLevel())
+    if (topLevel._tag === "Failure") return
+    if ((yield* host.realPath(topLevel.success)) !== (yield* host.realPath(host.root))) return
     if ((yield* (yield* ConfigDiscovery).workflowModule(host.root, host.home)) !== undefined) return
     yield* (yield* Narrator).warn(
       `gtd guide: no ${WORKFLOW_MODULE} governs here, and gtd ships no workflow — get one from ${WORKFLOWS_REPO} or write your own (step 2 of the briefing above)`,
     )
   })
 
+/** Loads the workflow first, so a pin is never made of one gtd would refuse. */
+const runBundleCommand = (
+  out: ArtifactOut,
+): Effect.Effect<
+  void,
+  Error,
+  ConfigService | ConfigDiscovery | EngineCore | Host | Narrator | Workspace
+> =>
+  Effect.gen(function* () {
+    yield* (yield* ConfigService).load
+    const host = yield* Host
+    const module = yield* (yield* ConfigDiscovery).workflowModule(host.root, host.home)
+    // Inside a pin, load read the pinned workflow, not a config on disk.
+    if (module === undefined) {
+      return yield* Effect.fail(new GtdError(`gtd bundle: no ${WORKFLOW_MODULE} here or above`))
+    }
+    out.write(yield* pin(module, host.root, GTD_VERSION))
+  })
+
 /**
  * `planLanding`'s result — a preview of what `gtd land` would do, plus the
  * combined `script` the driver runs to do it. `script` is
@@ -457,7 +480,7 @@ const runJudgeRunCommand = (
   })
 
 /** A verdict's own `answer` shape covers every `judge:` primitive (`noul` → boolean, `choice` → string, `score` → number) without gtd itself interpreting which one applies — that's a driver/judge-model concern, not this decode's. */
-const VerdictAnswer = Schema.Union(Schema.String, Schema.Number, Schema.Boolean)
+const VerdictAnswer = Schema.Union([Schema.String, Schema.Number, Schema.Boolean])
 
 /**
  * One `gtd judge answer` verdict entry per pending question, `{ id, answer,
@@ -470,14 +493,14 @@ const VerdictAnswer = Schema.Union(Schema.String, Schema.Number, Schema.Boolean)
 const verdictSchemaFor = (ids: readonly string[]) =>
   Schema.Array(
     Schema.Struct({
-      id: ids.length > 0 ? Schema.Literal(...(ids as [string, ...string[]])) : Schema.Never,
+      id: ids.length > 0 ? Schema.Literals(ids) : Schema.Never,
       answer: VerdictAnswer,
       // Bounded [0, 1] — every OTHER bound in the routes: matching path fails
       // CLOSED (a non-finite rendered minP/maxP never matches); an
       // unvalidated p wouldn't: a driver bug or a miscalibrated model
       // sending p > 1 would clear every minP a workflow declares,
       // unconditionally forcing the judged route on a live gate.
-      p: Schema.Number.pipe(Schema.between(0, 1)),
+      p: Schema.Number.check(Schema.isBetween({ minimum: 0, maximum: 1 })),
     }),
   )
 
@@ -509,7 +532,7 @@ const runJudgeAnswerCommand = (
       try: () => JSON.parse(raw) as unknown,
       catch: () => new SelectorUsageError("gtd judge answer: stdin is not valid JSON"),
     })
-    const verdict = yield* Schema.decodeUnknown(verdictSchemaFor(ids))(parsed).pipe(
+    const verdict = yield* Schema.decodeUnknownEffect(verdictSchemaFor(ids))(parsed).pipe(
       Effect.mapError(
         (e) =>
           new SelectorUsageError(
@@ -1137,7 +1160,7 @@ const gatherBeatDocument = (
       kind === "prompt" ? resolveSession(rendered.memory, rendered.memoryResumed) : undefined
     const resolvedValidate =
       kind === "prompt"
-        ? yield* resolveValidateScript(rest).pipe(Effect.catchAll(() => Effect.succeed(undefined)))
+        ? yield* resolveValidateScript(rest).pipe(Effect.catch(() => Effect.succeed(undefined)))
         : undefined
     const validate =
       resolvedValidate !== undefined && resolvedValidate.script.length > 0
@@ -1332,6 +1355,8 @@ const dispatchVoidCommand = (
       return runUncheckCommand(command.file)
     case "guide":
       return runGuideCommand(out)
+    case "bundle":
+      return runBundleCommand(out)
     case "summary":
       return runSummaryCommand(out)
     case "base":

package/src/cli/ToolCommands.ts

@@ -29,7 +29,7 @@ interface JudgeRequest {
  * The subcommands backed by a driver or tool. Core may not import those
  * units, so the composition root provides them here.
  */
-export class ToolCommands extends Context.Tag("ToolCommands")<
+export class ToolCommands extends Context.Service<
   ToolCommands,
   {
     readonly ui: (
@@ -39,4 +39,4 @@ export class ToolCommands extends Context.Tag("ToolCommands")<
     readonly lsp: (gtd: SelfGtd) => Effect.Effect<void, Error>
     readonly judge: (request: JudgeRequest) => Promise<string>
   }
->() {}
+>()("ToolCommands") {}

package/src/edge/Edge.test.ts

@@ -469,12 +469,14 @@ describe("history reads stay bounded by the episode, not the repository", () =>
     const raceyGit: GitOperations = {
       ...base,
       subjectHistory: (pageSize, skip, head) =>
-        Effect.tap(base.subjectHistory(pageSize, skip, head), () => {
-          if (!moved) {
-            moved = true
-            repo.hardResetTo(boundary)
-          }
-        }),
+        Effect.tap(base.subjectHistory(pageSize, skip, head), () =>
+          Effect.sync(() => {
+            if (!moved) {
+              moved = true
+              repo.hardResetTo(boundary)
+            }
+          }),
+        ),
     }
 
     const run = await provideWithGit(currentRun, raceyGit, repo)

package/src/edge/Edge.ts

@@ -1319,7 +1319,7 @@ const decideLanding = (
 export const previewLanding = (rest: Rest): Effect.Effect<StateName | undefined> =>
   decideLanding(rest, undefined, Option.none(), Option.none()).pipe(
     Effect.map((landing) => (landing.kind === "commit" ? landing.to : undefined)),
-    Effect.catchAll(() => Effect.succeed(undefined)),
+    Effect.catch(() => Effect.succeed(undefined)),
   )
 
 /** Every fact the pure landing planner needs, read once: the rest, its steering file, and the landing decision. */
@@ -1432,8 +1432,8 @@ const configRefusal = (
   )
 
 const differingConfigPaths = (
-  git: GitService["Type"],
-  workspace: Workspace["Type"],
+  git: GitService["Service"],
+  workspace: Workspace["Service"],
   root: string,
   config: { readonly fingerprint: ConfigFingerprint },
   run: ProcessRun,

package/src/flows/runtime.ts

@@ -1,7 +1,7 @@
 // The authoring surface of a gtd workflow. Every function here is a thin
 // facade over the replay context the engine installs on `globalThis` — keyed by
 // a registered symbol, not a module-local variable, so a copy of this file
-// loaded through a user's `gtd.config.ts` (jiti) and the copy bundled into the
+// a user's `gtd.config.ts` brings along and the copy bundled into the
 // gtd binary drive the same replay.
 import type { WorkflowBuild } from "./factory.js"
 

package/src/install/Version.ts

@@ -22,6 +22,12 @@ const findPackageJson = (fromUrl: string): string => {
   throw new Error(`package.json not found by walking up from ${fromUrl}`)
 }
 
-export const GTD_VERSION: string = (
-  _require(findPackageJson(import.meta.url)) as { version: string }
-).version
+/** The global a pin's workflow registers itself under, ahead of the engine in the same file. */
+export const PIN_KEY = Symbol.for("@pmelab/gtd/pin")
+
+// Inside a pin, `import.meta.url` is the pin's own file, in the user's
+// repository: the pin registered the version it was built by before this runs.
+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

package/src/install/index.ts

@@ -1,2 +1,2 @@
 export { renderBriefing, WORKFLOWS_REPO } from "./Install.js"
-export { GTD_VERSION } from "./Version.js"
+export { GTD_VERSION, PIN_KEY } from "./Version.js"

package/src/platform/CommandRunner.ts

@@ -1,5 +1,5 @@
-import { Command, CommandExecutor } from "@effect/platform"
 import { Context, Effect, Layer, Stream } from "effect"
+import { ChildProcess, ChildProcessSpawner } from "effect/process"
 import { Host } from "./Host.js"
 
 /** One command run's outcome: its exit status (a signal death reported as `null`, matching `spawnSync`) and its combined output (stdout then stderr). */
@@ -23,13 +23,13 @@ interface CommandOutcome {
  * stdout/stderr, none of which this port's single-shot "run to completion"
  * shape supports.
  */
-export class CommandRunner extends Context.Tag("CommandRunner")<
+export class CommandRunner extends Context.Service<
   CommandRunner,
   {
     /** A SPAWN failure (no `bash`, unreadable cwd) fails the Effect; a non-zero EXIT is a value — how a mode command reports "invalid"/"broken" for the caller to interpret. */
     readonly bash: (command: string) => Effect.Effect<CommandOutcome, Error>
   }
->() {
+>()("CommandRunner") {
   /** A test layer over a canned `bash` implementation — no subprocess. */
   static readonly layer = (
     bash: (command: string) => Effect.Effect<CommandOutcome, Error>,
@@ -39,17 +39,19 @@ export class CommandRunner extends Context.Tag("CommandRunner")<
     CommandRunner,
     Effect.gen(function* () {
       const { root } = yield* Host
-      const executor = yield* CommandExecutor.CommandExecutor
+      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
       return {
         bash: (command: string) =>
           Effect.scoped(
             Effect.gen(function* () {
-              const process = yield* executor.start(
-                Command.make("bash", "-c", command).pipe(
-                  Command.workingDirectory(root),
-                  Command.stdout("pipe"),
-                  Command.stderr("pipe"),
-                ),
+              const process = yield* spawner.spawn(
+                ChildProcess.make("bash", ["-c", command], {
+                  cwd: root,
+                  stdout: "pipe",
+                  stderr: "pipe",
+                  // Not detached, like `Git.ts`'s `run`: a background job the command starts survives it.
+                  detached: false,
+                }),
               )
               const collect = (stream: typeof process.stdout) =>
                 stream.pipe(Stream.decodeText(), Stream.mkString)
@@ -60,7 +62,7 @@ export class CommandRunner extends Context.Tag("CommandRunner")<
                   // A signal death fails process.exitCode; map to null to match spawnSync's contract.
                   process.exitCode.pipe(
                     Effect.map((code): number | null => code),
-                    Effect.catchAll(() => Effect.succeed(null)),
+                    Effect.catch(() => Effect.succeed(null)),
                   ),
                 ],
                 { concurrency: "unbounded" },

package/src/platform/Commentary.ts

@@ -5,13 +5,13 @@ import { Context, Effect, Layer } from "effect"
  * layer was built, never by the call site; `warn` is its ungated
  * counterpart, always written regardless of verbosity.
  */
-export class Narrator extends Context.Tag("Narrator")<
+export class Narrator extends Context.Service<
   Narrator,
   {
     readonly narrate: (line: string) => Effect.Effect<void>
     readonly warn: (line: string) => Effect.Effect<void>
   }
->() {
+>()("Narrator") {
   /**
    * `write` is the raw stderr sink (`CliIo.stderr` in production, so the
    * in-memory `CliIo` used by `@inmem` e2e scenarios captures narration into

package/src/platform/Git.test.ts

@@ -2,11 +2,10 @@ import { execFileSync } from "node:child_process"
 import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
-import { NodeContext } from "@effect/platform-node"
 import { Cause, Effect, Exit, Option } from "effect"
 import { describe, expect, it } from "vitest"
 import { GitService, InvalidRefError, resolvedRefOrCorrupted } from "./Git.js"
-import { Host } from "./index.js"
+import { Host, NodeServices } from "./index.js"
 import { gitTiers, runGitServiceContract, runGitScriptContract } from "../twins/index.js"
 
 /**
@@ -78,7 +77,7 @@ describe("diffPaths [Live]", () => {
         Effect.flatMap(GitService, (g) => g.diffPaths(base, tip)).pipe(
           Effect.provide(GitService.Live),
           Effect.provide(Host.layer({ root: join(root, "sub"), home: root, env: {} })),
-          Effect.provide(NodeContext.layer),
+          Effect.provide(NodeServices.layer),
         ),
       )
       expect([...paths].sort()).toEqual(["sub/a.txt", "top.txt"])
@@ -131,7 +130,7 @@ describe("diffPaths [Live]", () => {
         Effect.flatMap(GitService, (g) => g.diffPaths(base, tip)).pipe(
           Effect.provide(GitService.Live),
           Effect.provide(Host.layer({ root: repo, home: root, env: {} })),
-          Effect.provide(NodeContext.layer),
+          Effect.provide(NodeServices.layer),
         ),
       )
       expect([...paths]).toEqual(["sub"])
@@ -155,7 +154,7 @@ describe("authorIdent [Live]", () => {
         Effect.flatMap(GitService, (g) => g.authorIdent()).pipe(
           Effect.provide(GitService.Live),
           Effect.provide(Host.layer({ root, home: root, env: {} })),
-          Effect.provide(NodeContext.layer),
+          Effect.provide(NodeServices.layer),
         ),
       )
       expect(Option.isNone(ident)).toBe(true)

package/src/platform/Git.ts

@@ -1,5 +1,5 @@
-import { Command, CommandExecutor } from "@effect/platform"
 import { Context, Effect, Layer, Option, Stream } from "effect"
+import { ChildProcess, ChildProcessSpawner } from "effect/process"
 import { Host } from "./Host.js"
 
 export interface GitReaderOperations {
@@ -80,7 +80,7 @@ export interface GitReaderOperations {
     skip: number,
     head?: string,
   ) => Effect.Effect<ReadonlyArray<{ readonly hash: string; readonly subject: string }>, Error>
-  /** Fails when the path doesn't exist at `ref` — a caller expecting that (e.g. the review sign-off gate) handles it with an explicit `catchAll`. */
+  /** Fails when the path doesn't exist at `ref` — a caller expecting that (e.g. the review sign-off gate) handles it with an explicit `catch`. */
   readonly readFileAtRef: (ref: string, path: string) => Effect.Effect<string, Error>
   /**
    * Pending working-tree changes vs `base` (default `HEAD`), as
@@ -216,7 +216,7 @@ const blobsAtRef = (
   paths: ReadonlyArray<string>,
 ): Effect.Effect<Map<string, string>, Error> =>
   exec("git", "ls-tree", "-r", "-z", ref, "--", ...paths).pipe(
-    Effect.catchAll(() => Effect.succeed("")),
+    Effect.catch(() => Effect.succeed("")),
     Effect.map((out) => {
       const blobs = new Map<string, string>()
       for (const entry of splitNul(out)) {
@@ -256,7 +256,7 @@ const hashObjects = (
             .map((oid, i) => [paths[i] ?? "", oid.trim()] as const),
         ),
     ),
-    Effect.catchAll(() => Effect.succeed(new Map<string, string>())),
+    Effect.catch(() => Effect.succeed(new Map<string, string>())),
   )
 
 /**
@@ -287,25 +287,28 @@ const classifyUntracked = (
 
 /**
  * Run a command and return its stdout — FAILING on a non-zero exit code with
- * the command line and stderr in the error message. `Command.string` alone
- * silently ignores exit codes, which used to make gtd report success on
- * rejected commits and lose files whose quoted paths broke a swallowed
- * `git add`. Callers that expect a probe to fail handle it with an explicit
- * `catchAll`.
+ * the command line and stderr in the error message. Ignoring exit codes
+ * used to make gtd report success on rejected commits and lose files whose
+ * quoted paths broke a swallowed `git add`. Callers that expect a probe to
+ * fail handle it with an explicit `catch`.
  */
 const run = (
   root: string,
   ...args: [string, ...Array<string>]
-): Effect.Effect<string, Error, CommandExecutor.CommandExecutor> =>
+): Effect.Effect<string, Error, ChildProcessSpawner.ChildProcessSpawner> =>
   Effect.scoped(
     Effect.gen(function* () {
-      const executor = yield* CommandExecutor.CommandExecutor
-      const process = yield* executor.start(
-        Command.make(...args).pipe(
-          Command.workingDirectory(root),
-          Command.stdout("pipe"),
-          Command.stderr("pipe"),
-        ),
+      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+      const [command, ...rest] = args
+      const process = yield* spawner.spawn(
+        // Not detached: the spawner SIGTERMs a detached child's whole group once it
+        // exits, which would kill a git hook's background job.
+        ChildProcess.make(command, rest, {
+          cwd: root,
+          stdout: "pipe",
+          stderr: "pipe",
+          detached: false,
+        }),
       )
       const collect = (stream: typeof process.stdout) =>
         stream.pipe(Stream.decodeText(), Stream.mkString)
@@ -353,11 +356,12 @@ export const resolvedRefOrCorrupted = (
     ? Effect.succeed(hash)
     : Effect.fail(new InvalidRefError(`Invalid ref: ${ref}`, [`ref: ${ref}`]))
 
-const makeGitImpl = (executor: CommandExecutor.CommandExecutor, root: string): GitOperations => {
+const makeGitImpl = (
+  spawner: ChildProcessSpawner.ChildProcessSpawner["Service"],
+  root: string,
+): GitOperations => {
   const exec = (...args: [string, ...Array<string>]) =>
-    run(root, ...args).pipe(
-      Effect.provide(Layer.succeed(CommandExecutor.CommandExecutor, executor)),
-    )
+    run(root, ...args).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner))
 
   return {
     lastCommitSubject: (ref = "HEAD") =>
@@ -374,7 +378,7 @@ const makeGitImpl = (executor: CommandExecutor.CommandExecutor, root: string): G
       exec("git", "symbolic-ref", "--quiet", "--short", "HEAD").pipe(
         Effect.map((s) => s.trim()),
         Effect.map((name) => Option.some(name)),
-        Effect.catchAll(() => Effect.succeed(Option.none<string>())),
+        Effect.catch(() => Effect.succeed(Option.none<string>())),
       ),
 
     listRefs: (prefix: string) =>
@@ -399,7 +403,7 @@ const makeGitImpl = (executor: CommandExecutor.CommandExecutor, root: string): G
     hasCommits: () =>
       exec("git", "rev-parse", "--verify", "HEAD").pipe(
         Effect.map(() => true),
-        Effect.catchAll(() => Effect.succeed(false)),
+        Effect.catch(() => Effect.succeed(false)),
       ),
 
     readFileAtRef: (ref: string, path: string) => exec("git", "show", `${ref}:${path}`),
@@ -427,7 +431,7 @@ const makeGitImpl = (executor: CommandExecutor.CommandExecutor, root: string): G
             ? Option.none()
             : Option.some({ name: match[1]!, email: match[2]! })
         }),
-        Effect.catchAll(() => Effect.succeed(Option.none())),
+        Effect.catch(() => Effect.succeed(Option.none())),
       ),
 
     changedPaths: (base?: string) =>
@@ -436,7 +440,7 @@ const makeGitImpl = (executor: CommandExecutor.CommandExecutor, root: string): G
         // Tolerates the empty-repo case (no HEAD), where the diff has no ref
         // to compare against and reports no tracked changes.
         const nameStatusOut = yield* exec("git", "diff", "--name-status", "-z", ref).pipe(
-          Effect.catchAll(() => Effect.succeed("")),
+          Effect.catch(() => Effect.succeed("")),
         )
         const trackedPaths = parseNameStatus(splitNul(nameStatusOut))
 
@@ -469,7 +473,7 @@ const makeGitImpl = (executor: CommandExecutor.CommandExecutor, root: string): G
 
     stagedPaths: () =>
       exec("git", "diff", "--cached", "--name-status", "--no-renames", "-z", "HEAD").pipe(
-        Effect.catchAll(() => Effect.succeed("")),
+        Effect.catch(() => Effect.succeed("")),
         Effect.map((out) => parseNameStatus(splitNul(out))),
       ),
 
@@ -482,26 +486,26 @@ const makeGitImpl = (executor: CommandExecutor.CommandExecutor, root: string): G
     readRefOption: (ref: string) =>
       exec("git", "rev-parse", "--verify", "--quiet", ref).pipe(
         Effect.map((s) => Option.some(s.trim())),
-        Effect.catchAll(() => Effect.succeed(Option.none<string>())),
+        Effect.catch(() => Effect.succeed(Option.none<string>())),
       ),
 
     isAncestor: (a: string, b: string) =>
       run(root, "git", "merge-base", "--is-ancestor", a, b).pipe(
-        Effect.provide(Layer.succeed(CommandExecutor.CommandExecutor, executor)),
+        Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
         Effect.map(() => true),
-        Effect.catchAll(() => Effect.succeed(false)),
+        Effect.catch(() => Effect.succeed(false)),
       ),
 
     mergeBase: (a: string, b: string) =>
       exec("git", "merge-base", a, b).pipe(
         Effect.map((s) => Option.some(s.trim())),
-        Effect.catchAll(() => Effect.succeed(Option.none<string>())),
+        Effect.catch(() => Effect.succeed(Option.none<string>())),
       ),
 
     defaultBranch: () =>
       exec("git", "symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD").pipe(
         Effect.map((s) => s.trim()),
-        Effect.catchAll(() => Effect.succeed("")),
+        Effect.catch(() => Effect.succeed("")),
         Effect.map((name) => (name === "" ? "main" : name)),
       ),
 
@@ -546,7 +550,7 @@ const makeGitImpl = (executor: CommandExecutor.CommandExecutor, root: string): G
             }),
         ),
         // Empty repo (no HEAD) makes `git log` fail; treat as no commits.
-        Effect.catchAll(() =>
+        Effect.catch(() =>
           Effect.succeed(
             [] as ReadonlyArray<{
               readonly hash: string
@@ -582,7 +586,7 @@ const makeGitImpl = (executor: CommandExecutor.CommandExecutor, root: string): G
         ),
         // Empty repo (no HEAD), or an unresolvable `head`, makes `git log`
         // fail; treat as no commits — the same fold `commitHistory` applies.
-        Effect.catchAll(() =>
+        Effect.catch(() =>
           Effect.succeed([] as ReadonlyArray<{ readonly hash: string; readonly subject: string }>),
         ),
       )
@@ -592,7 +596,7 @@ const makeGitImpl = (executor: CommandExecutor.CommandExecutor, root: string): G
       Effect.gen(function* () {
         yield* exec("git", "add", "-A")
         yield* exec("git", "commit", "--allow-empty", "-m", prefix).pipe(
-          Effect.catchAll((error) =>
+          Effect.catch((error) =>
             // Hooks like lint-staged block empty commits even with --allow-empty.
             // gtd's workflow commits have nothing for code-quality hooks to validate,
             // so retry without the pre-commit hook when that guard fires.
@@ -608,7 +612,7 @@ const makeGitImpl = (executor: CommandExecutor.CommandExecutor, root: string): G
     commitAsIs: (message: string) =>
       exec("git", "commit", "--allow-empty", "-m", message)
         .pipe(
-          Effect.catchAll((error) =>
+          Effect.catch((error) =>
             error.message.includes("empty git commit")
               ? exec("git", "commit", "--allow-empty", "--no-verify", "-m", message)
               : Effect.fail(error),
@@ -634,11 +638,11 @@ const makeGitImpl = (executor: CommandExecutor.CommandExecutor, root: string): G
 }
 
 const makeLiveEffect = Effect.gen(function* () {
-  const executor = yield* CommandExecutor.CommandExecutor
+  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
   const { root } = yield* Host
-  return makeGitImpl(executor, root)
+  return makeGitImpl(spawner, root)
 })
 
-export class GitService extends Context.Tag("GitService")<GitService, GitOperations>() {
+export class GitService extends Context.Service<GitService, GitOperations>()("GitService") {
   static Live = Layer.effect(GitService, makeLiveEffect)
 }

package/src/platform/Host.ts

@@ -36,7 +36,7 @@ const makeHostOps = (opts: HostOpsInput): HostOps => ({
     ((path: string) => Effect.try({ try: () => realpathSync(path), catch: toError })),
 })
 
-export class Host extends Context.Tag("Host")<Host, HostOps>() {
+export class Host extends Context.Service<Host, HostOps>()("Host") {
   static layer = (opts: HostOpsInput): Layer.Layer<Host> => Layer.succeed(Host, makeHostOps(opts))
   static Live = Host.layer({ root: process.cwd(), home: homedir(), env: process.env })
 }

package/src/platform/NodeServices.ts

@@ -0,0 +1,11 @@
+import { NodeChildProcessSpawner, NodeFileSystem, NodePath } from "@effect/platform-node-shared"
+import { Layer } from "effect"
+
+// Not `@effect/platform-node`'s own: that package requires a redis peer, which
+// every install of gtd would then pull in.
+export const layer = Layer.provideMerge(
+  NodeChildProcessSpawner.layer,
+  Layer.mergeAll(NodeFileSystem.layer, NodePath.layer),
+)
+
+export type NodeServices = Layer.Success<typeof layer>

package/src/platform/Workspace.test.ts

@@ -13,8 +13,7 @@ import { tmpdir } from "node:os"
 import { join } from "node:path"
 import { afterEach, describe, expect, it, vi } from "vitest"
 import { Effect, Layer } from "effect"
-import { NodeContext } from "@effect/platform-node"
-import { GitService, Host, Workspace, type WorkspaceOps } from "./index.js"
+import { GitService, Host, Workspace, type WorkspaceOps, NodeServices } from "./index.js"
 import { InMemRepo, makeInMemoryWorkspaceOps } from "../twins/index.js"
 
 // `execFileSync` is a named export of the built-in `node:child_process` ESM
@@ -54,7 +53,7 @@ const makeLiveTier = (): WorkspaceTier => {
   gitExecIn(root, "config", "commit.gpgsign", "false")
 
   const hostLayer = Host.layer({ root, home: root, env: {} })
-  const gitLayer = GitService.Live.pipe(Layer.provide(Layer.merge(hostLayer, NodeContext.layer)))
+  const gitLayer = GitService.Live.pipe(Layer.provide(Layer.merge(hostLayer, NodeServices.layer)))
   const workspaceLayer = Workspace.Live.pipe(Layer.provide(Layer.merge(hostLayer, gitLayer)))
 
   return {
@@ -275,7 +274,7 @@ describe("Workspace [Live] worktreeSync", () => {
                 Host.layer({ root, home: root, env: {} }),
                 GitService.Live.pipe(
                   Layer.provide(
-                    Layer.merge(Host.layer({ root, home: root, env: {} }), NodeContext.layer),
+                    Layer.merge(Host.layer({ root, home: root, env: {} }), NodeServices.layer),
                   ),
                 ),
               ),
@@ -361,7 +360,7 @@ const makeLiveEpisodeTier = () => {
   git("config", "commit.gpgsign", "false")
 
   const hostLayer = Host.layer({ root, home: root, env: {} })
-  const gitLayer = GitService.Live.pipe(Layer.provide(Layer.merge(hostLayer, NodeContext.layer)))
+  const gitLayer = GitService.Live.pipe(Layer.provide(Layer.merge(hostLayer, NodeServices.layer)))
   const workspaceLayer = Workspace.Live.pipe(Layer.provide(Layer.merge(hostLayer, gitLayer)))
   const ops = (): Promise<WorkspaceOps> =>
     Effect.runPromise(

package/src/platform/Workspace.ts

@@ -600,7 +600,7 @@ const makeWorkspaceOps = (
     committed: (path, ref = "HEAD") =>
       Effect.try({ try: () => assertRepoRelative(path), catch: toError }).pipe(
         Effect.flatMap((relPath) =>
-          git.readFileAtRef(ref, relPath).pipe(Effect.catchAll(() => Effect.succeed(undefined))),
+          git.readFileAtRef(ref, relPath).pipe(Effect.catch(() => Effect.succeed(undefined))),
         ),
       ),
     readCommittedSync,
@@ -610,7 +610,7 @@ const makeWorkspaceOps = (
   }
 }
 
-export class Workspace extends Context.Tag("Workspace")<Workspace, WorkspaceOps>() {
+export class Workspace extends Context.Service<Workspace, WorkspaceOps>()("Workspace") {
   static Live = Layer.effect(
     Workspace,
     Effect.gen(function* () {
@@ -624,7 +624,7 @@ export class Workspace extends Context.Tag("Workspace")<Workspace, WorkspaceOps>
       // like a full-disk failure does.
       const commonDir = yield* git
         .gitCommonDir()
-        .pipe(Effect.catchAll(() => Effect.succeed(undefined)))
+        .pipe(Effect.catch(() => Effect.succeed(undefined)))
       return makeWorkspaceOps(root, git, commonDir)
     }),
   )