@pmelab/gtd 65.0.0 → 66.0.0

package/src/edge/Edge.ts

@@ -761,6 +761,7 @@ const promptDef = (
   ...optional("system", request.options.system),
   ...optional("allowEmpty", request.options.allowEmpty),
   ...optional("keep", request.options.keep),
+  ...optional("original", request.original),
   ...optional("skills", skills),
   ...optional("access", access),
 })
@@ -1288,6 +1289,7 @@ export interface RenderedRest extends RestHints {
   readonly content: string
   readonly memory?: string
   readonly memoryResumed: boolean
+  readonly original?: string
   readonly pin?: PinChange
   readonly failure?: string
   readonly blocked?: string
@@ -1306,6 +1308,7 @@ export const renderRest = (rest: Rest): Effect.Effect<RenderedRest, Error> =>
     ...(rest.shipBlocked !== undefined ? { blocked: rest.shipBlocked } : {}),
     ...(rest.memory !== undefined ? { memory: rest.memory } : {}),
     memoryResumed: rest.memoryResumed,
+    ...(rest.stepDef.original !== undefined ? { original: rest.stepDef.original } : {}),
     ...(rest.pin !== undefined ? { pin: rest.pin } : {}),
   })
 
@@ -1383,7 +1386,7 @@ const cleanLanding = (rest: Rest): Landing | undefined => {
   return undefined
 }
 
-/** At the human review gate the pending tree lands with every tick cleared, as the landing script will. */
+/** At the human review gate the pending tree lands with every tick cleared; an agent-bound landing keeps them only if the unrewritten tree replays to the same step. */
 const reviewGateRewrite = (def: StepDef): Rewrite | undefined => {
   const reviewFormat = steeringFormatFor("review")
   if (!isHumanReviewGate(def) || def.file === undefined || reviewFormat === undefined) {
@@ -1392,6 +1395,16 @@ const reviewGateRewrite = (def: StepDef): Rewrite | undefined => {
   return { path: def.file, apply: (content) => reviewFormat.clearTicks(content) }
 }
 
+/** Whether the pending review file differs from HEAD's once both have their ticks cleared. */
+const reviewEditedBeyondTicks = (rest: Rest): boolean => {
+  const rewrite = reviewGateRewrite(rest.stepDef)
+  if (rewrite === undefined) return false
+  const pending = rest.setup.workspace.readSync(rewrite.path)
+  const committed = rest.setup.workspace.readCommittedSync(rewrite.path)
+  if (pending === undefined || committed === undefined) return true
+  return rewrite.apply(pending) !== rewrite.apply(committed)
+}
+
 const multilineRefusal = (vars: Record<string, string>): Landing | undefined => {
   const multiline = multilineSetting(vars)
   return multiline === undefined
@@ -1579,7 +1592,28 @@ const decideLanding = (
     )
     const to = yield* landingTarget(outcome, rest)
     if (typeof to !== "string") return to
-    return landingTo(rest, to, branch, approver, outcomeMarks(outcome))
+    const landed = landingTo(rest, to, branch, approver, outcomeMarks(outcome))
+    // Ticks survive an agent-bound landing only when the review file changed beyond ticks
+    // (a tick-only sign-off lands clean) and the unrewritten tree replays to the same step.
+    if (
+      landed.kind !== "commit" ||
+      !isHumanReviewGate(rest.stepDef) ||
+      outcome.kind !== "rest" ||
+      outcome.rest.request.kind !== "agent" ||
+      !reviewEditedBeyondTicks(rest)
+    ) {
+      return landed
+    }
+    const ticked = yield* Effect.promise(() =>
+      replayFor(rest.setup, {
+        tree: pendingTree(rest.setup.workspace, rest.setup.pendingWorktree(), undefined),
+        ...(verdicts !== undefined ? { verdicts } : {}),
+        ...(shipped !== undefined ? { shipped } : {}),
+      }),
+    )
+    return ticked.kind === "rest" && ticked.rest.name === outcome.rest.name
+      ? { ...landed, keepTicks: true }
+      : landed
   })
 
 /** The user's branch: `<b>` for a process on `gtd/<b>` while `<b>` still exists; any other branch as is. */
@@ -1620,7 +1654,13 @@ const withHistory = (landing: Landing & { kind: "commit" }) =>
     let out = landing
     const back = landing.keepHistory === undefined ? undefined : yield* returnBranch
     if (back !== undefined) out = { ...out, leaveBranch: back }
-    if (landing.keepHistory === undefined && landing.ship === undefined) return out
+    if (
+      landing.keepHistory === undefined &&
+      landing.ship === undefined &&
+      landing.recordedHistory === undefined
+    ) {
+      return out
+    }
     const remote = (yield* (yield* ConfigService).load).historyRemote
     return remote === undefined ? out : { ...out, pushHistory: remote }
   })
