@pmelab/gtd 62.1.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-CPzWnl3P.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-CPzWnl3P.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": "62.1.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,
@@ -455,7 +457,7 @@ With no <name>, list every workflow and door it can start. An unknown <name>, th
     arity: "none",
     group: "Start and stop",
     summary: "Pin the process to the live gtd and workflow",
-    details: `Switch the process underway to the live engine and workflow, the way out when the workflow needs a fix mid-process: the printed script runs the pin beat again, writing \`gtd bundle\`'s output to .gtd/process.gtdpin and committing that file alone. Always runs on the gtd on PATH, never on the pin. Refuses when no process is underway, when the next beat is a pin or unpin beat already, or when the live workflow does not replay the process.
+    details: `Switch the process underway to the live engine and workflow, the way out when the workflow needs a fix mid-process: the printed script runs the pin beat again, writing \`gtd bundle\`'s output to .gtd/process.gtdpin and committing that file alone. Always runs on the gtd on PATH, never on the pin. When the live workflow no longer replays the process, the commit continues from the divergence: a Gtd-Anchor trailer names the last commit it replays, the later commits stay as files only, and the process rests at the step the live workflow reached there. Refuses when no process is underway, when the next beat is a pin or unpin beat already, when an unpinned process diverges, or when the live workflow would continue at the default workflow's first step.
 
   s=$(gtd repin --json=script) && sh -c "$s"`,
   },
@@ -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: 2`,
+        `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 3, but this gtd reads formats 1 to 2"
+  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: 3")
+    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: 3")
+    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: 3")
+    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: 3")
+    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,
@@ -51,6 +51,7 @@ import {
 } from "../wire/index.js"
 import {
   currentRest,
+  repinAnchor,
   startRefusal,
   currentRun,
   renderRest,
@@ -98,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,
@@ -209,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.
@@ -245,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
@@ -429,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
@@ -469,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: () =>
@@ -534,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"),
@@ -867,36 +849,45 @@ const runRestoreCommand = (
     yield* writeScript(json, out, combinedScript(required, ""))
   })
 
+/** The step an ordinary repin rests at — the one the process rests at now. */
+const repinTarget = Effect.gen(function* () {
+  const rest = yield* currentRest
+  const refusal =
+    rest.pin === "add"
+      ? "the next beat pins the process already — run it (`gtd next --json=content`), then land"
+      : rest.pin === "remove"
+        ? "the flow has ended — its unpin beat is next, so there is nothing to repin"
+        : noProcessUnderway(rest)
+          ? "no gtd process is underway — nothing to repin"
+          : undefined
+  if (refusal !== undefined) return yield* Effect.fail(new Error(`gtd repin: ${refusal}`))
+  return rest.step.name
+})
+
 /**
- * `gtd repin`: the pin beat's script and landing, on demand. It runs live,
- * so reading the rest first refuses a live workflow that cannot replay the
- * process before any pin is written.
+ * `gtd repin`: the pin beat's script and landing, on demand. It runs live: a
+ * pinned process the live workflow no longer replays is anchored where it
+ * diverged, and any other failure to read the rest refuses before any pin is
+ * written.
  */
 const runRepinCommand = (
   json: JsonMode,
   out: ArtifactOut,
 ): Effect.Effect<void, Error, CommandRequirements> =>
   Effect.gen(function* () {
-    const rest = yield* currentRest
-    const refusal =
-      rest.pin === "add"
-        ? "the next beat pins the process already — run it (`gtd next --json=content`), then land"
-        : rest.pin === "remove"
-          ? "the flow has ended — its unpin beat is next, so there is nothing to repin"
-          : noProcessUnderway(rest)
-            ? "no gtd process is underway — nothing to repin"
-            : undefined
-    if (refusal !== undefined) return yield* Effect.fail(new Error(`gtd repin: ${refusal}`))
+    const anchor = yield* repinAnchor
+    const to = anchor?.to ?? (yield* repinTarget)
     const message = formatCommitMessage({
       actor: "check",
       from: PIN_STATES.add,
-      to: rest.step.name,
+      to,
       pin: "add",
+      ...(anchor !== undefined ? { anchor: anchor.at } : {}),
     })
     const steps: EmitStep[] = [
       { kind: "gitWrite", command: repinScript(PIN_PATH) },
       { kind: "gitWrite", command: commitPath(PIN_PATH, message) },
-      { kind: "outcome", command: transitionOutcome(PIN_STATES.add, rest.step.name) },
+      { kind: "outcome", command: transitionOutcome(PIN_STATES.add, to) },
     ]
     yield* writeScript(json, out, combinedScript(emitScripts(steps).required, ""))
   })
@@ -936,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") {}