@pmelab/gtd 60.0.0 → 60.1.0

package/dist/testkit/gherkin.mjs

@@ -1,8 +1,8 @@
-import { n as runsItsScript, r as testRepo } from "../chunks/testkit-BvecVjQ0.mjs";
+import { n as runsItsScript, r as testRepo } from "../chunks/testkit-BhTey1Do.mjs";
 import { resolve } from "node:path";
-import assert from "node:assert";
 import { pathToFileURL } from "node:url";
 import { After, AfterAll, Given, QuickPickleWorld, Then, When, setWorldConstructor } from "quickpickle";
+import assert from "node:assert";
 //#region src/gherkin/messages.ts
 const CONTENT_LINES = 5;
 const reason = (error) => error instanceof Error ? error.message : String(error);

package/dist/testkit.mjs

@@ -1,3 +1,3 @@
 import { H as installContext } from "./chunks/flows-DENt0uWV.mjs";
-import { a as verdictWhen, i as verdict, n as runsItsScript, o as whenPrompted, r as testRepo, t as inTurn } from "./chunks/testkit-BvecVjQ0.mjs";
+import { a as verdictWhen, i as verdict, n as runsItsScript, o as whenPrompted, r as testRepo, t as inTurn } from "./chunks/testkit-BhTey1Do.mjs";
 export { inTurn, installContext, runsItsScript, testRepo, verdict, verdictWhen, whenPrompted };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "60.0.0",
+  "version": "60.1.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {
@@ -76,14 +76,14 @@
     "url": "https://github.com/pmelab/gtd.git"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=22.19.0"
   },
   "type": "module",
   "packageManager": "npm@11.17.0",
   "scripts": {
     "prepare": "husky",
     "dev": "node dev/run.mjs",
-    "build": "tsdown --filter web && npx @tailwindcss/cli -i src/web/styles.css -o dist/web/main.css --minify && node scripts/inline-web-client.mjs && tsdown --filter gtd && tsdown --filter entrypoints",
+    "build": "tsdown --filter web && npx @tailwindcss/cli -i src/web/styles.css -o dist/web/main.css --minify && node scripts/inline-web-client.mjs && tsdown --filter gtd --filter core && tsdown --filter entrypoints",
     "postbuild": "node scripts/assert-no-test-doubles.mjs",
     "watch": "tsdown --watch",
     "bench:replay": "node scripts/bench-replay.mjs",
@@ -141,6 +141,7 @@
     "fallow": "3.25.0",
     "fast-check": "^4.8.0",
     "husky": "^9.1.7",
+    "jiti": "^2.7.0",
     "lint-staged": "^17.0.8",
     "oxfmt": "^0.59.0",
     "oxlint": "^1.74.0",
@@ -173,12 +174,10 @@
     }
   },
   "dependencies": {
-    "@effect/platform": "^0.94.2",
-    "@effect/platform-node": "^0.104.1",
+    "@effect/platform-node-shared": "^4.1.0",
     "@standard-schema/spec": "^1.1.0",
     "@trpc/server": "^11.18.0",
-    "effect": "^3.19.15",
-    "jiti": "^2.7.0",
+    "effect": "^4.1.0",
     "mdast-util-from-markdown": "^2.0.3",
     "mdast-util-gfm-autolink-literal": "^2.0.1",
     "mdast-util-gfm-footnote": "^2.1.0",
@@ -188,6 +187,7 @@
     "micromark-extension-gfm-footnote": "^2.1.0",
     "micromark-extension-gfm-strikethrough": "^2.1.0",
     "micromark-extension-gfm-task-list-item": "^2.1.0",
+    "rolldown": "^1.1.5",
     "vscode-languageserver": "^10.1.0",
     "vscode-languageserver-textdocument": "^1.0.13"
   }

package/src/cli/Cli.test.ts

