@pmelab/gtd 61.0.0 → 62.1.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-CPzWnl3P.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-CPzWnl3P.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.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": {

package/src/cli/Cli.test.ts

@@ -114,6 +114,7 @@ describe("parseArgv — scope", () => {
       ["validate", "--json"],
       ["abandon", "--json"],
       ["restore", "--json"],
+      ["repin", "--json"],
       ["start", "--json"],
       ["start", "fix", "--json"],
       ["history", "fetch", "--json"],
@@ -1116,6 +1117,7 @@ describe("standaloneKinds / needsOf", () => {
       "start",
       "abandon",
       "restore",
+      "repin",
       "next",
       "validate",
       "ui",

package/src/cli/Cli.ts

@@ -131,6 +131,7 @@ const SCRIPT_KINDS: ReadonlySet<Command["kind"]> = new Set<Command["kind"]>([
   "start",
   "abandon",
   "restore",
+  "repin",
   "validate",
   "historyFetch",
 ])
@@ -448,6 +449,16 @@ With no <name>, list every workflow and door it can start. An unknown <name>, th
     summary: "Bring back the last abandoned process",
     details: `Bring back the process the last \`gtd abandon\` stopped: the printed script resets HEAD to that process's last commit. Refuses on a dirty working tree, when nothing was abandoned, or when commits made since would be lost.`,
   },
+  {
+    token: "repin",
+    kind: "repin",
+    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.
+
+  s=$(gtd repin --json=script) && sh -c "$s"`,
+  },
   {
     token: "summary",
     kind: "summary",
@@ -632,6 +643,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 +655,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
@@ -1301,6 +1317,7 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
       | "lsp"
       | "abandon"
       | "restore"
+      | "repin"
       | "next"
       | "validate"
       | "guide"

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,144 @@
+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",
+  "repin",
+  "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)
@@ -1718,6 +1717,7 @@ describe("runCommand — refuses in a repository with no commits", () => {
     start: { kind: "start", name: "fix", args: [], vars: {} },
     abandon: { kind: "abandon" },
     restore: { kind: "restore" },
+    repin: { kind: "repin" },
     next: { kind: "next" },
     validate: { kind: "validate" },
     check: { kind: "check", mode: "qa", file: ".gtd/TODO.md" },
@@ -1744,7 +1744,7 @@ 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 seventeen non-standalone kinds — a canary for the table-driven cases below", () => {
+  it("derives exactly the eighteen non-standalone kinds — a canary for the table-driven cases below", () => {
     expect(stateKinds.sort()).toEqual(
       [
         "abandon",
@@ -1754,6 +1754,7 @@ describe("runCommand — refuses in a repository with no commits", () => {
         "land",
         "next",
         "restore",
+        "repin",
         "summary",
         "validate",
         "ui",

package/src/cli/Program.ts

@@ -65,6 +65,7 @@ import {
   summaryRun,
   type RenderedRest,
 } from "../edge/index.js"
+import { formatCommitMessage, PIN_STATES } from "../replay/index.js"
 import { planStart, planStep as planStepPure, type JudgeVerdict } from "../step/index.js"
 import {
   BUILT_IN_MODE_NAMES,
@@ -82,6 +83,9 @@ import {
   hardResetTo,
   mixedResetTo,
   unpinScript,
+  repinScript,
+  commitPath,
+  transitionOutcome,
   ScriptSurface,
   updateRef,
   type RunnableScript,
@@ -154,6 +158,7 @@ export type Command =
     }
   | { readonly kind: "abandon" }
   | { readonly kind: "restore" }
+  | { readonly kind: "repin" }
   | { readonly kind: "next" }
   | { readonly kind: "validate" }
   | {
@@ -619,7 +624,6 @@ const startWorkflow = (
         first: started,
         commandLabel,
         vars: varOverrides,
-        config: rest.config,
       },
     )
     if (plan.kind === "refusal") {
@@ -863,6 +867,40 @@ const runRestoreCommand = (
     yield* writeScript(json, out, combinedScript(required, ""))
   })
 
+/**
+ * `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.
+ */
+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 message = formatCommitMessage({
+      actor: "check",
+      from: PIN_STATES.add,
+      to: rest.step.name,
+      pin: "add",
+    })
+    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) },
+    ]
+    yield* writeScript(json, out, combinedScript(emitScripts(steps).required, ""))
+  })
+
 /**
  * The mode's own validate command for `file`: a declared `validate:` command
  * verbatim; a `"builtin"` validator or no mode at all names the leaf
@@ -1340,6 +1378,8 @@ const dispatchVoidCommand = (
       return runAbandonCommand(json, out)
     case "restore":
       return runRestoreCommand(json, out)
+    case "repin":
+      return runRepinCommand(json, out)
     case "next":
       return runNextCommand(json, out)
     case "validate":

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/emit/GitScript.ts

@@ -44,6 +44,13 @@ export const pinScript = (path: string): string => {
   return `${mkdir}gtd bundle >${p} || { rm -f -- ${p}; exit 1; }`
 }
 
+/** `gtd repin`'s pin write: a failed `gtd bundle` leaves the committed pin in place. */
+export const repinScript = (path: string): string => {
+  const p = shellQuote(path)
+  const next = shellQuote(`${path}.new`)
+  return `gtd bundle >${next} || { rm -f -- ${next}; exit 1; }\nmv -f -- ${next} ${p}`
+}
+
 /** An unpin beat's script, and `gtd abandon`'s removal of the pin. */
 export const unpinScript = (path: string): string => `rm -f -- ${shellQuote(path)}`
 

package/src/emit/index.ts

@@ -18,6 +18,7 @@ export {
   commitClean,
   commitPath,
   pinScript,
+  repinScript,
   unpinScript,
   CHANGED_SINCE_LAND,
   softResetTo,