@pmelab/gtd 63.0.0 → 64.0.0

package/dist/steering.mjs

@@ -1,2 +1,2 @@
-import { A as parseThreads, C as FREE_TEXT_PLACEHOLDER, D as findingEntries, E as NOISE_HEADING, N as formatFinding, O as openThreadFindings, S as unansweredNotes, T as FIX_BOX, _ as reviewChunks, a as sections, b as reviewRisks, c as openThreads, d as freeFormFormat, f as applySteeringEdits, g as REVIEW_SECTIONS, h as ANSWER_WONT_FIX, i as sectionBodies, j as parseThreadsWithFindings, k as parseFootnotes, l as steeringFormatFor, m as ANSWER_LEAD, n as stripCodeThreads, o as threads, p as ANSWER_FIX, r as openQuestions, t as parseCodeThreads, v as reviewDecisions, w as isAnswered, x as reviewSections, y as reviewNotes } from "./chunks/steering-DF_BMadH.mjs";
+import { A as parseThreads, C as FREE_TEXT_PLACEHOLDER, D as findingEntries, E as NOISE_HEADING, N as formatFinding, O as openThreadFindings, S as unansweredNotes, T as FIX_BOX, _ as reviewChunks, a as sections, b as reviewRisks, c as openThreads, d as freeFormFormat, f as applySteeringEdits, g as REVIEW_SECTIONS, h as ANSWER_WONT_FIX, i as sectionBodies, j as parseThreadsWithFindings, k as parseFootnotes, l as steeringFormatFor, m as ANSWER_LEAD, n as stripCodeThreads, o as threads, p as ANSWER_FIX, r as openQuestions, t as parseCodeThreads, v as reviewDecisions, w as isAnswered, x as reviewSections, y as reviewNotes } from "./chunks/steering-DkA51qDa.mjs";
 export { ANSWER_FIX, ANSWER_LEAD, ANSWER_WONT_FIX, FIX_BOX, FREE_TEXT_PLACEHOLDER, NOISE_HEADING, REVIEW_SECTIONS, applySteeringEdits, findingEntries, formatFinding, freeFormFormat, isAnswered, openQuestions, openThreadFindings, openThreads, parseCodeThreads, parseFootnotes, parseThreads, parseThreadsWithFindings, reviewChunks, reviewDecisions, reviewNotes, reviewRisks, reviewSections, sectionBodies, sections, steeringFormatFor, stripCodeThreads, threads, unansweredNotes };

package/dist/testkit/gherkin.mjs

@@ -1,6 +1,6 @@
-import { n as runsItsScript, r as testRepo } from "../chunks/testkit-DwypA7cH.mjs";
-import { resolve } from "node:path";
+import { n as runsItsScript, r as testRepo } from "../chunks/testkit-zGjNeQNL.mjs";
 import { pathToFileURL } from "node:url";
+import { resolve } from "node:path";
 import { After, AfterAll, Given, QuickPickleWorld, Then, When, setWorldConstructor } from "quickpickle";
 import assert from "node:assert";
 //#region src/gherkin/messages.ts

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-DwypA7cH.mjs";
+import { H as installContext } from "./chunks/flows-B7ZRCe-B.mjs";
+import { a as verdictWhen, i as verdict, n as runsItsScript, o as whenPrompted, r as testRepo, t as inTurn } from "./chunks/testkit-zGjNeQNL.mjs";
 export { inTurn, installContext, runsItsScript, testRepo, verdict, verdictWhen, whenPrompted };

package/dist/workflow-kit.mjs

@@ -1,5 +1,5 @@
-import { B as head, F as changesSince, G as mark, P as changes, X as read, Z as refuse, d as hasThreadFor, et as scope, g as requireReplies, v as requireThreadsClosed } from "./chunks/flows-DENt0uWV.mjs";
-import { A as parseThreads, S as unansweredNotes, b as reviewRisks, n as stripCodeThreads, v as reviewDecisions, y as reviewNotes } from "./chunks/steering-DF_BMadH.mjs";
+import { B as head, F as changesSince, G as mark, P as changes, X as read, Z as refuse, d as hasThreadFor, et as scope, g as requireReplies, v as requireThreadsClosed } from "./chunks/flows-B7ZRCe-B.mjs";
+import { A as parseThreads, S as unansweredNotes, b as reviewRisks, n as stripCodeThreads, v as reviewDecisions, y as reviewNotes } from "./chunks/steering-DkA51qDa.mjs";
 //#region src/workflow-kit/health.ts
 /** Hand a red suite that repeated attempts could not fix to a person, until `limit` rounds are spent. */
 const escalation = async (count, steps) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "63.0.0",
