@pmelab/gtd 61.0.0 → 62.0.0

package/dist/testkit/gherkin.mjs

@@ -1,4 +1,4 @@
-import { n as runsItsScript, r as testRepo } from "../chunks/testkit-C9sq0x07.mjs";
+import { n as runsItsScript, r as testRepo } from "../chunks/testkit-XQeYCNMn.mjs";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { After, AfterAll, Given, QuickPickleWorld, Then, When, setWorldConstructor } from "quickpickle";

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "61.0.0",
+  "version": "62.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.ts

@@ -632,6 +632,7 @@ const flagHeader = (row: FlagRow): string => {
 
 const GLOBAL_OPTIONS: readonly (readonly [string, string])[] = [
   ["-v, --verbose", "Narrate on stderr what gtd resolved"],
+  ["--live", "Run this gtd, not the process's pin; it may misread the process"],
   ["-h, --help", "Print help; gtd <command> --help for one command"],
   ["-V, --version", "Print the version"],
   ["--", "End the options: every word after it is an argument"],
@@ -643,7 +644,11 @@ const EXTRA_TOPICS: readonly (readonly [string, string, string])[] = [
     "Print help for gtd or one command",
     "Print gtd's overview, or with <command> that command's own help.",
   ],
-  ["version", "Print the version", "Print gtd's version."],
+  [
+    "version",
+    "Print the version",
+    "Print gtd's version, and the version of a pinned process's gtd.",
+  ],
 ]
 
 const EXAMPLES = `  $ gtd start                                   list what can start

package/src/cli/Launch.test.ts

@@ -0,0 +1,52 @@
+import { afterEach, describe, expect, it } from "vitest"
+import { GTD_VERSION, PIN_KEY } from "../install/index.js"
+import { launchFor } from "./Launch.js"
+
+const pin =
+  (header = "gtdpin 1 gtd 1.2.3") =>
+  () => ({
+    path: "/repo/.gtd/process.gtdpin",
+    bytes: Buffer.from(`${header}\n`),
+  })
+const argv = (...words: string[]) => ["node", "gtd", ...words]
+
+describe("launchFor", () => {
+  afterEach(() => {
+    delete (globalThis as { [PIN_KEY]?: unknown })[PIN_KEY]
+  })
+
+  it("hands a state command over to the pin", () => {
+    expect(launchFor(argv("next"), pin())).toMatchObject({ kind: "pin", version: "1.2.3" })
+  })
+
+  it("never hands over from inside a pin", () => {
+    ;(globalThis as { [PIN_KEY]?: unknown })[PIN_KEY] = { version: "1.2.3" }
+    expect(launchFor(argv("next"), pin())).toEqual({ kind: "live", argv: argv("next") })
+  })
+
+  it("strips --live, but keeps one after --", () => {
+    expect(launchFor(argv("--live", "start", "--", "--live"), pin())).toEqual({
+      kind: "live",
+      argv: argv("start", "--", "--live"),
+    })
+    expect(launchFor(argv("start", "--", "--live"), pin())).toMatchObject({
+      kind: "pin",
+      argv: argv("start", "--", "--live"),
+    })
+  })
+
+  it("leaves the version to this gtd without a pin, and for a file that is no pin", () => {
+    expect(launchFor(argv("-V"), () => undefined)).toEqual({ kind: "live", argv: argv("-V") })
+    expect(launchFor(argv("version"), pin("garbage"))).toEqual({
+      kind: "output",
+      stdout: `${GTD_VERSION}\n`,
+    })
+  })
+
+  it("names a newer pin's version even when it cannot run it", () => {
+    expect(launchFor(argv("--version"), pin("gtdpin 9 gtd 99.0.0"))).toEqual({
+      kind: "output",
+      stdout: `${GTD_VERSION} (this process is pinned to gtd 99.0.0)\n`,
+    })
+  })
+})

package/src/cli/Launch.ts

@@ -0,0 +1,143 @@
+import type { PinFile } from "../platform/index.js"
+import { GTD_VERSION, PIN_KEY } from "../install/index.js"
+import { PIN_FORMAT, pinHeader, readPin } from "../workflow/index.js"
+import { EXIT_RUNTIME_ERROR } from "../wire/index.js"
+import { parseArgv } from "./Cli.js"
+import type { Command } from "./Program.js"
+
+/** What the core a pin carries lacks, or what must read the live state: these never hand over. */
+const LIVE_KINDS: ReadonlySet<Command["kind"]> = new Set<Command["kind"]>([
+  "ui",
+  "lsp",
+  "guide",
+  "bundle",
+  "historyList",
+  "historyShow",
+  "historyMetrics",
+  "historyJudges",
+  "historyFetch",
+])
+
+export type Launch =
+  | { readonly kind: "live"; readonly argv: readonly string[] }
+  | {
+      readonly kind: "pin"
+      readonly argv: readonly string[]
+      readonly path: string
+      readonly version: string
+      /** Unpacked only when run: its failure is the hand-over's. */
+      readonly source: () => string
+    }
+  | { readonly kind: "output"; readonly stdout: string }
+  | { readonly kind: "refuse"; readonly message: string }
+
+const LIVE_FLAG = "--live"
+
+// Only before `--`: after it, `--live` is an argument.
+const optionWords = (argv: readonly string[]): readonly string[] => {
+  const end = argv.indexOf("--", 2)
+  return argv.slice(2, end < 0 ? undefined : end)
+}
+
+const withoutLiveFlag = (argv: readonly string[]): readonly string[] => {
+  const end = argv.indexOf("--", 2)
+  return argv.filter((word, i) => word !== LIVE_FLAG || i < 2 || (end >= 0 && i > end))
+}
+
+/**
+ * Whether this gtd runs the command or hands it to the process's pin. A pin
+ * this gtd cannot run is refused, never guessed at; a usage error the live
+ * parser finds is still the pin's to judge, since its engine may read
+ * another CLI.
+ */
+export const launchFor = (argv: readonly string[], pinFile: PinFile): Launch => {
+  // The engine a pin carries is this same code: once inside one, never hand over again.
+  if ((globalThis as { [PIN_KEY]?: unknown })[PIN_KEY] !== undefined) return { kind: "live", argv }
+  const live = optionWords(argv).includes(LIVE_FLAG)
+  const rest = withoutLiveFlag(argv)
+  if (live) return { kind: "live", argv: rest }
+  const plan = parseArgv(rest)
+  const version = plan.kind === "output" && plan.stdout === `${GTD_VERSION}\n`
+  if (plan.kind === "output" && !version) return { kind: "live", argv: rest }
+  if (plan.kind === "command" && LIVE_KINDS.has(plan.command.kind))
+    return { kind: "live", argv: rest }
+  const found = pinFile()
+  if (found === undefined) return { kind: "live", argv: rest }
+  const header = pinHeader(found.bytes)
+  if (version)
+    return {
+      kind: "output",
+      stdout:
+        header === undefined
+          ? plan.stdout
+          : `${GTD_VERSION} (this process is pinned to gtd ${header.version})\n`,
+    }
+  if (header === undefined || header.format !== PIN_FORMAT) {
+    const what =
+      header === undefined
+        ? "is no pin this gtd can read"
+        : `is pin format ${header.format}, made by gtd ${header.version}`
+    return {
+      kind: "refuse",
+      message: `gtd: ${found.path} ${what}; gtd ${GTD_VERSION} runs pin format ${PIN_FORMAT} — upgrade gtd (\`gtd --live\` runs this gtd instead, and may misread the process)`,
+    }
+  }
+  return {
+    kind: "pin",
+    argv: rest,
+    path: found.path,
+    version: header.version,
+    source: () => readPin(found.bytes).source,
+  }
+}
+
+export interface Launcher {
+  readonly stdout: (chunk: string) => void
+  readonly stderr: (chunk: string) => void
+  readonly exit: (code: number) => void
+  readonly live: (argv: readonly string[]) => void | Promise<void>
+  readonly pin: (launch: Extract<Launch, { kind: "pin" }>) => Promise<void>
+}
+
+const isJsonFlag = (word: string): boolean => word === "--json" || word.startsWith("--json=")
+
+// The CLI's own error envelope too, which a `--json` driver reads.
+const refusalText = (argv: readonly string[], message: string): string =>
+  (optionWords(argv).some(isJsonFlag)
+    ? `${JSON.stringify({ state: "error", prompt: message })}\n`
+    : "") + `${message}\n`
+
+const runPin = async (
+  launch: Extract<Launch, { kind: "pin" }>,
+  launcher: Launcher,
+): Promise<void> => {
+  const words = optionWords(launch.argv)
+  if (words.includes("--verbose") || words.includes("-v"))
+    launcher.stderr(`launcher: running the pin ${launch.path} (gtd ${launch.version})\n`)
+  try {
+    await launcher.pin(launch)
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error)
+    launcher.stderr(`gtd: could not run the pin ${launch.path}: ${reason}\n`)
+    launcher.exit(EXIT_RUNTIME_ERROR)
+  }
+}
+
+export const runLauncher = async (
+  argv: readonly string[],
+  pinFile: PinFile,
+  launcher: Launcher,
+): Promise<void> => {
+  const launch = launchFor(argv, pinFile)
+  switch (launch.kind) {
+    case "live":
+      return launcher.live(launch.argv)
+    case "output":
+      return launcher.stdout(launch.stdout)
+    case "refuse":
+      launcher.stderr(refusalText(argv, launch.message))
+      return launcher.exit(EXIT_RUNTIME_ERROR)
+    case "pin":
+      return runPin(launch, launcher)
+  }
+}