@@ -1659,9 +1699,16 @@ const SHIP_EXCLUDED = ".gtd/"
 
 type ShipDecision =
   | { readonly kind: "ship"; readonly branch: string; readonly parent: string }
+  | { readonly kind: "recorded"; readonly hash: string }
   | { readonly kind: "skip"; readonly note: string }
   | { readonly kind: "blocked"; readonly message: string }
 
+/** `tree` with file modes read from `ref` (the working tree when `undefined`), for the ship decision only: reading them costs a git call. */
+const withModes = (workspace: WorkspaceOps, tree: TreeView, ref: string | undefined): TreeView => {
+  let modes: ReadonlyMap<string, string> | undefined
+  return { ...tree, mode: (path) => (modes ??= workspace.modeSync(ref)).get(path) }
+}
+
 const shippedPaths = (before: TreeView, after: TreeView): readonly string[] => {
   const diff = diffTrees(before, after)
   return [...diff.added, ...diff.modified, ...diff.deleted].filter(
@@ -1700,6 +1747,7 @@ const revertedPaths = (
   parent: string,
   tree: TreeView,
   changed: ReadonlySet<string>,
+  treeRef: string | undefined,
 ) =>
   Effect.gen(function* () {
     const head = yield* git.resolveRef("HEAD")
@@ -1708,9 +1756,18 @@ const revertedPaths = (
     const fork = yield* git.mergeBase(parent, head)
     const foreign = Option.isNone(fork)
       ? [...changed]
-      : shippedPaths(commitTree(workspace, fork.value), commitTree(workspace, parent))
-    const committed = commitTree(workspace, head)
-    return foreign.filter((path) => changed.has(path) && tree.read(path) === committed.read(path))
+      : shippedPaths(
+          withModes(workspace, commitTree(workspace, fork.value), fork.value),
+          withModes(workspace, commitTree(workspace, parent), parent),
+        )
+    const committed = withModes(workspace, commitTree(workspace, head), head)
+    const moded = withModes(workspace, tree, treeRef)
+    return foreign.filter(
+      (path) =>
+        changed.has(path) &&
+        moded.read(path) === committed.read(path) &&
+        moded.mode!(path) === committed.mode!(path),
+    )
   })
 
 /**
@@ -1722,14 +1779,31 @@ const revertedPaths = (
 const decideShip = (
   workspace: WorkspaceOps,
   tree: TreeView,
+  /** The commit `tree` is of; `undefined` for the working tree. */
+  treeRef: string | undefined,
 ): Effect.Effect<ShipDecision, Error, GitService> =>
   Effect.gen(function* () {
     const git = yield* GitService
     const target = yield* shipTarget(git)
     if (target.kind !== "ship") return target
     const { branch, parent } = target
-    const changed = new Set(shippedPaths(commitTree(workspace, parent), tree))
-    const reverted = yield* revertedPaths(git, workspace, parent, tree, changed)
+    const changed = new Set(
+      shippedPaths(
+        withModes(workspace, commitTree(workspace, parent), parent),
+        withModes(workspace, tree, treeRef),
+      ),
+    )
+    // A landing whose hook rejected after the ship moved `<b>`: its tip is a ship of this very HEAD.
+    // An edit since (say, to satisfy that hook) ships again rather than reusing the stale ship.
+    const pending = parseCommitMessage(yield* git.lastCommitMessage(parent)).tip
+    if (
+      changed.size === 0 &&
+      pending !== undefined &&
+      pending === (yield* git.resolveRef("HEAD"))
+    ) {
+      return { kind: "recorded", hash: parent }
+    }
+    const reverted = yield* revertedPaths(git, workspace, parent, tree, changed, treeRef)
     if (reverted.length > 0) {
       return {
         kind: "blocked",
@@ -1750,7 +1824,7 @@ const shipBlockedAt = (
   Effect.gen(function* () {
     if (pin !== undefined || step.request.kind !== "ship" || changes.length > 0) return undefined
     const head = yield* (yield* GitService).resolveRef("HEAD")
-    const decision = yield* decideShip(setup.workspace, commitTree(setup.workspace, head))
+    const decision = yield* decideShip(setup.workspace, commitTree(setup.workspace, head), head)
     return decision.kind === "blocked" ? decision.message : undefined
   })
 
@@ -1763,7 +1837,7 @@ const shipSnapshot = (
 ) =>
   Effect.gen(function* () {
     const tree = pendingTree(rest.setup.workspace, rest.setup.pendingWorktree(), undefined)
-    const decision = yield* decideShip(rest.setup.workspace, tree)
+    const decision = yield* decideShip(rest.setup.workspace, tree, undefined)
     if (decision.kind === "blocked") return refusedSnapshot(rest, decision.message)
     const shipping = decision.kind === "ship"
     const decided = yield* decideLanding(
@@ -1771,9 +1845,17 @@ const shipSnapshot = (
       verdicts,
       branch,
       approver,
-      shipping ? SHIPPED_STAND_IN : undefined,
+      decision.kind === "recorded" ? decision.hash : shipping ? SHIPPED_STAND_IN : undefined,
     )
     if (decided.kind !== "commit") return snapshotOf(rest, decided)
+    if (decision.kind === "recorded") {
+      const recorded = {
+        ...decided,
+        spec: { ...decided.spec, shipped: decision.hash },
+        recordedHistory: processHistoryRef(rest.run.startHash),
+      }
+      return snapshotOf(rest, yield* withBranchAndPush(recorded))
+    }
     const landing: Landing = shipping
       ? {
           ...decided,

package/src/flows/helpers.ts

@@ -12,6 +12,7 @@ import {
   settings,
   threads,
   type Change,
+  type Changes,
   type JudgeAnswer,
   type Judgment,
 } from "./runtime.js"
@@ -78,15 +79,19 @@ const isCode = (path: string): boolean => path !== ".gtd" && !path.startsWith(".
 /** The last step's changes outside `.gtd/`. */
 export const codeChanges = (): readonly Change[] => changes().filter((c) => isCode(c.path))
 
+/** Validator form of `requireProgress`: the agent-addressed error, or `undefined` when the turn is valid. */
+export const progressErrors = (file: string, turnChanges: Changes): string | undefined => {
+  const change = turnChanges.get(file)
+  if (change?.status !== "deleted") return undefined
+  if (turnChanges.some((c) => isCode(c.path))) return undefined
+  if ((change.before ?? "").trim().startsWith("NOTHING ACTIONABLE")) return undefined
+  return `${file} was deleted without addressing its instructions — implement the changes it lists (then delete it), don't just remove the file. Its content was:\n${change.before ?? ""}`
+}
+
 /** Refuse a turn whose only change deletes `file` — unless it says it found nothing to do. */
 export const requireProgress = (file: string): void => {
-  const change = changes().get(file)
-  if (change?.status !== "deleted") return
-  if (codeChanges().length > 0) return
-  if ((change.before ?? "").trim().startsWith("NOTHING ACTIONABLE")) return
-  refuse(
-    `gtd land: feedback-progress: ${file} was deleted without addressing its instructions — implement the changes it lists (then delete it), don't just remove the file.`,
-  )
+  const error = progressErrors(file, changes())
+  if (error !== undefined) refuse(`gtd land: feedback-progress: ${error}`)
 }
 
 /** Refuse a turn that leaves a question in `file` unanswered. An untouched tree is silence, and allowed. */
@@ -135,23 +140,36 @@ export const requireThreadsClosed = (file: string): void => {
   )
 }
 
+/** Validator form of `requireReplies`: the agent-addressed error, or `undefined` when every thread is answered. */
+export const repliesErrors = (file: string): string | undefined => {
+  const open = [...threadLines(file, "agent"), ...codeThreadLines("agent")]
+  if (open.length === 0) return undefined
+  return `${countOf(open)} thread(s) in ${file} or code comments still wait on the agent — append one "- A:" reply to each (one "A:" comment line, same token and indentation, directly below a code thread's last line), or fold a concluded thread and delete it:\n${open.join("\n")}`
+}
+
 /** Refuse an agent turn that leaves a thread in `file`, or a code thread in a changed file, waiting on the agent (its last entry is `H:`) or with a syntax fault. */
 export const requireReplies = (file: string): void => {
-  const open = [...threadLines(file, "agent"), ...codeThreadLines("agent")]
-  if (open.length === 0) return
-  refuse(
-    `gtd land: unanswered-threads: ${countOf(open)} thread(s) in ${file} or code comments still wait on the agent — append one "- A:" reply to each (one "A:" comment line, same token and indentation, directly below a code thread's last line), or fold a concluded thread and delete it:\n${open.join("\n")}`,
-  )
+  const error = repliesErrors(file)
+  if (error !== undefined) refuse(`gtd land: unanswered-threads: ${error}`)
 }
 
-/** Refuse a turn that did not undo the code edits `edited` recorded, back to their content before `base`. */
-export const requireRevert = (edited: readonly Change[], base: string): void => {
+const revertFix = (edited: readonly Change[], base: string): string | undefined => {
   const residue = edited.filter((c) => read(c.path) !== c.before).map((c) => c.path)
-  if (residue.length === 0) return
+  if (residue.length === 0) return undefined
   const quoted = residue.map((path) => `'${path.replace(/'/g, "'\\''")}'`).join(" ")
-  refuse(
-    `gtd land: require-revert: ${residue.join(", ")} still differ from ${base}~1 — the revert did not take. Run \`git checkout ${base}~1 -- ${quoted}\`, then \`gtd land\` again.`,
-  )
+  return `${residue.join(", ")} still differ from ${base}~1 — the revert did not take. Run \`git checkout ${base}~1 -- ${quoted}\``
+}
+
+/** Validator form of `requireRevert`: reads the tree, not the turn's changes. */
+export const revertErrors = (edited: readonly Change[], base: string): string | undefined => {
+  const fix = revertFix(edited, base)
+  return fix === undefined ? undefined : `${fix}.`
+}
+
+/** Refuse a turn that did not undo the code edits `edited` recorded, back to their content before `base`. */
+export const requireRevert = (edited: readonly Change[], base: string): void => {
+  const fix = revertFix(edited, base)
+  if (fix !== undefined) refuse(`gtd land: require-revert: ${fix}, then \`gtd land\` again.`)
 }
 
 const SHAPES = ["land", "refactor-first", "reject"] as const

package/src/flows/index.test.ts

@@ -34,10 +34,12 @@ describe("@pmelab/gtd/flows", () => {
         "moveScript",
         "numeric",
         "openQuestions",
+        "progressErrors",
         "quote",
         "read",
         "refuse",
         "removeScript",
+        "repliesErrors",
         "requireAnswers",
         "requireProgress",
         "requireReplies",
@@ -45,6 +47,7 @@ describe("@pmelab/gtd/flows", () => {
         "requireThreadsClosed",
         "restart",
         "restoreScript",
+        "revertErrors",
         "revertScript",
         "run",
         "scope",

package/src/flows/index.ts

@@ -48,6 +48,8 @@ export {
   type JudgeQuestion,
   type JudgeQuestionInput,
   type JudgeSpec,
+  type ValidateResult,
+  type ValidateTurn,
   type Judgment,
   type KeptTip,
   type Mark,
@@ -78,11 +80,14 @@ export {
   hasThreadFor,
   judgeDiffShape,
   numeric,
+  progressErrors,
+  repliesErrors,
   requireAnswers,
   requireProgress,
   requireReplies,
   requireRevert,
   requireThreadsClosed,
+  revertErrors,
   seamGate,
   wrote,
   type Check,

package/src/flows/runtime.ts

@@ -37,9 +37,25 @@ type SteeringFile =
 /** A steering-file declaration shared by the steps that rest on one. `mode` requires `file`. */
 export type SteeringOptions = SteeringCommon & SteeringFile
 
+/** What a validator is told about the work so far. */
+export interface ValidateTurn {
+  /** Every change since before the first try, minus the files the validator's own steps wrote. */
+  readonly changes: Changes
+}
+
+export type ValidateResult = string | readonly string[] | undefined
+
 interface AgentCommon {
   readonly model?: string | undefined
   readonly system?: string | undefined
+  /** Runs after each landed turn; errors it returns become the correction the next try gets. Only `check`, `run` and `judge` may run inside. */
+  readonly validate?: ((turn: ValidateTurn) => Promise<ValidateResult>) | undefined
+  /** Retries before `exhausted` runs. Default 3. */
+  readonly cap?: number | undefined
+  /** Runs once `cap` retries failed; default rests at a `<name>.invalid` gate. The validator then runs again. */
+  readonly exhausted?: ((errors: readonly string[]) => Promise<void>) | undefined
+  /** The retry's `content`, instead of the default lead-in plus the errors. */
+  readonly correction?: ((errors: readonly string[]) => string) | undefined
 }
 
 export type AgentOptions = SteeringOptions &
@@ -209,6 +225,8 @@ export type StepRequest =
       readonly name: string
       readonly prompt: string
       readonly options: AgentOptions
+      /** On a validator retry: the step's original prompt (`prompt` is then the correction). */
+      readonly original?: string
     }
   | { readonly kind: "human"; readonly name: string; readonly options: HumanOptions }
   | {
@@ -331,9 +349,84 @@ const ctx = (): FlowContext => {
 
 // ── Steps ───────────────────────────────────────────────────────────────────
 
+// While a validator runs: its step's name, and the paths its own steps changed. Keyed by the
+// replay's context: a validator suspended at a rest never unwinds, so a global would leak.
+type Validating = { readonly name: string; readonly paths: Set<string> }
+const validatingBy = new WeakMap<FlowContext, Validating>()
+
+const DEFAULT_CAP = 3
+
+const noValidatorStep = (kind: string, name: string): void => {
+  const validating = validatingBy.get(ctx())
+  if (validating !== undefined) {
+    throw new Error(
+      `gtd: step "${name}": ${kind}() cannot run inside the validator of "${validating.name}" — a validator may only run check, run and judge steps`,
+    )
+  }
+}
+
+const noteValidatorPaths = (): void => {
+  const validating = validatingBy.get(ctx())
+  if (validating !== undefined) for (const c of ctx().changes()) validating.paths.add(c.path)
+}
+
+const errorList = (result: ValidateResult): readonly string[] =>
+  result === undefined ? [] : typeof result === "string" ? [result] : result
+
 /** An agent turn: `prompt` is emitted, the driver lands the diff. */
-export const agent = (name: string, prompt: string, options: AgentOptions = {}): Promise<void> =>
-  ctx().step({ kind: "agent", name, prompt, options }) as Promise<void>
+export const agent = async (
+  name: string,
+  prompt: string,
+  options: AgentOptions = {},
+): Promise<void> => {
+  noValidatorStep("agent", name)
+  const context = ctx()
+  const { validate, cap = DEFAULT_CAP, exhausted, correction } = options
+  const base = typeof validate === "function" ? context.head() : ""
+  await context.step({ kind: "agent", name, prompt, options })
+  if (typeof validate !== "function") return
+
+  const own = new Set<string>()
+  // Paths an agent turn or a person changed. Whatever changed since the last validator returned
+  // is theirs — even on a path a validator `run` (lint --fix) wrote in an earlier round.
+  const agentPaths = new Set<string>()
+  let validated = base
+  const validateNow = async (): Promise<readonly string[]> => {
+    for (const c of context.changesSince(validated)) agentPaths.add(c.path)
+    const turn: ValidateTurn = {
+      get changes() {
+        return toChanges(
+          context.changesSince(base).filter((c) => !own.has(c.path) || agentPaths.has(c.path)),
+        )
+      },
+    }
+    validatingBy.set(context, { name, paths: own })
+    try {
+      return errorList(await scope(`${name}.validate`, () => validate(turn)))
+    } finally {
+      validatingBy.delete(context)
+      validated = context.head()
+    }
+  }
+
+  let errors = await validateNow()
+  let retries = 0
+  while (errors.length > 0) {
+    if (retries >= cap) {
+      if (exhausted !== undefined) await exhausted(errors)
+      else await human(`${name}.invalid`, errors.join("\n"), { acceptClean: true })
+      retries = 0
+    } else {
+      retries++
+      const text =
+        correction !== undefined
+          ? correction(errors)
+          : `The result did not pass validation. Fix these errors:\n\n${errors.join("\n")}\n`
+      await context.step({ kind: "agent", name, prompt: text, options, original: prompt })
+    }
+    errors = await validateNow()
+  }
+}
 
 // `Omit` over a union collapses it; this keeps each member's own rules.
 type OmitEach<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never
@@ -349,8 +442,9 @@ export const human: Human = (
   name: string,
   messageOrOptions?: string | HumanOptions,
   options?: OmitEach<HumanOptions, "message">,
-): Promise<void> =>
-  ctx().step({
+): Promise<void> => {
+  noValidatorStep("human", name)
+  return ctx().step({
     kind: "human",
     name,
     options:
@@ -358,10 +452,13 @@ export const human: Human = (
         ? { ...options, message: messageOrOptions }
         : (messageOrOptions ?? {}),
   }) as Promise<void>
+}
 
 /** A check: `body` runs at the edge and its effect on the tree is committed. */
-export const run = (name: string, body: string, options: RunOptions = {}): Promise<void> =>
-  ctx().step({ kind: "run", name, body, options }) as Promise<void>
+export const run = async (name: string, body: string, options: RunOptions = {}): Promise<void> => {
+  await ctx().step({ kind: "run", name, body, options })
+  noteValidatorPaths()
+}
 
 /**
  * Squashes HEAD's tree, with `.gtd/` as the user's branch has it, into one commit on the user's branch
@@ -372,8 +469,10 @@ export const ship = (
   name: string,
   message: string,
   options: ShipOptions = {},
-): Promise<string | undefined> =>
-  ctx().step({ kind: "ship", name, message, options }) as Promise<string | undefined>
+): Promise<string | undefined> => {
+  noValidatorStep("ship", name)
+  return ctx().step({ kind: "ship", name, message, options }) as Promise<string | undefined>
+}
 
 /** A judge gate: resolves to what the judge answered, for the flow to decide on. */
 export const judge = <const Q extends readonly JudgeQuestionInput[] = readonly JudgeQuestion[]>(
@@ -385,17 +484,25 @@ export const judge = <const Q extends readonly JudgeQuestionInput[] = readonly J
   const canonical = questions.map((q) =>
     q.primitive === "yesno" ? { ...q, primitive: "noul" as const } : (q as JudgeQuestion),
   )
-  return ctx().step({
-    kind: "judge",
-    name,
-    questions: canonical,
-    evidence,
-    options,
-  }) as Promise<Judgment<Q[number]["id"]>>
+  return ctx()
+    .step({
+      kind: "judge",
+      name,
+      questions: canonical,
+      evidence,
+      options,
+    })
+    .then((judgment) => {
+      noteValidatorPaths()
+      return judgment as Judgment<Q[number]["id"]>
+    })
 }
 
 /** End the episode from any depth. The next episode starts the flow afresh. */
-export const restart = (): Promise<never> => ctx().step({ kind: "restart" }) as Promise<never>
+export const restart = (): Promise<never> => {
+  noValidatorStep("restart", "restart")
+  return ctx().step({ kind: "restart" }) as Promise<never>
+}
 
 /** Refuse the pending turn: nothing lands, the process stays where it rests. */
 export const refuse = (message: string): never => ctx().refuse(message)

package/src/install/Install.ts

@@ -83,6 +83,7 @@ while :; do
       model="$(gtd next --json=model)"
       system="$(gtd next --json=system)"
       validate="$(gtd next --json=validate)"
+      fresh="$(gtd next --json=fresh)"
       log="$(gtd next --json=log)"
       # \`model\` is a hint, not a model name — gtd-workflows' default ships
       # \`smart\` and \`base\`, which \`claude --model\` rejects. Resolve them
@@ -125,8 +126,14 @@ while :; do
       then first=--resume second=--session-id
       else first=--session-id second=--resume
       fi
+      # A validator retry resumes with the correction alone; a session that
+      # cannot resume starts over with \`fresh\`, the original prompt plus it.
+      second_prompt="$log.prompt"
+      if [ "$second" = --session-id ] && [ -n "\${fresh:-}" ]
+      then printf '%s\\n' "$fresh" >"$log.fresh" && second_prompt="$log.fresh"
+      fi
       turn "$first" "$session_id" <"$log.prompt" ||
-        { [ "$ran" = false ] && turn "$second" "$session_id" <"$log.prompt"; } || {
+        { [ "$ran" = false ] && turn "$second" "$session_id" <"$second_prompt"; } || {
         echo "agent turn failed — see $log" >&2
         exit 1
       }
@@ -140,7 +147,7 @@ while :; do
           exit 1
         }
       done
-      rm -f "$log.prompt" ;;
+      rm -f "$log.prompt" "$log.fresh" ;;
   esac
 
   # Read every value the landing needs BEFORE piping the script to \`sh\`:

package/src/platform/Git.test.ts

@@ -87,17 +87,13 @@ describe("diffPaths [Live]", () => {
   })
 
   // An exported GIT_DIR/GIT_WORK_TREE would send this test's commits to the real repo;
-  // the pinned config keeps a global commit.gpgsign or missing identity from failing them.
-  const cleanEnv = {
-    ...Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("GIT_"))),
-    GIT_CONFIG_COUNT: "3",
-    GIT_CONFIG_KEY_0: "commit.gpgsign",
-    GIT_CONFIG_VALUE_0: "false",
-    GIT_CONFIG_KEY_1: "user.email",
-    GIT_CONFIG_VALUE_1: "test@test.com",
-    GIT_CONFIG_KEY_2: "user.name",
-    GIT_CONFIG_VALUE_2: "Test",
-  }
+  // the suite's isolated global config keeps a developer's signing setup out.
+  const cleanEnv = Object.fromEntries(
+    Object.entries(process.env).filter(
+      ([key]) =>
+        !key.startsWith("GIT_") || key === "GIT_CONFIG_GLOBAL" || key === "GIT_CONFIG_NOSYSTEM",
+    ),
+  )
 
   it("reports a submodule pointer bump whatever diff.ignoreSubmodules and .gitmodules ignore say", async () => {
     const root = realpathSync(mkdtempSync(join(tmpdir(), "gtd-diffpaths-sm-")))

package/src/platform/NodeSync.ts

@@ -39,6 +39,8 @@ const infoOf = (stats: Stats): FileInfo => ({
         ? "file"
         : "other",
   uid: process.platform === "win32" ? undefined : stats.uid,
+  // git records 100755 from the owner execute bit alone.
+  ...(process.platform === "win32" ? {} : { executable: (stats.mode & 0o100) !== 0 }),
 })
 
 export const nodeSyncIo: SyncIo = {

package/src/platform/SyncIo.ts

@@ -4,6 +4,8 @@ export interface FileInfo {
   readonly type: "file" | "directory" | "symlink" | "other"
   /** `undefined` where the platform has no POSIX user ids. */
   readonly uid: number | undefined
+  /** Any execute bit set; `undefined` where the platform has none. */
+  readonly executable?: boolean
 }
 
 /**