@pmelab/gtd 64.3.0 → 66.0.0

package/claude/hooks/register.tsx

@@ -15,6 +15,7 @@ import {
   decided,
   missingReasons,
   reply,
+  processTip,
   REVIEW_FILE,
   unresolvedThreads,
   withThreads,
@@ -25,9 +26,8 @@ import type { Judgment } from "./judge"
 import { catchFrom, throwTo } from "./handoff"
 import { jobs } from "./jobs"
 import { documents, readDocument } from "./schema"
-import { READ_ONLY_GIT, ship } from "./ship"
 import { withRequirements } from "./sketch"
-import type { Shipped, ShipIo } from "./ship"
+import type { Done, GitIo } from "./git"
 import { collectAnswer } from "./delegate"
 import { decideCommand, decideContinue, decideJob, restId, TOOLS } from "./tools"
 import type { JobName } from "./tools"
@@ -72,7 +72,7 @@ let isDriving = false
 // bumped by every stop, so a queued continue that was mid-check sees it
 let stopCount = 0
 // subagents answering into a file: what each may touch (see tool.call)
-const delegates = new Map<string, { file: string; mayRun: RegExp | undefined }>()
+const delegates = new Map<string, { file: string }>()
 const ours = new Set<string>()
 // What each turn agent may read and write; reset on every spawn and resume,
 // since the steering file can differ per step.
@@ -218,7 +218,7 @@ function io($: $): Io {
       // held it): start one, as the sh driver falls back to `--session-id`.
       const spawned = await $.agent.spawn({
         subagentType: await persona($, t),
-        prompt: t.prompt,
+        prompt: t.fresh ?? t.prompt,
         description: t.label || "gtd",
         model: await workerModel($, t.model),
         cwd: root,
@@ -295,8 +295,7 @@ async function wake($: $) {
   const r = await read($, run)
   const stop = r.stop
   if (!stop || !r.rest) return
-  const branch = stop.kind === "done" ? await shippable($) : undefined
-  if (!wakes(stop, branch)) return
+  if (!wakes(stop)) return
   const questions = stop.isJudge ? await openQuestions($) : undefined
   const text = wakePrompt({
     stop,
@@ -304,7 +303,6 @@ async function wake($: $) {
     notes: r.notes,
     isRepeat: r.isRepeat,
     questions,
-    branch,
   })
   await update($, run, (x) => ({ ...x, notes: undefined }))
   // Not from inside the hook that started the run: a prompt submitted there
@@ -321,16 +319,6 @@ async function openQuestions($: $) {
   }
 }
 
-// The branch a finished process can open its pull request from, if any.
-async function shippable($: $) {
-  const branch = (
-    await $.process.run(["git", "rev-parse", "--abbrev-ref", "HEAD"], { cwd: root })
-  ).stdout.trim()
-  if (["main", "master", "HEAD"].includes(branch)) return undefined
-  const summary = await $.process.run(["gtd", "summary"], { cwd: root })
-  return summary.exitCode === 0 ? branch : undefined
-}
-
 // A new process starts from the requirements written to the steering file an
 // idle rest names; the opening beat captures them like a hand-edit.
 async function begin($: $, requirements: string) {
@@ -440,8 +428,8 @@ function startJob(
   $: $,
   job: JobName,
   isInTurn: boolean,
-  work: () => Promise<Shipped>,
-  then?: (outcome: Shipped) => Promise<void>,
+  work: () => Promise<Done>,
+  then?: (outcome: Done) => Promise<void>,
 ) {
   const answer = background.start(job, work, true, async (outcome) => {
     if (then) await then(outcome)
@@ -457,7 +445,7 @@ function startJob(
 }
 
 async function throwNow($: $, target: string | undefined, isInTurn: boolean) {
-  const refused = decideJob(await read($, run), "handoff")
+  const refused = decideJob(await read($, run))
   if (refused) return refused
   return startJob(
     $,
@@ -474,7 +462,7 @@ async function throwNow($: $, target: string | undefined, isInTurn: boolean) {
         content: b.content,
         isIdle: isTrue(b.idle),
       }
-      return throwTo(shipIo($), rest, target, new Date().toISOString())
+      return throwTo(gitIo($), rest, target, new Date().toISOString())
     },
     async (thrown) => {
       if (!thrown.ok) return
@@ -490,7 +478,7 @@ async function throwNow($: $, target: string | undefined, isInTurn: boolean) {
 
 async function enterNow($: $, door: string, args: string[]) {
   if ((await read($, run)).isRunning) return "Stop the loop first: /gtd stop."
-  const entered = await enter(shipIo($), door, args)
+  const entered = await enter(gitIo($), door, args)
   if (entered.ok) await start($)
   return entered.text
 }
@@ -511,7 +499,7 @@ async function prNow($: $) {
   if (r.pr && !isReviewGate(r.stop)) {
     return "Review threads from an earlier /gtd pr wait for the review's first review gate."
   }
-  const io = shipIo($)
+  const io = gitIo($)
   const pr = await currentPr(io)
   if (typeof pr === "string") return pr
   const threads = await unresolvedThreads(io, pr)
@@ -585,11 +573,13 @@ async function prRest($: $, stop: Stop) {
 async function replyThreads($: $, stop: Stop) {
   const pr = (await read($, run)).pr
   if (!pr?.importedAt) return
-  const io = shipIo($)
+  const io = gitIo($)
+  const { tip } = await processTip(io)
   const found = await decided(
     io,
     pr.importedAt,
     pr.threads.map((t) => t.id),
+    tip,
   )
   if (found === "gone") {
     $.ui.log("gtd pr: the history moved since the review threads were added; they get no replies.")
@@ -605,12 +595,24 @@ async function replyThreads($: $, stop: Stop) {
   $.ui.status("replying to the review threads…")
   let replied
   try {
-    replied = await reply(io, pr.host, found.gate, found.answers)
+    replied = await reply(io, pr.host, found.gate, found.answers, stop.kind === "done")
   } finally {
     $.ui.status(undefined)
   }
-  for (const line of replied.text.split("\n")) $.ui.log(line)
-  $.ui.toast(replied.text.split("\n")[0]!)
+  if (replied.text) {
+    for (const line of replied.text.split("\n")) $.ui.log(line)
+    $.ui.toast(replied.text.split("\n")[0]!)
+  }
+  if (replied.waiting.length > 0) {
+    // Unshipped fixes keep their threads; answered ones are not answered twice.
+    if (replied.isPushed) {
+      const keep = new Set(replied.waiting.map((a) => a.thread))
+      await update($, run, (x) =>
+        x.pr ? { ...x, pr: { ...x.pr, threads: x.pr.threads.filter((t) => keep.has(t.id)) } } : x,
+      )
+    }
+    return
+  }
   if (replied.isPushed) await forgetPr($)
 }
 
@@ -618,7 +620,7 @@ async function replyThreads($: $, stop: Stop) {
 // shown to the catcher first, never landed unseen.
 async function catchNow($: $, ref: string) {
   if ((await read($, run)).isRunning) return "Stop the loop first: /gtd stop."
-  const caught = await catchFrom(shipIo($), ref)
+  const caught = await catchFrom(gitIo($), ref)
   if (!caught.ok) return caught.text
   await findRoot($)
   const b = await docs($).next()
@@ -636,27 +638,11 @@ async function catchNow($: $, ref: string) {
   return caught.text
 }
 
-// Ship's text turns need git to read the process, so they run as a subagent.
-// Its answer is a file, not its hand-back: a hand-back never reaches a mod.
-// `mayRun`: the only shell commands the subagent may run; none when absent.
 type Delegate = {
   name: string
   description: string
   system: string
   tools: string[]
-  mayRun?: RegExp
-}
-
-const SHIPPER: Delegate = {
-  name: "shipper",
-  description:
-    "Writes commit messages and pull requests for gtd's ship, spawned by the gtd mod only",
-  system:
-    "You write commit messages and pull-request descriptions for gtd's ship command. Read the repository with git and the file tools as the instructions ask. Never modify the repository: no commits, no checkouts, no pushes.",
-  tools: ["Bash", "Read", "Grep", "Glob", "Write", "Skill"],
-  // It reads commit messages anyone on the branch wrote: read-only git, and
-  // no shell syntax to chain anything else onto it.
-  mayRun: READ_ONLY_GIT,
 }
 
 // gtd's llm judge persona; writing its answer file is its one tool.
@@ -693,7 +679,7 @@ async function delegate($: $, who: Delegate, prompt: string, model: string, deli
   const id = spawned.agentId
   if (!id) return undefined
   ours.add(id)
-  delegates.set(id, { file, mayRun: who.mayRun })
+  delegates.set(id, { file })
   // A timed-out agent may still be running: it keeps its tool limits until its
   // turn ends, where turn.complete drops them.
   return collectAnswer({
@@ -704,11 +690,6 @@ async function delegate($: $, who: Delegate, prompt: string, model: string, deli
   })
 }
 
-async function writer($: $, prompt: string) {
-  const model = (await $.env.get("GTD_PLANNERMODEL")) ?? "opus"
-  return delegate($, SHIPPER, prompt, model, "Your final answer, exactly as you would print it.")
-}
-
 // Where `gtd judge run` would pick its llm, a judge gate is put to a small
 // model as that provider does, but as a subagent of this session. Any doubt leaves the
 // gate to the person, which routes the workflow its cautious way.
@@ -729,39 +710,19 @@ async function judgeInSession($: $, j: Judgment) {
   }
 }
 
-function shipIo($: $): ShipIo {
+function gitIo($: $): GitIo {
   return {
     run: async (argv, stdin) => {
       const r = await $.process.run(argv, { cwd: root, stdin, timeoutMs: TEN_MINUTES })
       return { code: r.exitCode, out: r.stdout, err: r.stderr }
     },
-    complete: (prompt) => writer($, prompt),
     log: (line) => {
       for (const l of line.split("\n")) $.ui.log(l)
       if (background.busy()) $.ui.status(line.split("\n")[0]!)
     },
-    today: () => new Date().toISOString().slice(0, 10),
   }
 }
 
-async function shipNow($: $, isDry: boolean, isInTurn: boolean) {
-  const refused = decideJob(await read($, run), "ship")
-  if (refused) return refused
-  return startJob(
-    $,
-    "ship",
-    isInTurn,
-    async () => {
-      $.ui.status(isDry ? "previewing the pull request…" : "opening the pull request…")
-      return ship(shipIo($), isDry)
-    },
-    async (shipped) => {
-      // a failed ship leaves the run as it was; a dry run changes nothing
-      if (shipped.ok && !isDry) await dismiss($)
-    },
-  )
-}
-
 // Turns a missing CLI or a wrong directory into an instruction, not a stack trace.
 // The plugin is gtd's own npm package, so it runs the gtd it ships and the mod
 // and the CLI never disagree. A checkout without a build falls back to PATH.
@@ -986,8 +947,6 @@ async function command($: $, arg: string): Promise<string | undefined> {
       return rest[0]
         ? catchNow($, rest[0])
         : "Name the pull request or branch: /gtd catch <number|branch>."
-    case "ship":
-      return shipNow($, rest[0] === "-n" || rest[0] === "--dry-run", false)
     case "":
       return resume($)
     default:
@@ -997,7 +956,7 @@ async function command($: $, arg: string): Promise<string | undefined> {
 
 // A door wins over the bare `pr` verb; anything else is requirements.
 async function routed($: $, verb: string, rest: string[], arg: string) {
-  if (doorFor(await doors(shipIo($)), verb, rest)) return enterNow($, verb, rest)
+  if (doorFor(await doors(gitIo($)), verb, rest)) return enterNow($, verb, rest)
   return verb === "pr" && rest.length === 0 ? prNow($) : begin($, arg)
 }
 
@@ -1067,12 +1026,9 @@ function subagentDenial(agentId: string, e: Record<string, unknown>) {
   if (denial) return denial
   const delegated = delegates.get(agentId)
   if (!delegated) return undefined
-  if (e.tool === "Write" && e.file_path !== delegated.file) {
+  if ((e.tool === "Write" && e.file_path !== delegated.file) || e.tool === "Bash") {
     return `Write only your answer, to ${delegated.file}.`
   }
-  if (e.tool === "Bash" && !delegated.mayRun?.test(String(e.command).trim())) {
-    return "Only read-only git commands, without shell syntax, are allowed here."
-  }
   return undefined
 }
 
@@ -1111,7 +1067,7 @@ export const register: Register = (on) => {
       name: "gtd",
       description: "Drive gtd until it rests on you; pass requirements to start a new process",
       argumentHint:
-        "[requirements | <door> [args] | stop | status | ui | ship [-n] | pr | throw [@user] | catch <pr|branch>]",
+        "[requirements | <door> [args] | stop | status | ui | pr | throw [@user] | catch <pr|branch>]",
       immediate: true,
     })
     return next(e)
@@ -1191,9 +1147,6 @@ export const register: Register = (on) => {
   on("tool.call", { tool: "mcp__gtd__handoff" }, async ($, e) =>
     answer(await throwNow($, typeof e.to === "string" && e.to ? e.to : undefined, true), true),
   )
-  on("tool.call", { tool: "mcp__gtd__ship" }, async ($, e) =>
-    answer(await shipNow($, e.dryRun === true, true), true),
-  )
   on("tool.call", { tool: "mcp__gtd__browser" }, async ($) => answer(await browse($), true))
 
   on("agent.offer", ($, e, next) => (e.agent.startsWith("gtd:") ? { isOffered: false } : next(e)))

package/claude/hooks/tools.ts

@@ -10,7 +10,6 @@ export const TOOL = {
   continue: "mcp__gtd__continue",
   note: "mcp__gtd__note",
   handoff: "mcp__gtd__handoff",
-  ship: "mcp__gtd__ship",
   browser: "mcp__gtd__browser",
 } as const
 
@@ -44,12 +43,6 @@ export const TOOLS = [
       "Hands the gtd process to someone else: pushes the branch and opens or refreshes a draft pull request assigned to them. Call it only when the person asks. `to`: their GitHub username; omit it to leave the process for anyone.",
     inputSchema: { type: "object", properties: { to: { type: "string" } } },
   },
-  {
-    name: "ship",
-    description:
-      "Combines the finished gtd process into one commit, pushes it and opens or updates its pull request. Call it only after the person agreed. `dryRun` previews without writing anything.",
-    inputSchema: { type: "object", properties: { dryRun: { type: "boolean" } } },
-  },
   {
     name: "browser",
     description:
@@ -71,21 +64,21 @@ export type ContinueIo = {
   // the rest's own `gtd validate` script, run; ok when there is nothing to check
   validate(): Promise<{ ok: boolean; out: string }>
   judgment(): Promise<Judgment | undefined>
-  // a ship or hand-off running or queued: it writes the tree the driver would
+  // a hand-off running or queued: it writes the tree the driver would
   busy?: JobName
 }
 
-export type JobName = "ship" | "handoff"
+export type JobName = "handoff"
 
-export const JOB_NAME: Record<JobName, string> = { ship: "ship", handoff: "hand-off" }
+export const JOB_NAME: Record<JobName, string> = { handoff: "hand-off" }
 
 const busyText = (job: JobName) => `A ${JOB_NAME[job]} is still running: wait for its report.`
 
-// Only these leave the tree alone (ship and throw refuse for themselves); any
+// Only these leave the tree alone (throw refuses for itself); any
 // other verb, unknown ones included, may switch branch or write .gtd/. `stop`
 // is not here: `command` takes the bare word itself, and `stop <words>` is a
 // requirement. `ui` is not: its page writes steering files.
-const WHILE_BUSY = new Set(["status", "throw", "ship"])
+const WHILE_BUSY = new Set(["status", "throw"])
 
 export function decideCommand(arg: string, busy: JobName | undefined): string | undefined {
   if (!busy) return undefined
@@ -94,13 +87,9 @@ export function decideCommand(arg: string, busy: JobName | undefined): string |
 }
 
 // Pure: a refused job leaves the run, and so `continue`, as it was.
-export function decideJob(run: Run, job: JobName): string | undefined {
+export function decideJob(run: Run): string | undefined {
   if (run.isRunning) return "gtd is running a step: wait for it to rest."
   if (run.pending) return "A continue is already waiting for this turn to end."
-  const kind = run.stop?.kind
-  if (job === "ship" && (kind === "gate" || kind === "stalled" || kind === "error")) {
-    return "gtd still waits on the person at this step: answer it with continue first."
-  }
   return undefined
 }
 
@@ -116,9 +105,7 @@ export async function decideContinue(
   if (io.busy) return { refuse: busyText(io.busy) }
   const stop = run.stop
   if (!stop) return { refuse: "Nothing is waiting: gtd has no rest open. /gtd drives it." }
-  if (stop.kind === "done") {
-    return { refuse: `The process is finished: ${TOOL.ship} opens its pull request.` }
-  }
+  if (stop.kind === "done") return { refuse: "The process is finished: nothing waits here." }
   if (rest !== undefined && rest !== run.rest) {
     return {
       refuse: "gtd has moved on from that step; it no longer waits there. Nothing was changed.",

package/claude/hooks/wording.ts

@@ -2,7 +2,7 @@
 
 import type { Stop } from "../types"
 import type { Beat } from "./drive"
-import type { Shipped } from "./ship"
+import type { Done } from "./git"
 import { JOB_NAME } from "./tools"
 import type { JobName } from "./tools"
 
@@ -61,8 +61,8 @@ export function pushText(stop: Stop, repo: string, url?: string) {
 
 const capitalised = (s: string) => s[0]!.toUpperCase() + s.slice(1)
 
-export const jobHeadline = (job: JobName, outcome: Shipped) =>
+export const jobHeadline = (job: JobName, outcome: Done) =>
   `${outcome.ok ? "✔" : "✘"} ${capitalised(JOB_NAME[job])} ${outcome.ok ? "finished" : "failed"}`
 
-export const jobPushText = (job: JobName, outcome: Shipped, repo: string) =>
+export const jobPushText = (job: JobName, outcome: Done, repo: string) =>
   `${repo}: ${JOB_NAME[job]} ${outcome.ok ? "finished" : "failed"}. ${outcome.text}`.trim()

package/dist/chunks/{flows-dnIE_qbe.mjs → flows-CmQplvh1.mjs}

@@ -37,29 +37,106 @@ const ctx = () => {
 	}
 	return context;
 };
+const validatingBy = /* @__PURE__ */ new WeakMap();
+const DEFAULT_CAP = 3;
+const noValidatorStep = (kind, name) => {
+	const validating = validatingBy.get(ctx());
+	if (validating !== void 0) 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 = () => {
+	const validating = validatingBy.get(ctx());
+	if (validating !== void 0) for (const c of ctx().changes()) validating.paths.add(c.path);
+};
+const errorList = (result) => result === void 0 ? [] : typeof result === "string" ? [result] : result;
 /** An agent turn: `prompt` is emitted, the driver lands the diff. */
-const agent = (name, prompt, options = {}) => ctx().step({
-	kind: "agent",
-	name,
-	prompt,
-	options
-});
+const agent = async (name, prompt, options = {}) => {
+	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 = /* @__PURE__ */ new Set();
+	const agentPaths = /* @__PURE__ */ new Set();
+	let validated = base;
+	const validateNow = async () => {
+		for (const c of context.changesSince(validated)) agentPaths.add(c.path);
+		const turn = { 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 !== void 0) await exhausted(errors);
+			else await human(`${name}.invalid`, errors.join("\n"), { acceptClean: true });
+			retries = 0;
+		} else {
+			retries++;
+			const text = correction !== void 0 ? 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();
+	}
+};
 /** A human gate: the process rests until a person lands a turn. */
-const human = (name, messageOrOptions, options) => ctx().step({
-	kind: "human",
-	name,
-	options: typeof messageOrOptions === "string" ? {
-		...options,
-		message: messageOrOptions
-	} : messageOrOptions ?? {}
-});
+const human = (name, messageOrOptions, options) => {
+	noValidatorStep("human", name);
+	return ctx().step({
+		kind: "human",
+		name,
+		options: typeof messageOrOptions === "string" ? {
+			...options,
+			message: messageOrOptions
+		} : messageOrOptions ?? {}
+	});
+};
 /** A check: `body` runs at the edge and its effect on the tree is committed. */
-const run = (name, body, options = {}) => ctx().step({
-	kind: "run",
-	name,
-	body,
-	options
-});
+const run = async (name, body, options = {}) => {
+	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
+* with `message`, and moves that branch there; HEAD stays on `gtd/<b>`.
+* Resolves to the new commit's hash, or `undefined` when nothing shipped.
+*/
+const ship = (name, message, options = {}) => {
+	noValidatorStep("ship", name);
+	return ctx().step({
+		kind: "ship",
+		name,
+		message,
+		options
+	});
+};
 /** A judge gate: resolves to what the judge answered, for the flow to decide on. */
 const judge = (name, spec) => {
 	const { questions, evidence, ...options } = spec;
@@ -73,10 +150,16 @@ const judge = (name, spec) => {
 		questions: canonical,
 		evidence,
 		options
+	}).then((judgment) => {
+		noteValidatorPaths();
+		return judgment;
 	});
 };
 /** End the episode from any depth. The next episode starts the flow afresh. */
-const restart = () => ctx().step({ kind: "restart" });
+const restart = () => {
+	noValidatorStep("restart", "restart");
+	return ctx().step({ kind: "restart" });
+};
 /** Refuse the pending turn: nothing lands, the process stays where it rests. */
 const refuse = (message) => ctx().refuse(message);
 /**
@@ -348,13 +431,18 @@ const check = async (name, command, report, options = {}) => {
 const isCode = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
 /** The last step's changes outside `.gtd/`. */
 const codeChanges = () => changes().filter((c) => isCode(c.path));
+/** Validator form of `requireProgress`: the agent-addressed error, or `undefined` when the turn is valid. */
+const progressErrors = (file, turnChanges) => {
+	const change = turnChanges.get(file);
+	if (change?.status !== "deleted") return void 0;
+	if (turnChanges.some((c) => isCode(c.path))) return void 0;
+	if ((change.before ?? "").trim().startsWith("NOTHING ACTIONABLE")) return void 0;
+	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. */
 const requireProgress = (file) => {
-	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 !== void 0) refuse(`gtd land: feedback-progress: ${error}`);
 };
 /** Refuse a turn that leaves a question in `file` unanswered. An untouched tree is silence, and allowed. */
 const requireAnswers = (file) => {
@@ -377,18 +465,32 @@ const requireThreadsClosed = (file) => {
 	if (open.length === 0) return;
 	refuse(`gtd land: open-threads: ${countOf(open)} thread(s) in ${file} or code comments wait on you — reply with a conclusion, or delete the thread:\n${open.join("\n")}`);
 };
+/** Validator form of `requireReplies`: the agent-addressed error, or `undefined` when every thread is answered. */
+const repliesErrors = (file) => {
+	const open = [...threadLines(file, "agent"), ...codeThreadLines("agent")];
+	if (open.length === 0) return void 0;
+	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. */
 const requireReplies = (file) => {
-	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 !== void 0) refuse(`gtd land: unanswered-threads: ${error}`);
 };
-/** Refuse a turn that did not undo the code edits `edited` recorded, back to their content before `base`. */
-const requireRevert = (edited, base) => {
+const revertFix = (edited, base) => {
 	const residue = edited.filter((c) => read(c.path) !== c.before).map((c) => c.path);
-	if (residue.length === 0) return;
+	if (residue.length === 0) return void 0;
 	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. */
+const revertErrors = (edited, base) => {
+	const fix = revertFix(edited, base);
+	return fix === void 0 ? void 0 : `${fix}.`;
+};
+/** Refuse a turn that did not undo the code edits `edited` recorded, back to their content before `base`. */
+const requireRevert = (edited, base) => {
+	const fix = revertFix(edited, base);
+	if (fix !== void 0) refuse(`gtd land: require-revert: ${fix}, then \`gtd land\` again.`);
 };
 const SHAPES = [
 	"land",
@@ -551,7 +653,8 @@ const CONFIG_KEYS = [
 	"modes",
 	"ui",
 	"skills",
-	"access"
+	"access",
+	"historyRemote"
 ];
 const MODE_KEYS = ["format", "validate"];
 const UI_KEYS = [
@@ -622,6 +725,10 @@ const configProblems = (value) => {
 		...unknownKeys(value, CONFIG_KEYS, []),
 		...value.modes === void 0 ? [] : recordOf(value.modes, ["modes"], "modes", modeProblems),
 		...value.ui === void 0 ? [] : uiProblems(value.ui, ["ui"]),
+		...value.historyRemote === void 0 || typeof value.historyRemote === "string" && value.historyRemote.trim() !== "" ? [] : [{
+			path: ["historyRemote"],
+			message: "must be a non-empty remote name"
+		}],
 		...value.skills === void 0 ? [] : recordOf(value.skills, ["skills"], "skill-name arrays", (v, path) => isStringArray(v) ? [] : [{
 			path,
 			message: "must be an array of skill names"
@@ -671,10 +778,12 @@ var flows_exports = /* @__PURE__ */ __exportAll({
 	moveScript: () => moveScript,
 	numeric: () => numeric,
 	openQuestions: () => openQuestions,
+	progressErrors: () => progressErrors,
 	quote: () => quote,
 	read: () => read,
 	refuse: () => refuse,
 	removeScript: () => removeScript,
+	repliesErrors: () => repliesErrors,
 	requireAnswers: () => requireAnswers,
 	requireProgress: () => requireProgress,
 	requireReplies: () => requireReplies,
@@ -682,6 +791,7 @@ var flows_exports = /* @__PURE__ */ __exportAll({
 	requireThreadsClosed: () => requireThreadsClosed,
 	restart: () => restart,
 	restoreScript: () => restoreScript,
+	revertErrors: () => revertErrors,
 	revertScript: () => revertScript,
 	run: () => run,
 	scope: () => scope,
@@ -690,6 +800,7 @@ var flows_exports = /* @__PURE__ */ __exportAll({
 	sections: () => sections,
 	settings: () => settings,
 	settingsOf: () => settingsOf,
+	ship: () => ship,
 	showScript: () => showScript,
 	skillsFor: () => skillsFor,
 	start: () => start,
@@ -698,4 +809,4 @@ var flows_exports = /* @__PURE__ */ __exportAll({
 	writeScript: () => writeScript,
 	wrote: () => wrote
 });
-export { run as $, FLOWS_PROTOCOL as A, head as B, moveScript as C, revertScript as D, restoreScript as E, changesSince as F, mark as G, installContext as H, codeThreads as I, openQuestions as J, markedOptions as K, envSettings as L, accessFor as M, agent as N, showScript as O, changes as P, restart as Q, envSettingsOf as R, checkScript as S, removeScript as T, judge as U, human as V, kept as W, read as X, protocolMismatch as Y, refuse as Z, requireRevert as _, defineWorkflow as a, skillsFor as at, wrote as b, check as c, workflow as ct, hasThreadFor as d, scope as et, judgeDiffShape as f, requireReplies as g, requireProgress as h, configure as i, settingsOf as it, FlowsProtocolError as j, writeScript as k, codeChanges as l, requireAnswers as m, configProblems as n, sections as nt, isFactoryWorkflow as o, start as ot, numeric as p, matches as q, defineConfig as r, settings as rt, answered as s, threads as st, flows_exports as t, sectionBodies as tt, displayPath as u, requireThreadsClosed as v, quote as w, applyScript as x, seamGate as y, glob as z };
+export { read as $, revertScript as A, envSettings as B, wrote as C, quote as D, moveScript as E, accessFor as F, installContext as G, glob as H, agent as I, mark as J, judge as K, changes as L, writeScript as M, FLOWS_PROTOCOL as N, removeScript as O, FlowsProtocolError as P, protocolMismatch as Q, changesSince as R, seamGate as S, checkScript as T, head as U, envSettingsOf as V, human as W, matches as X, markedOptions as Y, openQuestions as Z, requireProgress as _, defineWorkflow as a, sections as at, requireThreadsClosed as b, check as c, ship as ct, hasThreadFor as d, threads as dt, refuse as et, judgeDiffShape as f, workflow as ft, requireAnswers as g, repliesErrors as h, configure as i, sectionBodies as it, showScript as j, restoreScript as k, codeChanges as l, skillsFor as lt, progressErrors as m, configProblems as n, run as nt, isFactoryWorkflow as o, settings as ot, numeric as p, kept as q, defineConfig as r, scope as rt, answered as s, settingsOf as st, flows_exports as t, restart as tt, displayPath as u, start as ut, requireReplies as v, applyScript as w, revertErrors as x, requireRevert as y, codeThreads as z };