+  "version": "64.0.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {

package/src/cli/Cli.test.ts

@@ -25,7 +25,7 @@ import {
 import { EXIT_CODES, EXIT_RUNTIME_ERROR, EXIT_USAGE_ERROR } from "../wire/index.js"
 import { Host } from "../platform/index.js"
 import { type CommandRequirements } from "./Cli.js"
-import { InMemRepo, makeCapturingCliIo, testLayers } from "../twins/index.js"
+import { InMemRepo, inMemoryHost, makeCapturingCliIo, testLayers } from "../twins/index.js"
 
 const FLAG_NAMES = [
   "--json",
@@ -1342,13 +1342,10 @@ describe("runCli — a garbled GTD_FLAG_* value", () => {
   it("exits 1 naming the variable", async () => {
     const { io, captured } = capturingIo(
       () =>
-        Layer.succeed(Host, {
-          root: "/",
-          home: "/",
-          scratchDir: "/",
-          realPath: (p: string) => Effect.succeed(p),
-          env: { GTD_FLAG_BETA: "ture" },
-        }) as unknown as Layer.Layer<CommandRequirements>,
+        Layer.succeed(
+          Host,
+          inMemoryHost("/", "/", { GTD_FLAG_BETA: "ture" }),
+        ) as unknown as Layer.Layer<CommandRequirements>,
     )
     await Effect.runPromise(
       runCli(["node", "gtd.js", "next"], {

package/src/cli/Cli.ts

@@ -9,6 +9,8 @@ import {
   Workspace,
   CommandRunner,
   NodeServices,
+  nodeStdio,
+  type Stdio,
 } from "../platform/index.js"
 import {
   flagSettings,
@@ -1334,10 +1336,7 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
 // runCli
 // ---------------------------------------------------------------------------
 
-export interface CliIo {
-  readonly stdout: (chunk: string | Uint8Array) => void
-  readonly stderr: (chunk: string) => void
-  readonly exit: (code: number) => void
+export interface CliIo extends Stdio {
   /**
    * Deferred thunk — a layer is built only for a resolved `Command`, never
    * for `--version`/`--help`/a usage error. `verbose` (`--verbose`/`-v`,
@@ -1349,13 +1348,10 @@ export interface CliIo {
   readonly flags?: readonly FlagDeclaration[]
 }
 
-// The one write-to-stderr primitive nodeCliIo uses for both `stderr` (errors)
-// and `layers`'s `Narrator` (narration) — same sink, so a real invocation's
-// narration and its remediation interleave on the same fd exactly as
-// written.
-const writeStderr = (chunk: string): void => {
-  process.stderr.write(chunk)
-}
+// `nodeCliIo` hands this one sink to both `stderr` (errors) and `layers`'s
+// `Narrator` (narration), so a real invocation's narration and its
+// remediation interleave on the same fd exactly as written.
+const stdio = nodeStdio()
 
 export type LiveToolCommands = Layer.Layer<
   ToolCommands,
@@ -1364,21 +1360,7 @@ export type LiveToolCommands = Layer.Layer<
 >
 
 export const nodeCliIo = (tools: LiveToolCommands): CliIo => ({
-  // `process.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) => {
-    process.stdout.write(chunk, () => {})
-  },
-  stderr: writeStderr,
-  exit: (code) => {
-    // 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 run to completion — draining
-    // any queued write — before Node exits gracefully with this code.
-    process.exitCode = code
-  },
+  ...stdio,
   // A Layer is a lazy description, not a running service — building this
   // object touches no filesystem/git; only `Effect.provide` running the
   // result does. `runCli` calls this thunk exactly when `plan.kind ===
@@ -1394,7 +1376,7 @@ export const nodeCliIo = (tools: LiveToolCommands): CliIo => ({
           ConfigDiscovery.Live,
           EngineCore.Live,
           Workspace.Live,
-          Narrator.layer(writeStderr, verbose),
+          Narrator.layer(stdio.stderr, verbose),
           CommandRunner.Live,
         ).pipe(
           Layer.provideMerge(GitService.Live),

package/src/cli/Output.ts

@@ -1,4 +1,4 @@
-import { Effect } from "effect"
+import { Effect, type Path } from "effect"
 import { CommandRunner, GitService, Host, Narrator, Workspace } from "../platform/index.js"
 import {
   renderScriptJson,
@@ -70,6 +70,7 @@ export type CommandRequirements =
   | EngineCore
   | Workspace
   | Host
+  | Path.Path
   | Narrator
   | CommandRunner
   | ToolCommands

package/src/cli/Program.test.ts

@@ -5,8 +5,7 @@
  */
 
 import { Cause, Context, Effect, Exit } from "effect"
-import { PassThrough } from "node:stream"
-import { afterEach, describe, expect, it, vi } from "vitest"
+import { describe, expect, it, vi } from "vitest"
 
 // `gtd ui`'s bind-host lookup reads the real `os.networkInterfaces()` — a host
 // on a tailnet would make the "no Tailscale interface" refusal below fail.
@@ -24,6 +23,8 @@ import {
   testLayers,
   applyEmittedScript,
   takePinBeat,
+  IN_MEMORY_PID,
+  IN_MEMORY_SCRATCH,
 } from "../twins/index.js"
 import {
   commitAll,
@@ -110,7 +111,7 @@ export const hotfix = workflow(
     expect(exitCode).toBe(0)
     expect(stdout).toContain(
       commitAll(
-        `gtd(human): working\n\nGtd-Workflow: hotfix\nGtd-Var: greeting=hello\nGtd-Format: 3`,
+        `gtd(human): working\n\nGtd-Workflow: hotfix\nGtd-Var: greeting=hello\nGtd-Format: 4`,
       ),
     )
     expect(repo.commitHistory()).toHaveLength(before)
@@ -197,7 +198,7 @@ export const hotfix = workflow(
     expect(applyEmittedScript(repo, new Map(), stdout).ok).toBe(true)
     expect(repo.lastCommitSubject()).toBe("gtd(human): working")
     const pin = JSON.parse((await run(repo, "next", "--json")).stdout) as Record<string, unknown>
-    expect(pin).toMatchObject({ kind: "script", state: "pin", actor: "check", pin: "add" })
+    expect(pin).toMatchObject({ kind: "script", state: "gtd:pin", actor: "check", pin: "add" })
     expect(await takePinBeat(repo, "add")).toBe(true)
     const next = JSON.parse((await run(repo, "next", "--json")).stdout) as Record<string, unknown>
     expect(next.kind).toBe("prompt")
@@ -673,7 +674,7 @@ describe("gtd validate — the mode-contradiction round-trip", () => {
     const { stdout, exitCode } = await runEnv(repo, { TMPDIR: "/fixture-scratch" }, "validate")
     expect(exitCode).toBe(0)
 
-    const samplePath = `/fixture-scratch/gtd-mode-sample-qa-${process.pid}.md`
+    const samplePath = `/fixture-scratch/gtd-mode-sample-qa-${IN_MEMORY_PID}.md`
     const roundTripIndex = stdout.indexOf(`printf '%s' `)
     const guardIndex = stdout.indexOf(`[ -f '.gtd/PLAN.md' ] || exit 0`)
     // The real format command, distinct from the round-trip's own copy
@@ -724,11 +725,11 @@ describe("gtd validate — the mode-contradiction round-trip", () => {
     expect(stdout).not.toContain("skipping")
   })
 
-  it("resolves the scratch dir from node:os's tmpdir() when TMPDIR is unset or empty", async () => {
+  it("falls back to the host's own scratch dir when TMPDIR is unset", async () => {
     const repo = await atWorking(`{ qa: { format: "my-formatter $GTD_FILE" } }`)
     const { stdout, exitCode } = await runEnv(repo, {}, "validate")
     expect(exitCode).toBe(0)
-    expect(stdout).toContain(`gtd-mode-sample-qa-${process.pid}.md`)
+    expect(stdout).toContain(`${IN_MEMORY_SCRATCH}/gtd-mode-sample-qa-${IN_MEMORY_PID}.md`)
   })
 
   it("gtd validate the COMMAND exits 0 even when the emitted SCRIPT would fail if run — gtd only prints it", async () => {
@@ -791,14 +792,14 @@ describe("gtd next — refuses when history diverges from what replay reaches",
 
 describe("a history written in a format this gtd does not read", () => {
   // The exact wording is pinned in Format.test.ts; this is the part that proves the format gate fired.
-  const FOREIGN = "is written in history format 4, but this gtd reads formats 1 to 3"
+  const FOREIGN = "is written in history format 5, but this gtd reads formats 1 to 4"
 
   /** A step commit that would also diverge, so only the format gate can explain the refusal. */
   const foreignStep = async (): Promise<InMemRepo> => {
     const repo = seed(IDLE_THEN_WORKING)
     await landTurn(repo, { "NOTE.md": "a note\n" })
     repo.writeFile("WORK.md", "done\n")
-    repo.seedCommit("gtd(agent): elsewhere → review\n\nGtd-Step: elsewhere#1\nGtd-Format: 4")
+    repo.seedCommit("gtd(agent): elsewhere → review\n\nGtd-Step: elsewhere#1\nGtd-Format: 5")
     return repo
   }
 
@@ -823,7 +824,7 @@ describe("a history written in a format this gtd does not read", () => {
   it("refuses even when a foreign subject hides the commit from the episode", async () => {
     const repo = seed(IDLE_THEN_WORKING)
     repo.writeFile("NOTE.md", "a note\n")
-    repo.seedCommit("gtd2[human] idle -> working\n\nGtd-Format: 4")
+    repo.seedCommit("gtd2[human] idle -> working\n\nGtd-Format: 5")
     for (const command of ["next", "abandon"]) {
       const { exitCode, stderr } = await run(repo, command)
       expect(exitCode).toBe(1)
@@ -834,7 +835,7 @@ describe("a history written in a format this gtd does not read", () => {
   it("a commit gtd never wrote is not read for a format, even quoting the trailer", async () => {
     const repo = seed(IDLE_THEN_WORKING)
     repo.writeFile("NOTE.md", "a note\n")
-    repo.seedCommit("feat: x\n\nGtd-Format: 4")
+    repo.seedCommit("feat: x\n\nGtd-Format: 5")
     expect((await run(repo, "next")).exitCode).toBe(0)
   })
 
@@ -842,7 +843,7 @@ describe("a history written in a format this gtd does not read", () => {
     const repo = seed(IDLE_THEN_WORKING)
     const base = repo.resolveRef("HEAD")!
     repo.writeFile("NOTE.md", "a note\n")
-    repo.seedCommit("gtd(human): idle → working\n\nGtd-Step: idle#1\nGtd-Format: 4")
+    repo.seedCommit("gtd(human): idle → working\n\nGtd-Step: idle#1\nGtd-Format: 5")
     repo.updateRef(HISTORY_REF, repo.resolveRef("HEAD")!)
     repo.hardResetTo(base)
     const { exitCode, stderr } = await run(repo, "restore")
@@ -1403,7 +1404,7 @@ export default async () => {
   it("a turn that finishes a pinned flow targets the unpin", async () => {
     const repo = await atWorking()
     repo.writeFile("REVIEW.md", "an updated review\n")
-    expect(await nextOf(repo)).toMatchObject({ target: "unpin" })
+    expect(await nextOf(repo)).toMatchObject({ target: "gtd:unpin" })
   })
 
   it("plain gtd next shows the same preview as a `Next:` line", async () => {
@@ -1495,7 +1496,7 @@ export default async () => {
     expect(script).not.toContain("git reset --mixed")
     expect(script).not.toContain("nothing to retain")
     expect(applyEmittedScript(repo, new Map(), script).ok).toBe(true)
-    expect(repo.lastCommitSubject()).toBe("gtd(check): checking → unpin")
+    expect(repo.lastCommitSubject()).toBe("gtd(check): checking → gtd:unpin")
   })
 
   it("the same rest with a pending change lands an ordinary commit too", async () => {
@@ -1544,7 +1545,7 @@ export default async () => {
     }
     expect(parsed.settled).toBe(false)
     expect(parsed.idle).toBe(false)
-    expect(parsed.state).toBe("unpin")
+    expect(parsed.state).toBe("gtd:unpin")
   })
 
   it("gtd land --json an ordinary commit reports settled:false", async () => {
@@ -1693,7 +1694,7 @@ export default async () => {
     const { exitCode, script } = await landAndApply(repo)
     expect(exitCode).toBe(0)
     expect(script).not.toContain("fmt-notes")
-    expect(repo.lastCommitSubject("HEAD~1")).toBe("gtd(agent): drafting → unpin")
+    expect(repo.lastCommitSubject("HEAD~1")).toBe("gtd(agent): drafting → gtd:unpin")
   })
 
   it("`gtd next --json`'s `validate` field carries the mode's format command", async () => {
@@ -1973,7 +1974,7 @@ export default async () => {
   it("refuses once the process has closed and HEAD rests at the initial step again", async () => {
     const repo = await atDeciding()
     await landTurn(repo)
-    expect(repo.lastCommitSubject()).toBe("gtd(check): unpin → idle")
+    expect(repo.lastCommitSubject()).toBe("gtd(check): gtd:unpin → idle")
 
     const { exitCode, stdout, stderr } = await run(repo, "base")
     expect(exitCode).toBe(1)
@@ -2186,41 +2187,32 @@ export default workflow(
     expect(first.stdout).toBe(second.stdout)
   })
 
-  let savedStdin: PropertyDescriptor | undefined
-  afterEach(() => {
-    if (savedStdin) {
-      Object.defineProperty(process, "stdin", savedStdin)
-      savedStdin = undefined
-    }
-  })
-
-  const withStdin = async <T>(content: string, fn: () => Promise<T>): Promise<T> => {
-    savedStdin = Object.getOwnPropertyDescriptor(process, "stdin")
-    const stdin = new PassThrough()
-    Object.defineProperty(process, "stdin", { value: stdin, configurable: true })
-    stdin.end(content)
-    try {
-      return await fn()
-    } finally {
-      if (savedStdin) Object.defineProperty(process, "stdin", savedStdin)
-      savedStdin = undefined
-    }
+  const runWithStdin = async (
+    stdin: string,
+    repo: InMemRepo,
+    ...args: string[]
+  ): Promise<{ readonly stdout: string; readonly stderr: string; readonly exitCode: number }> => {
+    const { io, result } = makeCapturingCliIo(repo, {}, {}, stdin)
+    await Effect.runPromise(runCli(["node", "gtd.js", ...args], io))
+    return result()
   }
 
   const VERDICT = JSON.stringify([{ id: "q1", answer: true, p: 0.97 }])
 
   it("gtd judge answer decodes a verdict on stdin against the pending question ids and succeeds", async () => {
     const repo = seededRepo()
-    const { exitCode, stdout } = await withStdin(VERDICT, () => run(repo, "judge", "answer"))
+    const { exitCode, stdout } = await runWithStdin(VERDICT, repo, "judge", "answer")
     expect(exitCode).toBe(0)
     expect(stdout.length).toBeGreaterThan(0)
   })
 
   it("gtd judge answer refuses a verdict naming a question id the pending judgment never declared, with the usage-error exit code", async () => {
     const repo = seededRepo()
-    const { exitCode, stderr } = await withStdin(
+    const { exitCode, stderr } = await runWithStdin(
       JSON.stringify([{ id: "not-a-real-question", answer: true, p: 0.97 }]),
-      () => run(repo, "judge", "answer"),
+      repo,
+      "judge",
+      "answer",
     )
     expect(exitCode).toBe(2)
     expect(stderr).toContain("does not match the pending questions")
@@ -2228,16 +2220,18 @@ export default workflow(
 
   it("gtd judge answer refuses when stdin is not valid JSON at all, with the usage-error exit code", async () => {
     const repo = seededRepo()
-    const { exitCode, stderr } = await withStdin("not json", () => run(repo, "judge", "answer"))
+    const { exitCode, stderr } = await runWithStdin("not json", repo, "judge", "answer")
     expect(exitCode).toBe(2)
     expect(stderr).toContain("stdin is not valid JSON")
   })
 
   it("gtd judge answer refuses a verdict whose p is above 1 — an unvalidated p would clear every minP", async () => {
     const repo = seededRepo()
-    const { exitCode, stderr } = await withStdin(
+    const { exitCode, stderr } = await runWithStdin(
       JSON.stringify([{ id: "q1", answer: true, p: 5 }]),
-      () => run(repo, "judge", "answer"),
+      repo,
+      "judge",
+      "answer",
     )
     expect(exitCode).toBe(2)
     expect(stderr).toContain("does not match the pending questions")
@@ -2245,9 +2239,11 @@ export default workflow(
 
   it("gtd judge answer refuses a verdict whose p is negative", async () => {
     const repo = seededRepo()
-    const { exitCode, stderr } = await withStdin(
+    const { exitCode, stderr } = await runWithStdin(
       JSON.stringify([{ id: "q1", answer: true, p: -0.1 }]),
-      () => run(repo, "judge", "answer"),
+      repo,
+      "judge",
+      "answer",
     )
     expect(exitCode).toBe(2)
     expect(stderr).toContain("does not match the pending questions")
@@ -2255,15 +2251,19 @@ export default workflow(
 
   it("gtd judge answer refuses through the ordinary error envelope when the rest is no judge step", async () => {
     const repo = seededRepoWithoutJudge()
-    const { exitCode, stderr } = await withStdin("[]", () => run(repo, "judge", "answer"))
+    const { exitCode, stderr } = await runWithStdin("[]", repo, "judge", "answer")
     expect(exitCode).toBe(1)
     expect(stderr).toContain('declares no "judge:"')
   })
 
   it("gtd judge answer --json=script emits a POSIX sh script carrying a Gtd-Judge: trailer on the step commit", async () => {
     const repo = seededLandingRepo()
-    const { stdout, exitCode } = await withStdin(VERDICT, () =>
-      run(repo, "judge", "answer", "--json=script"),
+    const { stdout, exitCode } = await runWithStdin(
+      VERDICT,
+      repo,
+      "judge",
+      "answer",
+      "--json=script",
     )
     expect(exitCode).toBe(0)
     expect(stdout).toContain(DID_NOT_RUN_COMMENT)
@@ -2276,16 +2276,14 @@ export default workflow(
 
   it("gtd judge answer --json=script opens with the same leading comment as land's script", async () => {
     const repo = seededLandingRepo()
-    const { stdout: script } = await withStdin(VERDICT, () =>
-      run(repo, "judge", "answer", "--json=script"),
-    )
+    const { stdout: script } = await runWithStdin(VERDICT, repo, "judge", "answer", "--json=script")
     const { stdout: landScript } = await run(repo, "land", "--json=script")
     expect(script.split("\n")[0]).toBe(landScript.split("\n")[0])
   })
 
   it("plain gtd judge answer (no --json) names the commit and points at --json=script, never the script itself", async () => {
     const repo = seededLandingRepo()
-    const { stdout, exitCode } = await withStdin(VERDICT, () => run(repo, "judge", "answer"))
+    const { stdout, exitCode } = await runWithStdin(VERDICT, repo, "judge", "answer")
     expect(exitCode).toBe(0)
     expect(stdout).toContain("--json=script")
     expect(stdout).not.toContain(DID_NOT_RUN_COMMENT)
@@ -2305,8 +2303,12 @@ export default workflow(
 
   it("gtd judge answer records no truncation on the landing commit — replay recomputes the cut from the budget", async () => {
     const repo = seededTruncatingLandingRepo("20", "aaaaaaaaaa\nbbbbbbbbbb\ncccccccccc\n")
-    const { stdout, exitCode } = await withStdin(VERDICT, () =>
-      run(repo, "judge", "answer", "--json=script"),
+    const { stdout, exitCode } = await runWithStdin(
+      VERDICT,
+      repo,
+      "judge",
+      "answer",
+      "--json=script",
     )
     expect(exitCode).toBe(0)
     expect(applyEmittedScript(repo, new Map(), stdout).ok).toBe(true)

package/src/cli/Program.ts

@@ -1,4 +1,4 @@
-import { Effect, Option, Schema } from "effect"
+import { Effect, Option, type Path, Schema } from "effect"
 import {
   GtdError,
   GtdUsageError,
@@ -99,7 +99,7 @@ import {
   restoredOutcome,
 } from "../emit/index.js"
 import { GTD_VERSION, renderBriefing, WORKFLOWS_REPO } from "../install/index.js"
-import { ToolCommands, type SelfGtd } from "./ToolCommands.js"
+import { ToolCommands } from "./ToolCommands.js"
 import {
   normalizeScriptNewline,
   SelectorUsageError,
@@ -210,14 +210,12 @@ export type Command =
  */
 export type Needs = "pure" | "removed" | "none" | "fs" | "state"
 
-const selfGtd = (): SelfGtd => {
-  const script = process.argv[1]
-  return script === undefined ? ["gtd"] : [process.execPath, script]
-}
-
 /** `needs: "none"` skips the repo-root guard — the server is keyed on file name, not workflow state. */
-const runLspCommand = (): Effect.Effect<void, Error, ToolCommands> =>
-  Effect.flatMap(ToolCommands, (tools) => tools.lsp(selfGtd()))
+const runLspCommand = (): Effect.Effect<void, Error, ToolCommands | Host> =>
+  Effect.gen(function* () {
+    const { self } = yield* Host
+    return yield* (yield* ToolCommands).lsp(self)
+  })
 
 /**
  * Prints the briefing, emitted by the binary itself so it's always current.
@@ -246,7 +244,7 @@ const runBundleCommand = (
 ): Effect.Effect<
   void,
   Error,
-  ConfigService | ConfigDiscovery | EngineCore | Host | Narrator | Workspace
+  ConfigService | ConfigDiscovery | EngineCore | Host | Path.Path | Narrator | Workspace
 > =>
   Effect.gen(function* () {
     yield* (yield* ConfigService).load
@@ -430,23 +428,6 @@ const parseJudgeDocument = (rendered: string): Effect.Effect<JudgeDocument, Erro
       ),
   })
 
-/**
- * The first stdin-consuming command outside `src/lsp/Lsp.ts` (which reads LSP's
- * own length-prefixed frames off `process.stdin`, not a one-shot read) —
- * reads stdin to completion and decodes it as UTF-8 text, no framing.
- */
-const readStdin = (): Effect.Effect<string, Error> =>
-  Effect.tryPromise({
-    try: async () => {
-      const chunks: Buffer[] = []
-      for await (const chunk of process.stdin as AsyncIterable<Buffer>) {
-        chunks.push(chunk)
-      }
-      return Buffer.concat(chunks).toString("utf8")
-    },
-    catch: (e) => (e instanceof Error ? e : new Error(String(e))),
-  })
-
 /** A stdin that is no judgment is the caller's mistake, a usage error like `gtd judge answer`'s. */
 const judgmentShape = (input: string): Effect.Effect<void, GtdUsageError> => {
   let doc: unknown
@@ -470,7 +451,7 @@ const runJudgeRunCommand = (
     const host = yield* Host
     const tools = yield* ToolCommands
     yield* refuseLegacyRc
-    const input = yield* readStdin()
+    const input = yield* host.stdin
     yield* judgmentShape(input)
     const verdict = yield* Effect.tryPromise({
       try: () =>
@@ -535,7 +516,7 @@ const runJudgeAnswerCommand = (
     const document = yield* parseJudgeDocument(rendered.judge)
     const ids = document.questions.map((q) => q.id)
 
-    const raw = yield* readStdin()
+    const raw = yield* (yield* Host).stdin
     const parsed = yield* Effect.try({
       try: () => JSON.parse(raw) as unknown,
       catch: () => new SelectorUsageError("gtd judge answer: stdin is not valid JSON"),
@@ -946,7 +927,7 @@ const resolveValidateScript = (
 ): Effect.Effect<
   { readonly file: string; readonly mode: StateMode; readonly script: string } | undefined,
   Error,
-  Host
+  Host | Path.Path
 > =>
   Effect.gen(function* () {
     const file = rest.hints.file

package/src/cli/ToolCommands.ts

@@ -1,9 +1,7 @@
 import { Context } from "effect"
 import type { Effect } from "effect"
 import type { UiSettings } from "../flows/index.js"
-
-/** How to run THIS gtd — a tool (the LSP) never reads a different version's state than the one it ships with. */
-export type SelfGtd = readonly [string, ...string[]]
+import type { HostOps } from "../platform/index.js"
 
 export interface UiRequest {
   readonly flags: {
@@ -36,7 +34,8 @@ export class ToolCommands extends Context.Service<
       request: UiRequest,
       out: { readonly write: (chunk: string) => void; readonly flush: () => void },
     ) => Effect.Effect<void, Error>
-    readonly lsp: (gtd: SelfGtd) => Effect.Effect<void, Error>
+    /** `gtd` runs THIS gtd, so the LSP never reads a different version's state than the one it ships with. */
+    readonly lsp: (gtd: HostOps["self"]) => Effect.Effect<void, Error>
     readonly judge: (request: JudgeRequest) => Promise<string>
   }
 >()("ToolCommands") {}