@pmelab/gtd 65.0.0 → 66.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "65.0.0",
+  "version": "66.0.0",
   "description": "Drive the gtd loop inside Claude Code: agent turns run as subagents, gtd decides every beat",
   "author": {
     "name": "Philipp Melab"

package/README.md

@@ -501,8 +501,9 @@ and gtd moves `<b>` only when the workflow calls `ship()`, which squashes the
 process onto `<b>` as one commit (see
 [Shipping](docs/configuration.md#shipping)); what it committed after its last
 ship stays on `gtd/<b>`. `gtd abandon` switches back to `<b>` with the unshipped
-work uncommitted and deletes `gtd/<b>`; `gtd restore` recreates it. The closing
-commit records `Gtd-Branch: <b>`.
+work uncommitted and deletes `gtd/<b>`; `gtd restore` recreates it, also when
+`<b>` still sits on the abandoned ship commit. The closing commit records
+`Gtd-Branch: <b>`.
 
 When a process finishes, the landing that closes it also keeps the whole run
 behind a ref, `refs/gtd/history/<entry>`, so a squash or a deleted branch

package/claude/hooks/drive.ts

@@ -19,6 +19,7 @@ export type Beat = {
   system?: string
   skills?: string[]
   validate?: string
+  fresh?: string | null
   access?: AccessDef
   judge?: unknown
   changes?: { status: string; path: string }[]
@@ -36,6 +37,8 @@ export type Turn = {
   memory: string
   resume: boolean
   prompt: string
+  /** A validator retry: what a replacement subagent starts from — the original prompt plus the correction. */
+  fresh?: string
   label?: string
   model?: string
   system?: string
@@ -163,7 +166,12 @@ async function followUp(io: Io, b: Beat, text: string): Promise<TurnEnd> {
   const turn = turnOf(b)
   const r = await io.resume(turn.memory, text)
   if (r.ok || !r.isLost) return r
-  return io.turn({ ...turn, resume: false, prompt: `${turn.prompt}\n\n${LOST}\n\n${text}` })
+  const { fresh, ...rest } = turn
+  return io.turn({
+    ...rest,
+    resume: false,
+    prompt: `${fresh ?? turn.prompt}\n\n${LOST}\n\n${text}`,
+  })
 }
 
 const LOST =
@@ -177,6 +185,7 @@ function turnOf(b: Beat): Turn {
     memory,
     resume: isTrue(b.session?.resume),
     prompt: b.content ?? "",
+    ...(b.fresh ? { fresh: b.fresh } : {}),
     label: b.label,
     model: b.model || undefined,
     system: b.system || undefined,

package/claude/hooks/git.ts

@@ -29,7 +29,7 @@ export async function defaultBranch(git: (...args: string[]) => Promise<string>)
 // needs --force-with-lease on an existing origin/<branch>. `fresh`: origin
 // lacks the branch, so any tracking ref is stale. Returns why the push failed,
 // or nothing.
-export async function pushBranch(io: GitIo, branch: string, fresh = false) {
+export async function pushBranch(io: GitIo, branch: string, fresh = false, head = "HEAD") {
   const ok = async (...args: string[]) => (await io.run(["git", ...args])).code === 0
   const push = async (args: string[], failure: string) => {
     const r = await attempt(io, ["git", "push", ...args])
@@ -42,7 +42,7 @@ export async function pushBranch(io: GitIo, branch: string, fresh = false) {
     io.log(`Pushing ${branch} to origin…`)
     return push(["--set-upstream", "origin", branch], "git push failed.")
   }
-  if (!(await ok("merge-base", "--is-ancestor", "HEAD", `origin/${branch}`))) {
+  if (!(await ok("merge-base", "--is-ancestor", head, `origin/${branch}`))) {
     io.log(`Pushing ${branch} to origin…`)
     return push(
       ["--force-with-lease", "origin", branch],

package/claude/hooks/pr.ts

@@ -29,9 +29,24 @@ const PLACEHOLDER = "_your answer_"
 
 const fail = (text: string): Done => ({ ok: false, text })
 
+const GTD_BRANCH = "gtd/"
+
+// The pull request belongs to `<b>`; a process runs on `gtd/<b>`.
+const userBranchOf = (branch: string) =>
+  branch.startsWith(GTD_BRANCH) ? branch.slice(GTD_BRANCH.length) : branch
+
 export async function currentPr(io: GitIo): Promise<Pr | string> {
-  const branch = (await io.run(["git", "rev-parse", "--abbrev-ref", "HEAD"])).out.trim()
-  const v = await io.run(["gh", "pr", "view", "--json", "number,url"])
+  const head = (await io.run(["git", "rev-parse", "--abbrev-ref", "HEAD"])).out.trim()
+  const branch = userBranchOf(head)
+  // `gtd/<b>` has no pull request of its own.
+  const v = await io.run([
+    "gh",
+    "pr",
+    "view",
+    ...(branch === head ? [] : [branch]),
+    "--json",
+    "number,url",
+  ])
   if (v.code !== 0) return `gh pr view failed: ${v.err.trim()}`
   try {
     const { url } = JSON.parse(v.out) as { url: string }
@@ -226,17 +241,16 @@ export function missingReasons(review: string) {
 
 // The first commit since `since` whose review answers any of `ids`: the gate
 // that decided them. Undefined while none has landed.
-export async function decided(io: GitIo, since: string, ids: readonly string[]) {
+export async function decided(io: GitIo, since: string, ids: readonly string[], tip = "HEAD") {
   // A reset or rebase since the import leaves nothing to find the gate in.
-  if ((await io.run(["git", "merge-base", "--is-ancestor", since, "HEAD"])).code !== 0)
-    return "gone"
+  if ((await io.run(["git", "merge-base", "--is-ancestor", since, tip])).code !== 0) return "gone"
   const log = await io.run([
     "git",
     "log",
     "--reverse",
     "--first-parent",
     "--format=%H",
-    `${since}..HEAD`,
+    `${since}..${tip}`,
   ])
   if (log.code !== 0) return "gone"
   for (const commit of log.out.split("\n").filter(Boolean)) {
@@ -255,7 +269,7 @@ export type PrRest = { isReviewGate: boolean; isDone: boolean; branch: string }
 // gate drops them.
 export function prAction(pr: PrFeedback | undefined, at: PrRest) {
   if (!pr) return "none"
-  if (at.branch !== pr.branch) return "forget"
+  if (userBranchOf(at.branch) !== pr.branch) return "forget"
   if (pr.importedAt === undefined) return at.isReviewGate ? "import" : at.isDone ? "forget" : "none"
   return at.isReviewGate || at.isDone ? "reply" : "none"
 }
@@ -265,7 +279,7 @@ export function prAction(pr: PrFeedback | undefined, at: PrRest) {
 export function replyText(a: Answer, fix: string | undefined) {
   if (a.choice === "wontfix") return a.text ? `Won't fix: ${a.text}` : "Won't fix."
   if (a.choice === "answer") return a.text
-  return fix ? `Fixed in ${fix}.` : "Fixed as suggested; the fix changed no code."
+  return fix ? `Fixed in ${fix}.` : "Fixed as suggested."
 }
 
 const REPLY = `mutation($thread: ID!, $body: String!) {
@@ -275,32 +289,77 @@ const RESOLVE = `mutation($thread: ID!) {
   resolveReviewThread(input: { threadId: $thread }) { thread { isResolved } }
 }`
 
-// Pushes the branch so the commits a reply names exist on GitHub, then replies
-// to each answered thread and resolves it. The code commits after `gate` are
-// the fixes; a thread that fails is named and left open.
+export type ProcessTip = { branch: string; tip: string; isShipped: boolean }
+
+// Where the process's commits are: HEAD on `gtd/<b>`, `gtd/<b>` once HEAD is
+// back on `<b>`. Without a `gtd/<b>` the process ran on `<b>` itself.
+export async function processTip(io: GitIo): Promise<ProcessTip> {
+  const head = (await io.run(["git", "rev-parse", "--abbrev-ref", "HEAD"])).out.trim()
+  const branch = userBranchOf(head)
+  if (branch !== head) return { branch, tip: "HEAD", isShipped: true }
+  const ref = `refs/heads/${GTD_BRANCH}${branch}`
+  const has = (await io.run(["git", "rev-parse", "--verify", "--quiet", ref])).code === 0
+  return { branch, tip: has ? ref : "HEAD", isShipped: has }
+}
+
+// The oldest ship on `<b>` whose process tip holds `fix`.
+async function shipOf(io: GitIo, branch: string, fix: string) {
+  const ships = await io.run([
+    "git",
+    "log",
+    "--reverse",
+    "--first-parent",
+    "--grep=^Gtd-Tip:",
+    "--format=%H",
+    `refs/heads/${branch}`,
+  ])
+  for (const ship of ships.out.split("\n").filter(Boolean)) {
+    const body = await io.run(["git", "show", "-s", "--format=%B", ship])
+    const tip = /^Gtd-Tip: ([0-9a-f]+)$/m.exec(body.out)?.[1]
+    if (tip && (await io.run(["git", "merge-base", "--is-ancestor", fix, tip])).code === 0)
+      return ship
+  }
+  return undefined
+}
+
+// Replies to each answered thread and resolves it. A process on `gtd/<b>` ships
+// its fixes to `<b>`: a "fixed" reply waits for the ship carrying the fix, then
+// pushes `<b>` and names that commit; a finished process without one replies
+// without a link. A thread that fails is named and left open.
 export async function reply(
   io: GitIo,
   host: string,
   gate: string,
   decidedAnswers: readonly Answer[],
-): Promise<Done & { isPushed: boolean }> {
-  const branch = (await io.run(["git", "rev-parse", "--abbrev-ref", "HEAD"])).out.trim()
-  const pushed = await pushBranch(io, branch)
-  if (pushed) return { ...fail(pushed), isPushed: false }
+  isDone = true,
+): Promise<Done & { isPushed: boolean; waiting: Answer[] }> {
+  const { branch, tip, isShipped } = await processTip(io)
   const log = await io.run([
     "git",
     "log",
     "--reverse",
     "--first-parent",
     "--format=%H",
-    `${gate}..HEAD`,
+    `${gate}..${tip}`,
     "--",
     ".",
     ":(exclude).gtd",
   ])
-  const fix = log.out.split("\n").find(Boolean)
+  const code = log.out.split("\n").find(Boolean)
+  const ship = isShipped && code ? await shipOf(io, branch, code) : undefined
+  const fix = isShipped ? ship : code
+  const waiting = decidedAnswers.filter(
+    (a) => isShipped && !isDone && a.choice === "fix" && code !== undefined && !ship,
+  )
+  const ready = decidedAnswers.filter((a) => !waiting.includes(a))
+  if (ready.length === 0) return { ok: true, text: "", isPushed: false, waiting }
+  // Only a reply naming a commit needs it on GitHub.
+  if (fix !== undefined && ready.some((a) => a.choice === "fix")) {
+    const pushed = await pushBranch(io, branch, false, isShipped ? `refs/heads/${branch}` : "HEAD")
+    if (pushed) return { ...fail(pushed), isPushed: false, waiting }
+  }
   const failed: string[] = []
-  for (const a of decidedAnswers) {
+  for (const a of ready) {
     const sent = await io.run([
       "gh",
       "api",
@@ -331,12 +390,13 @@ export async function reply(
       ).code === 0
     if (!resolved) failed.push(a.title)
   }
-  const done = decidedAnswers.length - failed.length
+  const done = ready.length - failed.length
   const text = `Replied to and resolved ${done} review thread(s).`
   return failed.length === 0
-    ? { ok: true, text, isPushed: true }
+    ? { ok: true, text, isPushed: true, waiting }
     : {
         ...fail(`${text}\nThese failed and stay open:\n${failed.map((t) => `- ${t}`).join("\n")}`),
         isPushed: true,
+        waiting,
       }
 }

package/claude/hooks/register.tsx

@@ -15,6 +15,7 @@ import {
   decided,
   missingReasons,
   reply,
+  processTip,
   REVIEW_FILE,
   unresolvedThreads,
   withThreads,
@@ -217,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,
@@ -573,10 +574,12 @@ async function replyThreads($: $, stop: Stop) {
   const pr = (await read($, run)).pr
   if (!pr?.importedAt) return
   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.")
@@ -592,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($)
 }
 

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

@@ -37,40 +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 = {}) => ctx().step({
-	kind: "ship",
-	name,
-	message,
-	options
-});
+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;
@@ -84,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);
 /**
@@ -359,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) => {
@@ -388,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",
@@ -687,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,
@@ -698,6 +791,7 @@ var flows_exports = /* @__PURE__ */ __exportAll({
 	requireThreadsClosed: () => requireThreadsClosed,
 	restart: () => restart,
 	restoreScript: () => restoreScript,
+	revertErrors: () => revertErrors,
 	revertScript: () => revertScript,
 	run: () => run,
 	scope: () => scope,
@@ -715,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, ship as at, wrote as b, check as c, threads 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, workflow as lt, requireAnswers as m, configProblems as n, sections as nt, isFactoryWorkflow as o, skillsFor as ot, numeric as p, matches as q, defineConfig as r, settings as rt, answered as s, start 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 };