@pmelab/gtd 60.0.0 → 61.0.0

package/src/emit/GitScript.ts

@@ -12,12 +12,13 @@ export const pathspec = (paths: ReadonlyArray<string>): string => paths.map(shel
  * output rather than the exit code, so a genuinely rejected commit (a lint
  * error, a commit-msg hook) still fails.
  */
-const commitAllowEmpty = (message: string): string => {
+const commitAllowEmpty = (message: string, only?: string): string => {
   const m = shellQuote(message)
+  const paths = only === undefined ? "" : ` -- ${shellQuote(only)}`
   return [
-    `if ! out=$(git commit --allow-empty -m ${m} 2>&1); then`,
+    `if ! out=$(git commit --allow-empty -m ${m}${paths} 2>&1); then`,
     `  case "$out" in`,
-    `    *"empty git commit"*) git commit --allow-empty --no-verify -m ${m} || exit 1 ;;`,
+    `    *"empty git commit"*) git commit --allow-empty --no-verify -m ${m}${paths} || exit 1 ;;`,
     `    *) printf '%s\\n' "$out" >&2; exit 1 ;;`,
     `  esac`,
     `fi`,
@@ -31,6 +32,21 @@ export const CHANGED_SINCE_LAND =
 export const commitAll = (message: string): string =>
   `git add -A || exit 1\n${commitAllowEmpty(message)}`
 
+/** Commits `path` alone, as the worktree has it; every other pending change stays pending. */
+export const commitPath = (path: string, message: string): string =>
+  `git add -A -- ${shellQuote(path)} || exit 1\n${commitAllowEmpty(message, path)}`
+
+/** A pin beat's script. A failed `gtd bundle` leaves no half-written pin behind. */
+export const pinScript = (path: string): string => {
+  const p = shellQuote(path)
+  const slash = path.lastIndexOf("/")
+  const mkdir = slash === -1 ? "" : `mkdir -p ${shellQuote(path.slice(0, slash))}\n`
+  return `${mkdir}gtd bundle >${p} || { rm -f -- ${p}; exit 1; }`
+}
+
+/** An unpin beat's script, and `gtd abandon`'s removal of the pin. */
+export const unpinScript = (path: string): string => `rm -f -- ${shellQuote(path)}`
+
 /**
  * An approval records exactly the judged tree: HEAD is pinned before the
  * clean check and the commit is built over its tree with `commit-tree`, so no
@@ -151,6 +167,8 @@ const renderGitWrite = (write: GitWrite): string => {
   switch (write.kind) {
     case "commitAll":
       return commitAll(write.message)
+    case "commitPath":
+      return commitPath(write.path, write.message)
     case "commitClean":
       return commitClean(write.message)
     case "updateRef":

package/src/emit/index.ts

@@ -16,6 +16,9 @@ export {
   commitAll,
   commitAsIs,
   commitClean,
+  commitPath,
+  pinScript,
+  unpinScript,
   CHANGED_SINCE_LAND,
   softResetTo,
   mixedResetTo,

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/gherkin/messages.test.ts

@@ -45,6 +45,7 @@ describe("restDescription", () => {
         "  last commits:",
         "    chore: initial commit",
         "    gtd(agent): plan → sign-off",
+        "    gtd(check): pin → sign-off",
         '  actors never used: "repair" (scenario), "ready" (Background)',
       ].join("\n"),
     )

package/src/gherkin/module-config.feature

@@ -20,5 +20,6 @@ Feature: a scenario runs a workflow module from disk
     And the commit subjects end with:
       """
       gtd(agent): plan → sign-off
+      gtd(check): pin → sign-off
       """
 

package/src/gherkin/more-steps.feature

@@ -23,6 +23,7 @@ Feature: steps for checks, stalls, beat fields, commit bodies and the environmen
 
   Scenario: the resting step's fields are read by name
     When gtd starts workflow "tested"
+    And the process is driven
     Then the process rests at "build.plan"
     And the resting step's model is "smart"
     And the resting step's idle is "false"

package/src/gherkin/testkit.feature

@@ -43,6 +43,7 @@ Feature: testkit drives any workflow against the real engine
     And the commit subjects end with:
       """
       gtd(human): plan
+      gtd(check): pin → plan
       gtd(agent): plan → check
       gtd(check): check → ready
       gtd(judge): ready → ship
@@ -106,7 +107,7 @@ Feature: testkit drives any workflow against the real engine
     When gtd starts workflow "tiny"
     And the process is driven
     Then the process rests at "plan"
-    And the last commit subject is "gtd(human): plan"
+    And the last commit subject is "gtd(check): pin → plan"
 
   Scenario: a prompt asserted beside a script is checked at every visit, before the step acts
     Given step "check" is prompted with "npm test"

package/src/install/Install.ts

@@ -240,7 +240,13 @@ The \`kind\` field (\`--json=kind\`) selects what to do:
   Land it immediately, no display needed.
 - \`script\` — run \`--json=content\` with \`sh -c\`, appending its output to
   \`--json=log\`, and ignore its exit code — the outcome lives in the tree,
-  not in the exit code.
+  not in the exit code. Two script beats carry a \`pin\` mark: the **pin
+  beat** right after a process starts (\`pin: "add"\`, its script writes
+  \`gtd bundle\`'s output to \`.gtd/process.gtdpin\`) and the **unpin beat**
+  once the flow has ended (\`pin: "remove"\`, its script deletes that file).
+  Both run unattended, like any script beat. A driver may write or delete the
+  file its own way instead of running the script; either way it then lands,
+  and the unpin's landing is the commit that closes the process.
 - \`prompt\` — send plain \`gtd next\`'s own output to your agent CLI over
   stdin (it's the bare content at this kind, so no separate \`--json=content\`
   read is needed), using the accompanying \`session.id\`/\`session.resume\`/
@@ -284,7 +290,8 @@ skills, \`skills\` (an array of the skill names, already trimmed and split —
 \`label\`, \`file\`, \`mode\`, \`edges\`, \`judge\` (the pending judgment's rendered
 document). When a cost has been recorded (a prior \`gtd land --cost=<n>\`):
 \`cost\`, \`costByModel\`. Always \`approvals\` (an array of
-\`{step, name, email, commit}\`, \`[]\` when none).
+\`{step, name, email, commit}\`, \`[]\` when none). Only at a pin or unpin
+beat: \`pin\` (\`"add"\` or \`"remove"\`).
 
 \`gtd land\` fields, in fixed order: \`schema\`, \`script\` (the POSIX sh to run), \`settled\`
 (true for a no-op at a \`script\` rest — stop immediately, nothing more to

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)
     }),
   )

package/src/platform/WorktreeState.test.ts

@@ -12,10 +12,9 @@ import { mkdtempSync, realpathSync } from "node:fs"
 import { execSync } from "node:child_process"
 import { tmpdir } from "node:os"
 import { Effect, Layer } from "effect"
-import { NodeContext } from "@effect/platform-node"
 import { describe, expect, it } from "vitest"
 import { loopLogPath, worktreeGitDir } from "./WorktreeState.js"
-import { GitService, Host, Workspace } from "./index.js"
+import { GitService, Host, Workspace, NodeServices } from "./index.js"
 import { InMemRepo, testLayers } from "../twins/index.js"
 
 const provide = <A>(
@@ -112,7 +111,7 @@ describe("worktreeGitDir [real git]", () => {
 
   const runIn = (root: string) => {
     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 Effect.runPromise(
       worktreeGitDir.pipe(Effect.provide(Layer.mergeAll(hostLayer, workspaceLayer))),

package/src/platform/WorktreeState.ts

@@ -17,7 +17,7 @@ export const worktreeGitDir: Effect.Effect<string, never, Host | Workspace> = Ef
     const workspace = yield* Workspace
     const content = yield* workspace
       .read(".git")
-      .pipe(Effect.catchAll(() => Effect.succeed(undefined)))
+      .pipe(Effect.catch(() => Effect.succeed(undefined)))
     const pointer = content === undefined ? null : GITDIR_POINTER.exec(content)
     if (pointer === null) return ".git"
     const gitdir = pointer[1]!.trim()

package/src/platform/index.ts

@@ -4,7 +4,7 @@
  * home, env, scratch). `GitService` moved in alongside `Workspace` since
  * `committed` IS `git.readFileAtRef` — one module owns every read.
  *
- * Seam rule, stated once: a seam is a `Context.Tag` unless the consuming
+ * Seam rule, stated once: a seam is a `Context.Service` unless the consuming
  * code is synchronous, non-Effect code that cannot `yield*` — replay's flow
  * reads are that exception, and use the `*Sync` members.
  */
@@ -19,6 +19,7 @@ export {
 } from "./Git.js"
 export { Narrator, GtdError, GtdUsageError, renderFailure } from "./Commentary.js"
 export { CommandRunner } from "./CommandRunner.js"
+export * as NodeServices from "./NodeServices.js"
 export { loopLogPath } from "./WorktreeState.js"
 export {
   HISTORY_REF,