package/src/cli/Program.test.ts

@@ -33,7 +33,6 @@ import {
   restoredOutcome,
 } from "../emit/index.js"
 import { GitService, HISTORY_REF, Host } from "../platform/index.js"
-import { contentHash } from "../workflow/index.js"
 import { WORKFLOWS_REPO } from "../install/index.js"
 
 const run = async (
@@ -111,7 +110,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-Config: ${contentHash(WORKFLOW)} gtd.config.ts\nGtd-Format: 2`,
+        `gtd(human): working\n\nGtd-Workflow: hotfix\nGtd-Var: greeting=hello\nGtd-Format: 2`,
       ),
     )
     expect(repo.commitHistory()).toHaveLength(before)

package/src/cli/Program.ts

@@ -619,7 +619,6 @@ const startWorkflow = (
         first: started,
         commandLabel,
         vars: varOverrides,
-        config: rest.config,
       },
     )
     if (plan.kind === "refusal") {

package/src/cli/index.ts

@@ -12,3 +12,4 @@ export {
   type LiveToolCommands,
 } from "./Cli.js"
 export { ToolCommands, type UiRequest } from "./ToolCommands.js"
+export { runLauncher } from "./Launch.js"

package/src/edge/Edge.test.ts

@@ -23,7 +23,7 @@ import { keptRef, processHistoryRef } from "../platform/index.js"
 import { GitService, Workspace, type GitOperations, type WorkspaceOps } from "../platform/index.js"
 import type { Mark } from "../flows/index.js"
 import { formatCommitMessage, type CommitSpec } from "../replay/index.js"
-import { contentHash, StartFlags } from "../workflow/index.js"
+import { StartFlags } from "../workflow/index.js"
 import {
   fakeGitOperations,
   InMemRepo,
@@ -217,7 +217,7 @@ describe("currentRun", () => {
     const before = headOf(repo)
     const opening = await enter(repo, "side")
     expect(repo.lastCommitMessage(opening)).toBe(
-      `gtd(human): fixing\n\nGtd-Workflow: side\nGtd-Var: base=\nGtd-Var: reviewer=nobody\nGtd-Config: ${contentHash(LINEAR)} gtd.config.ts\nGtd-Format: 2`,
+      `gtd(human): fixing\n\nGtd-Workflow: side\nGtd-Var: base=\nGtd-Var: reviewer=nobody\nGtd-Format: 2`,
     )
     const fixed = await land(repo, { "fix.txt": "x\n" })
     const run = await provide(currentRun, repo)
@@ -250,7 +250,7 @@ export const again = workflow(async () => {
     const before = headOf(repo)
     const opening = await enter(repo, "again")
     expect(repo.lastCommitMessage(opening)).toBe(
-      `gtd(human): idle\n\nGtd-Workflow: again\nGtd-Config: ${contentHash(STARTS_AT_INITIAL)} gtd.config.ts\nGtd-Format: 2`,
+      `gtd(human): idle\n\nGtd-Workflow: again\nGtd-Format: 2`,
     )
     const fixed = await land(repo, { "fix.txt": "x\n" })
     const run = await provide(currentRun, repo)

package/src/edge/Edge.ts

@@ -12,8 +12,6 @@ import {
 import {
   ConfigDiscovery,
   ConfigService,
-  changedConfigFiles,
-  contentHash,
   multilineSetting,
   resolveVars,
   resolveStartVars,
@@ -173,8 +171,6 @@ export interface ProcessRun {
   readonly approvals: readonly ApprovalEntry[]
   /** The process settings recorded in the process's first commit (empty for a process started before pinning existed). */
   readonly pinnedVars: Record<string, string>
-  /** Absent for a process started before recording existed. */
-  readonly pinnedConfig: { readonly commit: string; readonly files: ConfigFingerprint } | undefined
   /** HEAD's own gtd commit, when it is one — `empty` is whether it changed nothing. */
   readonly headTurn:
     | {
@@ -248,17 +244,6 @@ const runOf = (
     : Effect.fail(new Error(fault))
 }
 
-// The newest recording, not the first process commit's: the episode is
-// located by the CURRENT config's first step, so a config that renamed it can
-// move the boundary onto the start commit itself, or behind it.
-const pinnedConfigOf = (history: History): ProcessRun["pinnedConfig"] => {
-  for (let i = history.length - 1; i >= 0; i--) {
-    const files = parseCommitMessage(history[i]!.message).config
-    if (Object.keys(files).length > 0) return { commit: history[i]!.hash, files }
-  }
-  return undefined
-}
-
 const approvalEntryOf = (
   hash: string,
   message: ReturnType<typeof parseCommitMessage>,
@@ -300,7 +285,6 @@ const buildRun = (
     marks: parsed.flatMap((m) => m.marks),
     approvals: processCommits.flatMap((c, i) => approvalEntryOf(c.hash, parsed[i]!)),
     pinnedVars: { ...first?.vars },
-    pinnedConfig: pinnedConfigOf(history.slice(Math.max(location.baseIndex, 0))),
     headTurn: headTurnOf(head),
     closingHash,
     episode: {
@@ -420,37 +404,6 @@ const computeProcessRun = (
     runOf(history, locateEpisode(def, history)),
   )
 
-// A file matching its copy in the recording commit is unchanged: the hashes
-// are taken before the commit's own hooks run, and a hook may reformat it.
-const changedSinceStart = (
-  pinned: ProcessRun["pinnedConfig"],
-  current: ConfigFingerprint,
-  workspace: WorkspaceOps,
-): readonly string[] => {
-  if (pinned === undefined) return []
-  return changedConfigFiles(pinned.files, current).filter((path) => {
-    const committed = workspace.readCommittedSync(path, pinned.commit)
-    return (
-      current[path] === undefined ||
-      committed === undefined ||
-      contentHash(committed) !== current[path]
-    )
-  })
-}
-
-const warnConfigChanges = (
-  run: ProcessRun,
-  current: ConfigFingerprint,
-  workspace: WorkspaceOps,
-): Effect.Effect<void, never, Narrator> =>
-  Effect.gen(function* () {
-    const changed = changedSinceStart(run.pinnedConfig, current, workspace)
-    if (changed.length === 0) return
-    yield* (yield* Narrator).warn(
-      `gtd: warning: the config changed since this process started (${changed.join(", ")}) — the rest of the process replays under the changed config`,
-    )
-  })
-
 type ConfigRequirements = GitService | ConfigService | ConfigDiscovery | Narrator | Workspace | Host
 
 /** The run alone, never replaying — `gtd abandon` must work even when replay would refuse, short of a history it cannot read. */
@@ -876,8 +829,6 @@ interface Rest extends ResolvedRest {
   readonly run: ProcessRun
   readonly vars: Record<string, string>
   readonly env: Record<string, string>
-  /** What a landing that starts the process records. */
-  readonly config: ConfigFingerprint
   readonly changes: readonly PendingChange[]
   readonly memory: string | undefined
   readonly memoryResumed: boolean
@@ -1030,11 +981,13 @@ export const restAt = (
             path: e.path,
           }))
         : []
-    const configNow = config.fingerprint
-    // Only the current rest warns, so a command must read it once — a second
-    // read warns twice. An earlier ref (restore's tip) would warn about a
-    // process the command is not acting on.
-    if (ref === undefined) yield* warnConfigChanges(run, configNow, workspace)
+    // Only the current rest notices, so a command must read it once — a
+    // second read notices twice. An earlier ref (restore's tip) is not the
+    // process the command acts on.
+    if (ref === undefined && config.drift.length > 0)
+      yield* (yield* Narrator).warn(
+        `gtd: notice: the live config differs from the pinned one (${config.drift.join(", ")}); \`gtd repin\` to switch`,
+      )
     return {
       def,
       workflowName: resolved.name,
@@ -1048,7 +1001,6 @@ export const restAt = (
       run,
       vars,
       env,
-      config: configNow,
       changes,
       memory: memory.key,
       memoryResumed: memory.resumed,
@@ -1406,8 +1358,7 @@ const pinRefusal = (pin: PinChange): Landing => ({
       : `gtd land: ${PIN_PATH} is still there — run the unpin beat's script (\`gtd next --json=content\`), then land`,
 })
 
-const startTrailers = (rest: Rest, starts: boolean) =>
-  starts ? { vars: rest.vars, config: rest.config } : {}
+const startTrailers = (rest: Rest, starts: boolean) => (starts ? { vars: rest.vars } : {})
 
 const outcomeMarks = (outcome: ReplayOutcome): readonly Mark[] =>
   outcome.kind === "rest" || outcome.kind === "ended" ? outcome.marks : []
@@ -1543,13 +1494,13 @@ export interface HistoryTrail {
   readonly versionWarning?: string
 }
 
-/** Repository-relative paths of the config files today's config and the process's own record name; one outside the repository cannot be read at a ref, so it is left out. */
-const inRepoConfigPaths = (
-  root: string,
-  files: readonly string[],
-  recorded: ConfigFingerprint,
-): readonly string[] => {
-  const paths = new Set<string>(Object.keys(recorded))
+/**
+ * Repository-relative paths of today's config files; one outside the
+ * repository cannot be read at a ref, so it is left out. A file only the old
+ * config read needs no check: whichever file imported it differs too.
+ */
+const inRepoConfigPaths = (root: string, files: readonly string[]): readonly string[] => {
+  const paths = new Set<string>()
   for (const file of files) paths.add(relative(root, resolve(root, file)).split(sep).join("/"))
   return [...paths].filter((p) => p !== "" && !p.startsWith("..") && !isAbsolute(p)).sort()
 }
@@ -1569,16 +1520,11 @@ const differingConfigPaths = (
   workspace: Workspace["Service"],
   root: string,
   config: { readonly fingerprint: ConfigFingerprint },
-  run: ProcessRun,
   hash: string,
 ) =>
   Effect.gen(function* () {
     const differing: string[] = []
-    for (const path of inRepoConfigPaths(
-      root,
-      Object.keys(config.fingerprint),
-      run.pinnedConfig?.files ?? {},
-    )) {
+    for (const path of inRepoConfigPaths(root, Object.keys(config.fingerprint))) {
       const atTip = yield* Effect.orElseSucceed(git.readFileAtRef(hash, path), () => undefined)
       if (atTip !== workspace.readSync(path)) differing.push(path)
     }
@@ -1664,7 +1610,7 @@ const replayFinishedProcess = (
     // A refusal is often caused by the version change, so it carries the warning.
     const withWarning = (err: Error): Error =>
       versionWarning === undefined ? err : new Error(`${err.message}\n${versionWarning}`)
-    const differing = yield* differingConfigPaths(git, workspace, host.root, config, run, hash)
+    const differing = yield* differingConfigPaths(git, workspace, host.root, config, hash)
     if (differing.length > 0)
       return yield* Effect.fail(
         withWarning(configRefusal(how.command, hash, differing, how.configReason)),

package/src/platform/PinFile.ts

@@ -0,0 +1,61 @@
+import { execFileSync } from "node:child_process"
+import { existsSync, readFileSync } from "node:fs"
+import { registerHooks } from "node:module"
+import { join } from "node:path"
+import { pathToFileURL } from "node:url"
+
+/** A process's pin as the launcher found it: the file's bytes and where its engine runs from. */
+export interface FoundPin {
+  readonly path: string
+  readonly bytes: Uint8Array
+}
+
+/**
+ * Where the launcher looks for a pin: the worktree's copy, else HEAD's — so
+ * the landing after an unpin beat deleted the file still runs on the pin.
+ */
+export type PinFile = () => FoundPin | undefined
+
+// `cwd`, as the engine's own root is: gtd runs only at the worktree root, and
+// a relocated `$GIT_DIR` leaves no `.git` to walk up to. A file that cannot be
+// read counts as no pin, so the launcher refuses it rather than crashing.
+export const livePinFile =
+  (cwd: string, path: string): PinFile =>
+  () => {
+    const file = join(cwd, path)
+    if (existsSync(file)) {
+      try {
+        return { path: file, bytes: readFileSync(file) }
+      } catch {
+        return { path: file, bytes: new Uint8Array() }
+      }
+    }
+    try {
+      const bytes = execFileSync("git", ["show", `HEAD:${path}`], {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"],
+      })
+      return { path: file, bytes }
+    } catch {
+      return undefined
+    }
+  }
+
+/**
+ * Runs a pin's module as this process's main program. Node refuses an unknown
+ * extension, so a load hook serves the unpacked source under the pin's own
+ * URL — `import.meta.url` stays a file in the repository.
+ */
+export const runPinModule = async (path: string, source: string): Promise<void> => {
+  const url = pathToFileURL(path).href
+  // A pin read from HEAD has no file behind its URL, which Node's own resolve refuses.
+  registerHooks({
+    resolve: (specifier, context, nextResolve) =>
+      specifier === url ? { url, shortCircuit: true } : nextResolve(specifier, context),
+    load: (requested, context, nextLoad) =>
+      requested === url
+        ? { format: "module", source, shortCircuit: true }
+        : nextLoad(requested, context),
+  })
+  await import(url)
+}

package/src/platform/index.ts

@@ -29,3 +29,4 @@ export {
   readRetainedHistory,
   restorability,
 } from "./RetainedHistory.js"
+export { livePinFile, runPinModule, type PinFile } from "./PinFile.js"

package/src/replay/Trailers.test.ts

@@ -60,43 +60,6 @@ describe("the commit-message codec", () => {
     expect(parseCommitMessage(one).vars).toEqual({ a: "1", b: "2", c: "" })
   })
 
-  it("writes Gtd-Config trailers sorted by path, after Gtd-Var, and reads paths with spaces back", () => {
-    const message = formatCommitMessage({
-      actor: "human",
-      to: "x",
-      vars: { a: "1" },
-      config: { "lib/my flow.ts": "0123456789abcdef", "gtd.config.ts": "deadbeefdeadbeef" },
-    })
-    expect(message).toBe(
-      "gtd(human): x\n\nGtd-Var: a=1\nGtd-Config: deadbeefdeadbeef gtd.config.ts\nGtd-Config: 0123456789abcdef lib/my flow.ts\nGtd-Format: 2",
-    )
-    expect(parseCommitMessage(message).config).toEqual({
-      "gtd.config.ts": "deadbeefdeadbeef",
-      "lib/my flow.ts": "0123456789abcdef",
-    })
-  })
-
-  it("round-trips a Gtd-Config path that git or the trailer syntax would alter", () => {
-    const config = {
-      " lead.ts": "0123456789abcdef",
-      "trail.ts ": "0123456789abcdef",
-      '"q.ts': "0123456789abcdef",
-    }
-    const message = formatCommitMessage({ actor: "human", to: "x", config })
-    expect(message).toContain('Gtd-Config: 0123456789abcdef " lead.ts"')
-    expect(parseCommitMessage(message).config).toEqual(config)
-  })
-
-  it("ignores a Gtd-Config trailer without a 16-digit hex hash, without a path, or with a control character in its path", () => {
-    const read = (value: string) =>
-      parseCommitMessage(`gtd(human): x\n\nGtd-Config: ${value}`).config
-    expect(read("zzzzzzzzzzzzzzzz gtd.config.ts")).toEqual({})
-    expect(read("deadbeef gtd.config.ts")).toEqual({})
-    expect(read("deadbeefdeadbeef")).toEqual({})
-    expect(read("deadbeefdeadbeef a\x1b]0;x\x07.ts")).toEqual({})
-    expect(read('deadbeefdeadbeef "a\\u001b.ts"')).toEqual({})
-  })
-
   it("round-trips Gtd-Branch and Gtd-Version, after Gtd-Judge and before Gtd-Format", () => {
     const message = formatCommitMessage({
       actor: "agent",

package/src/replay/Trailers.ts

@@ -83,8 +83,6 @@ export interface CommitMessage {
   /** `Gtd-Mark`, in order; a malformed or control-character line is skipped. */
   readonly marks: readonly Mark[]
   readonly vars: Readonly<Record<string, string>>
-  /** Written only on a process's first commit. */
-  readonly config: Readonly<Record<string, string>>
   readonly reviewBase: string | undefined
   readonly cost: readonly CostEntry[]
   /** Written only on a process's finishing landing. */
@@ -120,20 +118,10 @@ const parseJson = (raw: string): unknown => {
 const TRAILER_RE = /^(Gtd-[A-Za-z-]+):[ \t]*(.*?)[ \t]*$/gm
 const COST_RE = /^([0-9]+(?:\.[0-9]+)?)(?:[ \t]+(.+))?$/
 const VAR_RE = /^([^=\s]+)=(.*)$/
-const CONFIG_RE = /^([0-9a-f]{16}) (.+)$/
-// A path git's message cleanup or the trailer syntax would alter travels as a
-// JSON string. A control character is refused on read: history written by
-// someone else must never put escape sequences on a terminal.
+// A control character is refused on read: history written by someone else
+// must never put escape sequences on a terminal.
 // eslint-disable-next-line no-control-regex -- the control range IS the point
 const CONTROL_CHARACTER = /[\x00-\x1f\x7f-\x9f\u2028\u2029]/
-const encodePath = (path: string): string =>
-  path.trim() !== path || path.startsWith('"') || CONTROL_CHARACTER.test(path)
-    ? JSON.stringify(path)
-    : path
-const decodePath = (raw: string): string | undefined => {
-  const path = raw.startsWith('"') ? parseJson(raw) : raw
-  return typeof path === "string" && path !== "" && !CONTROL_CHARACTER.test(path) ? path : undefined
-}
 const decodeApproval = (raw: string): Approval | undefined => {
   const parsed = parseJson(raw)
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return undefined
@@ -168,7 +156,6 @@ interface Trailers {
   readonly judge: JudgeVerdict[]
   readonly marks: Mark[]
   readonly vars: Record<string, string>
-  readonly config: Record<string, string>
   readonly cost: CostEntry[]
   format: number | undefined
 }
@@ -193,11 +180,6 @@ const TRAILER_READERS: Readonly<Record<string, (value: string, into: Trailers) =
     const kv = VAR_RE.exec(value)
     if (kv !== null) into.vars[kv[1]!] = kv[2]!
   },
-  "Gtd-Config": (value, into) => {
-    const entry = CONFIG_RE.exec(value)
-    const path = entry === null ? undefined : decodePath(entry[2]!)
-    if (path !== undefined) into.config[path] = entry![1]!
-  },
   "Gtd-Review-Base": (value, into) => {
     into.reviewBase ??= value.split(/\s/)[0]
   },
@@ -242,7 +224,6 @@ export const parseCommitMessage = (message: string): CommitMessage => {
     judge: [],
     marks: [],
     vars: {},
-    config: {},
     cost: [],
     format: undefined,
   }
@@ -262,7 +243,6 @@ export interface CommitSpec {
   readonly workflow?: string
   readonly reviewBase?: string
   readonly vars?: Readonly<Record<string, string>>
-  readonly config?: Readonly<Record<string, string>>
   readonly cost?: { readonly cost: number; readonly model?: string }
   readonly judge?: readonly JudgeVerdict[]
   /** Written after `Gtd-Judge`, before `Gtd-Approved`. */
@@ -290,7 +270,6 @@ export const formatCommitMessage = (spec: CommitSpec): string => {
     ...trailer("Workflow", spec.workflow),
     ...trailer("Review-Base", spec.reviewBase),
     ...sortedEntries(spec.vars).map(([name, value]) => `Gtd-Var: ${name}=${value}`),
-    ...sortedEntries(spec.config).map(([path, hash]) => `Gtd-Config: ${hash} ${encodePath(path)}`),
     ...trailer("Cost", costValue(spec.cost)),
     ...(spec.judge ?? []).map((verdict) => `Gtd-Judge: ${JSON.stringify(verdict)}`),
     ...(spec.marks ?? []).map((m) => `Gtd-Mark: ${m.name}=${m.value}`),

package/src/step/planStart.test.ts

@@ -56,7 +56,6 @@ const start = (
         first: startRefusal === undefined ? { firstStep: "work" } : { refusal: startRefusal },
         commandLabel: req.commandLabel,
         vars: req.vars,
-        config: {},
       })
     }).pipe(Effect.provide(testLayers(repo))),
   )