@@ -1537,7 +1537,7 @@ describe("runCli — stdout stays byte-empty on every failing surface", () => {
     repo.writeFile(".gtd/TODO.md", "## Open Questions\n\n###\n\nno question text.\n")
     const stdoutCalls: string[] = []
     const io: CliIo = {
-      stdout: (chunk) => stdoutCalls.push(chunk),
+      stdout: (chunk) => stdoutCalls.push(String(chunk)),
       stderr: () => {},
       exit: () => {},
       layers: () => testLayers(repo),
@@ -1548,7 +1548,7 @@ describe("runCli — stdout stays byte-empty on every failing surface", () => {
 })
 
 describe("nodeCliIo", () => {
-  const io = nodeCliIo(Layer.succeed(ToolCommands, {} as ToolCommands["Type"]))
+  const io = nodeCliIo(Layer.succeed(ToolCommands, {} as ToolCommands["Service"]))
 
   it("exposes stdout/stderr/exit/layers", () => {
     expect(typeof io.stdout).toBe("function")

package/src/cli/Cli.ts

@@ -1,5 +1,4 @@
-import { NodeContext } from "@effect/platform-node"
-import { Cause, Effect, Either, Layer } from "effect"
+import { Cause, Effect, Layer, Result } from "effect"
 import {
   GtdError,
   GtdUsageError,
@@ -9,6 +8,7 @@ import {
   Host,
   Workspace,
   CommandRunner,
+  NodeServices,
 } from "../platform/index.js"
 import {
   flagSettings,
@@ -20,6 +20,7 @@ import { GTD_VERSION } from "../install/index.js"
 import {
   ConfigDiscovery,
   ConfigService,
+  EngineCore,
   isSettingName,
   SETTING_NAME_RULE,
   StartFlags,
@@ -75,7 +76,7 @@ interface FlagRow {
   readonly repeatable: boolean
   readonly scope: FlagScope
   /** All raw occurrences (already de-`=`-ed) → the decoded value, or an error message. */
-  readonly decode: (raws: readonly string[]) => Either.Either<unknown, string>
+  readonly decode: (raws: readonly string[]) => Result.Result<unknown, string>
   readonly scopeError: string
   readonly valueHint: string
   /** One sentence for a command's help, wrapped when rendered; `helpFor` overrides it for a command the flag means something else on. */
@@ -89,40 +90,40 @@ interface FlagRow {
 const decodeAssignments = (
   flag: string,
   raws: readonly string[],
-): Either.Either<Readonly<Record<string, string>>, string> => {
+): Result.Result<Readonly<Record<string, string>>, string> => {
   const vars: Record<string, string> = {}
   for (const raw of raws) {
     const eq = raw.indexOf("=")
     if (eq <= 0) {
-      return Either.left(`gtd: ${flag} must be <name>=<value> with a non-empty name — got "${raw}"`)
+      return Result.fail(`gtd: ${flag} must be <name>=<value> with a non-empty name — got "${raw}"`)
     }
     const name = raw.slice(0, eq)
     const value = raw.slice(eq + 1)
     if (!isSettingName(name)) {
-      return Either.left(
+      return Result.fail(
         `gtd: ${flag} ${JSON.stringify(name)} is not a valid setting name — ${SETTING_NAME_RULE}`,
       )
     }
-    if (/[\r\n]/.test(value)) return Either.left(`gtd: ${flag} ${name} must be a single-line value`)
+    if (/[\r\n]/.test(value)) return Result.fail(`gtd: ${flag} ${name} must be a single-line value`)
     if (Object.hasOwn(vars, name))
-      return Either.left(`gtd: ${flag} ${name} specified more than once`)
+      return Result.fail(`gtd: ${flag} ${name} specified more than once`)
     if (!name.startsWith("flag_")) {
       vars[name] = value
       continue
     }
     const pinned = flagSettingValue(value)
-    if (pinned === undefined) return Either.left(`gtd: ${flag} ${name} must be 1, 0, true or false`)
+    if (pinned === undefined) return Result.fail(`gtd: ${flag} ${name} must be 1, 0, true or false`)
     vars[name] = pinned
   }
-  return Either.right(vars)
+  return Result.succeed(vars)
 }
 
-const nonNegativeNumber = (raw: string, flag: string): Either.Either<number, string> => {
+const nonNegativeNumber = (raw: string, flag: string): Result.Result<number, string> => {
   const n = Number(raw)
   if (raw.trim() === "" || !Number.isFinite(n) || n < 0) {
-    return Either.left(`gtd: ${flag} must be a non-negative number — got "${raw}"`)
+    return Result.fail(`gtd: ${flag} must be a non-negative number — got "${raw}"`)
   }
-  return Either.right(n)
+  return Result.succeed(n)
 }
 
 /** The commands whose only output is a script: `--json` prints `{ schema, script }`. */
@@ -155,7 +156,7 @@ const FLAGS: readonly FlagRow[] = [
     arity: "optional",
     repeatable: false,
     scope: (kind) => JSON_KINDS.has(kind),
-    decode: ([raw]) => Either.right(raw ?? ""),
+    decode: ([raw]) => Result.succeed(raw ?? ""),
     scopeError:
       "gtd: --json is only valid for `gtd next`/`gtd land`, the commands that print a script, and the listings whose help names it (e.g. `gtd strays`) — " +
       "every other command prints plain text; see `gtd guide` for the driver protocol briefing",
@@ -175,8 +176,8 @@ const FLAGS: readonly FlagRow[] = [
     decode: ([raw]) => {
       const n = Number(raw)
       return raw !== undefined && Number.isInteger(n) && n >= 0 && n <= 65535
-        ? Either.right(n)
-        : Either.left(`gtd: --port must be an integer 0–65535 (got '${raw ?? ""}')`)
+        ? Result.succeed(n)
+        : Result.fail(`gtd: --port must be an integer 0–65535 (got '${raw ?? ""}')`)
     },
     scopeError: "gtd: --port is only valid for `gtd ui`",
     valueHint: "<n>",
@@ -189,8 +190,8 @@ const FLAGS: readonly FlagRow[] = [
     scope: (kind) => kind === "ui",
     decode: ([raw]) =>
       raw === undefined || raw.trim() === "" || /[\r\n]/.test(raw)
-        ? Either.left("gtd: --host must be a non-empty, single-line value")
-        : Either.right(raw),
+        ? Result.fail("gtd: --host must be a non-empty, single-line value")
+        : Result.succeed(raw),
     scopeError: "gtd: --host is only valid for `gtd ui`",
     valueHint: "<addr>",
     help: "Bind this address directly instead of publishing through tailscale serve",
@@ -200,7 +201,7 @@ const FLAGS: readonly FlagRow[] = [
     arity: 0,
     repeatable: false,
     scope: (kind) => kind === "ui",
-    decode: () => Either.right(true),
+    decode: () => Result.succeed(true),
     scopeError: "gtd: --self-signed is only valid for `gtd ui`",
     valueHint: "",
     help: "Bind directly with a throwaway self-signed certificate instead of the configured ui.cert/ui.key",
@@ -210,7 +211,7 @@ const FLAGS: readonly FlagRow[] = [
     arity: 0,
     repeatable: false,
     scope: (kind) => kind === "ui",
-    decode: () => Either.right(true),
+    decode: () => Result.succeed(true),
     scopeError: "gtd: --dev is only valid for `gtd ui`",
     valueHint: "",
     help: "Serve local development sources instead of the packaged build",
@@ -222,8 +223,8 @@ const FLAGS: readonly FlagRow[] = [
     scope: (kind) => kind === "judgeRun",
     decode: ([raw]) =>
       raw === "fixed" || raw === "jev" || raw === "llm"
-        ? Either.right(raw)
-        : Either.left(`gtd: --provider must be one of fixed, jev, llm — got "${raw ?? ""}"`),
+        ? Result.succeed(raw)
+        : Result.fail(`gtd: --provider must be one of fixed, jev, llm — got "${raw ?? ""}"`),
     scopeError: "gtd: --provider is only valid for `gtd judge run`",
     valueHint: "<name>",
     help: "The answerer: fixed, jev or llm (default: $GTD_JUDGE_PROVIDER, then ~/.config/gtd/judge.json, then jev when $TYPESAFE_API_KEY is set, else llm)",
@@ -235,8 +236,8 @@ const FLAGS: readonly FlagRow[] = [
     scope: (kind) => kind === "judgeRun",
     decode: ([raw]) =>
       raw === undefined || raw === ""
-        ? Either.left("gtd: --answers must be a non-empty path")
-        : Either.right(raw),
+        ? Result.fail("gtd: --answers must be a non-empty path")
+        : Result.succeed(raw),
     scopeError: "gtd: --answers is only valid for `gtd judge run`",
     valueHint: "<path>",
     help: "With --provider fixed: a JSON verdict file [{ id, answer, p }] (default: $GTD_JUDGE_ANSWERS, inline JSON)",
@@ -258,8 +259,8 @@ const FLAGS: readonly FlagRow[] = [
     scope: (kind) => kind === "land" || kind === "judgeRun",
     decode: ([raw]) =>
       raw === undefined || raw.trim() === "" || /[\r\n]/.test(raw)
-        ? Either.left("gtd: --model must be a non-empty, single-line value")
-        : Either.right(raw),
+        ? Result.fail("gtd: --model must be a non-empty, single-line value")
+        : Result.succeed(raw),
     scopeError:
       "gtd: --model is only valid for `gtd land` (with --cost: the model to record the cost against) or `gtd judge run` (the model that answers)",
     valueHint: "<name>",
@@ -295,7 +296,7 @@ const FLAGS: readonly FlagRow[] = [
     arity: 0,
     repeatable: false,
     scope: (kind) => kind === "historyJudges",
-    decode: () => Either.right(true),
+    decode: () => Result.succeed(true),
     scopeError: "gtd: --jsonl is only valid for `gtd history judges`",
     valueHint: "",
     help: "Print one JSON line per verdict instead of the report",
@@ -306,7 +307,7 @@ const FLAGS: readonly FlagRow[] = [
     arity: 0,
     repeatable: false,
     scope: (kind) => kind === "check",
-    decode: () => Either.right(true),
+    decode: () => Result.succeed(true),
     scopeError: "gtd: --open-questions is only valid for `gtd check`",
     valueHint: "",
     help: "Instead of <mode>'s findings, list the unanswered questions in <file>; exits 1 when any remain",
@@ -316,7 +317,7 @@ const FLAGS: readonly FlagRow[] = [
     arity: 0,
     repeatable: false,
     scope: (kind) => kind === "check",
-    decode: () => Either.right(true),
+    decode: () => Result.succeed(true),
     scopeError: "gtd: --open-threads is only valid for `gtd check`",
     valueHint: "",
     help: "Instead of <mode>'s findings, list the open threads in <file>; exits 1 when any are open. Alone, lists the open code-comment threads in the files the current process changed",
@@ -326,7 +327,7 @@ const FLAGS: readonly FlagRow[] = [
     arity: 0,
     repeatable: false,
     scope: () => true,
-    decode: () => Either.right(true),
+    decode: () => Result.succeed(true),
     scopeError: "gtd: --verbose is valid for every command — this error is unreachable",
     valueHint: "",
     help: "Narrate on stderr what gtd resolved and where its config came from",
@@ -533,6 +534,14 @@ Prints a sorted JSON array ([] when clean) and a summary on stderr; --verbose ad
     summary: "Print a briefing for writing a driver",
     details: `Print a self-contained briefing that teaches an agent or a person to build a gtd driver in any shell or runtime, and where to get a workflow — gtd ships none. Writes nothing.`,
   },
+  {
+    token: "bundle",
+    kind: "bundle",
+    arity: "none",
+    group: "Driver plumbing",
+    summary: "Print the pin of the current workflow",
+    details: `Print a pin to stdout: gtd's engine and the current workflow — gtd.config.ts, every module it imports and every npm package they use — as one gzipped ES module, after a plain-text header line \`gtdpin <format> gtd <version>\`. Git diffs it as binary. Refuses a workflow gtd would refuse, and a package that loads a native addon (.node), naming it. Writes nothing.`,
+  },
   {
     token: "judge",
     kind: "judge",
@@ -916,7 +925,7 @@ const pairArityError = (
 /** Decode every present flag into a bag of values, or the first decode error encountered. */
 const decodeFlags = (
   byFlag: ReadonlyMap<string, readonly string[]>,
-): Either.Either<Readonly<Record<string, unknown>>, string> => {
+): Result.Result<Readonly<Record<string, unknown>>, string> => {
   const bag: Record<string, unknown> = {}
   for (const row of FLAGS) {
     const raws = byFlag.get(row.name)
@@ -925,19 +934,19 @@ const decodeFlags = (
     // to decode — presence alone is tracked via `present`, not the bag.
     if (row.arity === "optional" && raws.length === 0) continue
     const decoded = row.decode(raws)
-    if (Either.isLeft(decoded)) return Either.left(decoded.left)
-    bag[row.name] = decoded.right
+    if (Result.isFailure(decoded)) return Result.fail(decoded.failure)
+    bag[row.name] = decoded.success
   }
-  return Either.right(bag)
+  return Result.succeed(bag)
 }
 
 /** `gtd history judges`' thresholds: each a known judge threshold with a numeric value. */
 const judgeThresholds = (
   thresholds: Readonly<Record<string, string>>,
-): Either.Either<Readonly<Record<string, string>>, string> => {
+): Result.Result<Readonly<Record<string, string>>, string> => {
   const unknown = Object.keys(thresholds).find((name) => !Object.hasOwn(THRESHOLDS, name))
   if (unknown !== undefined) {
-    return Either.left(
+    return Result.fail(
       `gtd history judges: --threshold ${unknown} is no judge threshold — use ${Object.keys(THRESHOLDS).join(" or ")}`,
     )
   }
@@ -945,11 +954,11 @@ const judgeThresholds = (
     ([, value]) => value.trim() === "" || !Number.isFinite(Number(value)),
   )
   if (nan !== undefined) {
-    return Either.left(
+    return Result.fail(
       `gtd history judges: --threshold ${nan[0]} must be a number — got "${nan[1]}"`,
     )
   }
-  return Either.right(thresholds)
+  return Result.succeed(thresholds)
 }
 
 /** Assembles a `land` `Command` from its already-scope-checked flag bag — split out of `parseArgv` so its two independent, omit-when-absent optional fields don't inflate that function's own branching. */
@@ -1087,8 +1096,8 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
   if (conflict !== undefined) return usagePlan(conflict, jsonSeen)
 
   const decoded = decodeFlags(byFlag)
-  if (Either.isLeft(decoded)) return usagePlan(decoded.left, jsonSeen)
-  const bag = decoded.right as {
+  if (Result.isFailure(decoded)) return usagePlan(decoded.failure, jsonSeen)
+  const bag = decoded.success as {
     readonly "--json"?: string
     readonly "--port"?: number
     readonly "--cost"?: number
@@ -1231,8 +1240,8 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
 
   if (kind === "historyJudges") {
     const thresholds = judgeThresholds(bag["--threshold"] ?? {})
-    if (Either.isLeft(thresholds)) return usagePlan(thresholds.left, jsonSeen)
-    const vars = thresholds.right
+    if (Result.isFailure(thresholds)) return usagePlan(thresholds.failure, jsonSeen)
+    const vars = thresholds.success
     return {
       kind: "command",
       command: {
@@ -1295,6 +1304,7 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
       | "next"
       | "validate"
       | "guide"
+      | "bundle"
       | "base"
       | "judge"
       | "judgeAnswer"
@@ -1308,7 +1318,7 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
 // ---------------------------------------------------------------------------
 
 export interface CliIo {
-  readonly stdout: (chunk: string) => void
+  readonly stdout: (chunk: string | Uint8Array) => void
   readonly stderr: (chunk: string) => void
   readonly exit: (code: number) => void
   /**
@@ -1333,7 +1343,7 @@ const writeStderr = (chunk: string): void => {
 export type LiveToolCommands = Layer.Layer<
   ToolCommands,
   never,
-  Exclude<CommandRequirements, ToolCommands> | NodeContext.NodeContext
+  Exclude<CommandRequirements, ToolCommands> | NodeServices.NodeServices
 >
 
 export const nodeCliIo = (tools: LiveToolCommands): CliIo => ({
@@ -1358,20 +1368,21 @@ export const nodeCliIo = (tools: LiveToolCommands): CliIo => ({
   // "command"`, so --version/--help/a usage error never provoke it.
   layers: (verbose) =>
     // Dependency order matters: Workspace.Live needs GitService, both need
-    // Host, and GitService needs NodeContext's CommandExecutor. Each
+    // Host, and GitService needs NodeServices' ChildProcessSpawner. Each
     // `provideMerge` satisfies the layers above it AND stays in the output.
     tools.pipe(
       Layer.provideMerge(
         Layer.mergeAll(
           ConfigService.Live,
           ConfigDiscovery.Live,
+          EngineCore.Live,
           Workspace.Live,
           Narrator.layer(writeStderr, verbose),
           CommandRunner.Live,
         ).pipe(
           Layer.provideMerge(GitService.Live),
           Layer.provideMerge(Host.Live),
-          Layer.provideMerge(NodeContext.layer),
+          Layer.provideMerge(NodeServices.layer),
         ),
       ),
     ),
@@ -1386,14 +1397,20 @@ export const nodeCliIo = (tools: LiveToolCommands): CliIo => ({
 export const normalizeTrailingNewline = (artifact: string): string =>
   artifact.length === 0 ? artifact : `${artifact.replace(/\n+$/, "")}\n`
 
+// Bytes are a binary artifact, written as they are.
 const bufferedArtifactOut = (io: CliIo): ArtifactOut => {
-  let buffer = ""
+  let buffer: string | Uint8Array = ""
   return {
     write: (chunk) => {
-      buffer += chunk
+      buffer =
+        typeof buffer === "string" && typeof chunk === "string"
+          ? buffer + chunk
+          : Buffer.concat([Buffer.from(buffer), Buffer.from(chunk)])
     },
     flush: () => {
-      if (buffer.length > 0) io.stdout(normalizeTrailingNewline(buffer))
+      if (buffer.length > 0) {
+        io.stdout(typeof buffer === "string" ? normalizeTrailingNewline(buffer) : buffer)
+      }
       buffer = ""
     },
   }
@@ -1479,8 +1496,8 @@ export const runCli = (argv: readonly string[], io: CliIo): Effect.Effect<void,
     // (Ctrl-C on `ui`/`lsp`'s blocking `Effect.never`) is passed
     // through untouched via `failCause` so `NodeRuntime.runMain` still sees a
     // real interruption; everything else gets the envelope.
-    Effect.catchAll((cause) =>
-      Cause.isInterruptedOnly(cause)
+    Effect.catch((cause) =>
+      Cause.hasInterruptsOnly(cause)
         ? Effect.failCause(cause)
         : report(io, plan.json.kind !== "off")(cause),
     ),

package/src/cli/Output.test.ts

@@ -5,7 +5,7 @@ import { writeScript, type JsonMode } from "./Output.js"
 
 const run = (json: JsonMode, script: string, plain?: string) => {
   let written = ""
-  const out = { write: (chunk: string) => (written += chunk), flush: () => {} }
+  const out = { write: (chunk: string | Uint8Array) => (written += String(chunk)), flush: () => {} }
   const exit = Effect.runSyncExit(writeScript(json, out, script, plain))
   return { exit, written }
 }

package/src/cli/Output.ts

@@ -7,7 +7,7 @@ import {
   type EXIT_OK,
   type EXIT_STRAYS_FOUND,
 } from "../wire/index.js"
-import { ConfigDiscovery, ConfigService } from "../workflow/index.js"
+import { ConfigDiscovery, ConfigService, EngineCore } from "../workflow/index.js"
 import type { ToolCommands } from "./ToolCommands.js"
 
 /**
@@ -59,7 +59,7 @@ export type JsonMode =
  * reach stdout.
  */
 export interface ArtifactOut {
-  readonly write: (chunk: string) => void
+  readonly write: (chunk: string | Uint8Array) => void
   readonly flush: () => void
 }
 
@@ -67,6 +67,7 @@ export type CommandRequirements =
   | GitService
   | ConfigService
   | ConfigDiscovery
+  | EngineCore
   | Workspace
   | Host
   | Narrator

package/src/cli/Program.test.ts

@@ -1712,6 +1712,7 @@ describe("runCommand — refuses in a repository with no commits", () => {
     check: { kind: "check", mode: "qa", file: ".gtd/TODO.md" },
     uncheck: { kind: "uncheck", file: ".gtd/REVIEW.md" },
     guide: { kind: "guide" },
+    bundle: { kind: "bundle" },
     summary: { kind: "summary" },
     base: { kind: "base" },
     judge: { kind: "judge" },
@@ -1732,11 +1733,12 @@ describe("runCommand — refuses in a repository with no commits", () => {
   const NO_COMMITS_MESSAGE =
     "gtd: the repository has no commits yet — make an initial commit, then run gtd again"
 
-  it("derives exactly the sixteen non-standalone kinds — a canary for the table-driven cases below", () => {
+  it("derives exactly the seventeen non-standalone kinds — a canary for the table-driven cases below", () => {
     expect(stateKinds.sort()).toEqual(
       [
         "abandon",
         "base",
+        "bundle",
         "start",
         "land",
         "next",
@@ -1761,7 +1763,10 @@ describe("runCommand — refuses in a repository with no commits", () => {
       const repo = new InMemRepo()
       const before = repo.commitHistory().length
       const written: string[] = []
-      const out = { write: (chunk: string) => written.push(chunk), flush: () => {} }
+      const out = {
+        write: (chunk: string | Uint8Array) => written.push(String(chunk)),
+        flush: () => {},
+      }
 
       const exit = await Effect.runPromiseExit(
         runCommand(commandFor[kind], { kind: "off" }, out).pipe(Effect.provide(testLayers(repo))),
@@ -1780,7 +1785,10 @@ describe("runCommand — refuses in a repository with no commits", () => {
   it("a repository with a commit passes the guard and dispatches normally", async () => {
     const repo = seedIdle()
     const written: string[] = []
-    const out = { write: (chunk: string) => written.push(chunk), flush: () => {} }
+    const out = {
+      write: (chunk: string | Uint8Array) => written.push(String(chunk)),
+      flush: () => {},
+    }
 
     const exit = await Effect.runPromiseExit(
       runCommand({ kind: "next" }, { kind: "off" }, out).pipe(Effect.provide(testLayers(repo))),
@@ -2090,7 +2098,7 @@ describe("gtd next/land --json=<path> — the select branch", () => {
     )
     expect(Exit.isFailure(exit)).toBe(true)
     if (Exit.isFailure(exit)) {
-      const failure = Cause.failureOption(exit.cause)
+      const failure = Cause.findErrorOption(exit.cause)
       expect(failure._tag).toBe("Some")
       if (failure._tag === "Some") {
         expect(failure.value).toBeInstanceOf(SelectorUsageError)
@@ -2297,8 +2305,8 @@ export default workflow(
 describe("runCommand — the repository-root guard's messages", () => {
   const guarded = async (
     override: (
-      git: Context.Tag.Service<GitService>,
-      host: Context.Tag.Service<Host>,
+      git: Context.Service.Shape<typeof GitService>,
+      host: Context.Service.Shape<typeof Host>,
     ) => Effect.Effect<unknown, Error, CommandRequirements>,
   ): Promise<string> => {
     const exit = await Effect.runPromiseExit(