@pmelab/gtd 61.0.0 → 62.1.0

package/.claude-plugin/plugin.json

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

@@ -624,10 +624,10 @@ install for any of these but the testkit's: gtd resolves a `gtd.config.ts`'s
 `@pmelab/gtd/*` imports to its own copy.
 
 The `gtd` bin's commands — `next`, `land`, `start`, `abandon`, `restore`,
-`validate`, `check`, `uncheck`, `guide`, `bundle`, `summary`, `base`, `version`,
-`help`, `history list`, `history show`, `history metrics`, `history judges`,
-`history fetch`, `strays`, the tools `ui`, `lsp`, `judge` (`judge answer`,
-`judge run`) — are listed in the
+`repin`, `validate`, `check`, `uncheck`, `guide`, `bundle`, `summary`, `base`,
+`version`, `help`, `history list`, `history show`, `history metrics`,
+`history judges`, `history fetch`, `strays`, the tools `ui`, `lsp`, `judge`
+(`judge answer`, `judge run`) — are listed in the
 [CLI reference](https://github.com/pmelab/gtd/blob/main/docs/cli.md). Every
 command that prints a script takes `--json=script`, and `--` ends the options.
 
@@ -643,6 +643,17 @@ Both are ordinary `script` beats a driver runs unattended; see
 [Pin and unpin beats](https://github.com/pmelab/gtd/blob/main/docs/driver.md#pin-and-unpin-beats).
 Histories with pin commits are history format 2, which an older gtd refuses.
 
+While a process is pinned, the `gtd` on your `PATH` hands every command over to
+the pin, so editing the workflow or upgrading gtd mid-process changes nothing;
+gtd notes on stderr when the live config differs from the pinned one. `ui`,
+`lsp`, `guide`, `bundle`, `repin`, `help`, `version` and the `history` commands
+always run live, and `gtd --live <command>` runs the live engine for any other,
+at the risk of misreading the process. To fix a workflow mid-process, edit it
+and run `gtd repin`: its script commits a fresh pin from the live engine and
+config, and the process continues on it. A pin in a format your gtd does not
+know is refused: upgrade gtd. See
+[Pinned processes](https://github.com/pmelab/gtd/blob/main/docs/cli.md#pinned-processes).
+
 ## License
 
 MIT

package/dist/chunks/{testkit-C9sq0x07.mjs → testkit-CPzWnl3P.mjs}

@@ -22873,13 +22873,7 @@ const parseJson = (raw) => {
 const TRAILER_RE = /^(Gtd-[A-Za-z-]+):[ \t]*(.*?)[ \t]*$/gm;
 const COST_RE = /^([0-9]+(?:\.[0-9]+)?)(?:[ \t]+(.+))?$/;
 const VAR_RE = /^([^=\s]+)=(.*)$/;
-const CONFIG_RE = /^([0-9a-f]{16}) (.+)$/;
 const CONTROL_CHARACTER$1 = /[\x00-\x1f\x7f-\x9f\u2028\u2029]/;
-const encodePath = (path) => path.trim() !== path || path.startsWith("\"") || CONTROL_CHARACTER$1.test(path) ? JSON.stringify(path) : path;
-const decodePath = (raw) => {
-	const path = raw.startsWith("\"") ? parseJson(raw) : raw;
-	return typeof path === "string" && path !== "" && !CONTROL_CHARACTER$1.test(path) ? path : void 0;
-};
 const decodeApproval = (raw) => {
 	const parsed = parseJson(raw);
 	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
@@ -22931,11 +22925,6 @@ const TRAILER_READERS = {
 		const kv = VAR_RE.exec(value);
 		if (kv !== null) into.vars[kv[1]] = kv[2];
 	},
-	"Gtd-Config": (value, into) => {
-		const entry = CONFIG_RE.exec(value);
-		const path = entry === null ? void 0 : decodePath(entry[2]);
-		if (path !== void 0) into.config[path] = entry[1];
-	},
 	"Gtd-Review-Base": (value, into) => {
 		into.reviewBase ??= value.split(/\s/)[0];
 	},
@@ -22980,7 +22969,6 @@ const parseCommitMessage = (message) => {
 		judge: [],
 		marks: [],
 		vars: {},
-		config: {},
 		cost: [],
 		format: void 0
 	};
@@ -23002,7 +22990,6 @@ const formatCommitMessage = (spec) => {
 		...trailer("Workflow", spec.workflow),
 		...trailer("Review-Base", spec.reviewBase),
 		...sortedEntries(spec.vars).map(([name, value]) => `Gtd-Var: ${name}=${value}`),
-		...sortedEntries(spec.config).map(([path, hash]) => `Gtd-Config: ${hash} ${encodePath(path)}`),
 		...trailer("Cost", costValue(spec.cost)),
 		...(spec.judge ?? []).map((verdict) => `Gtd-Judge: ${JSON.stringify(verdict)}`),
 		...(spec.marks ?? []).map((m) => `Gtd-Mark: ${m.name}=${m.value}`),
@@ -23912,7 +23899,8 @@ const load = gen(function* () {
 		},
 		...compiled.ui !== void 0 ? { ui: compiled.ui } : {},
 		warnings: diagnostics.filter((d) => d.severity === "warning"),
-		fingerprint: pinned?.fingerprint ?? configFingerprint(loaded.file.dependencyFiles, host.root, module.read ?? readFromDisk)
+		fingerprint: pinned?.fingerprint ?? configFingerprint(loaded.file.dependencyFiles, host.root, module.read ?? readFromDisk),
+		drift: pinned === void 0 ? [] : changedConfigFiles(pinned.fingerprint, configFingerprint(Object.keys(pinned.fingerprint).map((file) => resolve(host.root, file)), host.root, readFromDisk))
 	};
 });
 const readFromDisk = (path) => {
@@ -24562,10 +24550,6 @@ const resolveScopeAccess = (def, skills, vars) => gen(function* () {
 //#endregion
 //#region src/workflow/Workflow.ts
 const knownModes = (def) => Object.keys(def.modes);
-//#endregion
-//#region src/workflow/pin.ts
-/** Bumped when a launcher could no longer run an older pin the same way. */
-const PIN_FORMAT = 1;
 /**
 * The engine a pin carries, as ES module source. Live, the `gtd.core.mjs` the
 * running gtd ships beside its own bundle.
@@ -24591,7 +24575,7 @@ const pin = (module, root, version) => gen(function* () {
 		try: () => pinnedWorkflowSource(module, root, version),
 		catch: (e) => new GtdError(`gtd bundle: ${module.filepath}: ${e instanceof Error ? e.message : String(e)}`)
 	})) + core.replace(/^#!.*\n/, "");
-	return Buffer.concat([Buffer.from(`gtdpin ${PIN_FORMAT} gtd ${version}\n`), gzipSync(source, { level: 9 })]);
+	return Buffer.concat([Buffer.from(`gtdpin 1 gtd ${version}\n`), gzipSync(source, { level: 9 })]);
 });
 //#endregion
 //#region src/emit/GitScript.ts
@@ -24626,6 +24610,12 @@ const pinScript = (path) => {
 	const slash = path.lastIndexOf("/");
 	return `${slash === -1 ? "" : `mkdir -p ${shellQuote(path.slice(0, slash))}\n`}gtd bundle >${p} || { rm -f -- ${p}; exit 1; }`;
 };
+/** `gtd repin`'s pin write: a failed `gtd bundle` leaves the committed pin in place. */
+const repinScript = (path) => {
+	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. */
 const unpinScript = (path) => `rm -f -- ${shellQuote(path)}`;
 /**
@@ -24866,6 +24856,12 @@ const FMT_ABANDONED = "abandoned the process resting at \"%s\" — HEAD is back
 const FMT_RESTORED = "restored the retained history — HEAD is back at %s (\"%s\"), resting at \"%s\". Resume with the loop, or `git reset` to any earlier turn to restart from there.\n";
 /** `no gtd process is underway (resting at "<initial>") — nothing to abandon` — `gtd abandon`'s no-op plain-text line. */
 const abandonNoopText = (initial) => renderFormat(FMT_ABANDON_NOOP, initial);
+/** A landed self-loop/target-change transition. */
+const transitionOutcome = (from, to) => printfLine("%s %s → %s\n", [
+	"'->'",
+	shellQuote(from),
+	shellQuote(to)
+]);
 /** One already-rendered plain line. */
 const noteOutcome = (text) => printfLine("%s\n", [shellQuote(text)]);
 /**
@@ -25231,8 +25227,7 @@ const checkOverrides = (commandLabel, varOverrides, declaredNames, envNames) =>
 * `gtd start <name>`: start a brand NEW process on a workflow, writing an
 * opening commit that names the workflow's first step and carries a
 * `Gtd-Workflow:` trailer, every process setting as a `Gtd-Var:` trailer, plus
-* a `Gtd-Review-Base:` trailer when the workflow fixes the process's diff base,
-* and a `Gtd-Config:` trailer per config file.
+* and a `Gtd-Review-Base:` trailer when the workflow fixes the process's diff base.
 * All validation is a REFUSAL, not an Effect failure.
 */
 const planStart = (current, actor, start) => gen(function* () {
@@ -25270,8 +25265,7 @@ const planStart = (current, actor, start) => gen(function* () {
 					to: firstStep,
 					workflow: name,
 					...base !== void 0 ? { reviewBase: base } : {},
-					vars,
-					config: start.config
+					vars
 				})
 			}
 		}, {
@@ -25378,15 +25372,6 @@ const runOf = (history, location, closingHash = void 0) => {
 	const fault = historyFormatFault(history, location);
 	return fault === void 0 ? succeed$1(buildRun(history, location, closingHash)) : fail$4(new Error(fault));
 };
-const pinnedConfigOf = (history) => {
-	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
-		};
-	}
-};
 const approvalEntryOf = (hash, message) => message.approved === void 0 ? [] : [{
 	step: formatStepId(message.approved.step),
 	name: message.approved.name,
@@ -25414,7 +25399,6 @@ const buildRun = (history, location, closingHash) => {
 		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: {
@@ -25504,18 +25488,6 @@ const findBoundaryBase = (git, def, head) => gen(function* () {
 });
 const historyUpTo = (git, def, head) => flatMap(findBoundaryBase(git, def, head), ({ base, head: resolvedHead }) => git.commitHistory(base, resolvedHead));
 const computeProcessRun = (git, def, head) => flatMap(historyUpTo(git, def, head), (history) => runOf(history, locateEpisode(def, history)));
-const changedSinceStart = (pinned, current, workspace) => {
-	if (pinned === void 0) return [];
-	return changedConfigFiles(pinned.files, current).filter((path) => {
-		const committed = workspace.readCommittedSync(path, pinned.commit);
-		return current[path] === void 0 || committed === void 0 || contentHash(committed) !== current[path];
-	});
-};
-const warnConfigChanges = (run, current, workspace) => 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`);
-});
 /** The run alone, never replaying — `gtd abandon` must work even when replay would refuse, short of a history it cannot read. */
 const currentRun = gen(function* () {
 	const git = yield* GitService;
@@ -25831,8 +25803,7 @@ const restAt = (ref, startOverrides = {}) => gen(function* () {
 		status: normalizeStatus(e.status),
 		path: e.path
 	})) : [];
-	const configNow = config.fingerprint;
-	if (ref === void 0) yield* warnConfigChanges(run, configNow, workspace);
+	if (ref === void 0 && 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,
@@ -25846,7 +25817,6 @@ const restAt = (ref, startOverrides = {}) => gen(function* () {
 		run,
 		vars,
 		env,
-		config: configNow,
 		changes,
 		memory: memory.key,
 		memoryResumed: memory.resumed,
@@ -26110,10 +26080,7 @@ const pinRefusal = (pin) => ({
 	kind: "refusal",
 	message: pin === "add" ? `gtd land: ${PIN_PATH} is missing — run the pin beat's script (\`gtd next --json=content\`); if its \`gtd bundle\` fails, fix what it reports, or run \`gtd abandon\`` : `gtd land: ${PIN_PATH} is still there — run the unpin beat's script (\`gtd next --json=content\`), then land`
 });
-const startTrailers = (rest, starts) => starts ? {
-	vars: rest.vars,
-	config: rest.config
-} : {};
+const startTrailers = (rest, starts) => starts ? { vars: rest.vars } : {};
 const outcomeMarks = (outcome) => outcome.kind === "rest" || outcome.kind === "ended" ? outcome.marks : [];
 /**
 * What landing the pending turn at `rest` does — a pure decision from a
@@ -26184,16 +26151,20 @@ const summaryFor = (run) => gen(function* () {
 	if (summary === void 0 || run.trace.length === 0) return { prompt: void 0 };
 	return { prompt: summary(summaryInput(run, settingsFor(resolved, run.pinnedVars, host.env, {}, {}))) };
 });
-/** 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, files, recorded) => {
-	const paths = new Set(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, files) => {
+	const paths = /* @__PURE__ */ new Set();
 	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();
 };
 const configRefusal = (command, tip, paths, reason = "A history ref replays under today's config, so it is unreadable after the config changes") => /* @__PURE__ */ new Error(`${command}: refused — config differs at ${tip.slice(0, 7)}: ${paths.join(", ")}. ${reason}`);
-const differingConfigPaths = (git, workspace, root, config, run, hash) => gen(function* () {
+const differingConfigPaths = (git, workspace, root, config, hash) => gen(function* () {
 	const differing = [];
-	for (const path of inRepoConfigPaths(root, Object.keys(config.fingerprint), run.pinnedConfig?.files ?? {})) if ((yield* orElseSucceed(git.readFileAtRef(hash, path), () => void 0)) !== workspace.readSync(path)) differing.push(path);
+	for (const path of inRepoConfigPaths(root, Object.keys(config.fingerprint))) if ((yield* orElseSucceed(git.readFileAtRef(hash, path), () => void 0)) !== workspace.readSync(path)) differing.push(path);
 	return differing;
 });
 const notClosedError = (hash, outcome) => outcome.kind === "rest" ? /* @__PURE__ */ new Error(`gtd history: ${hash.slice(0, 7)} does not close a process under today's config`) : replayError(outcome) ?? /* @__PURE__ */ new Error("gtd history: replay failed");
@@ -26250,7 +26221,7 @@ const replayFinishedProcess = (config, run, hash, how) => gen(function* () {
 	const recorded = parseCommitMessage(run.episode.commits.find((c) => c.hash === hash)?.message ?? "").version;
 	const versionWarning = versionWarningFor(recorded);
 	const withWarning = (err) => versionWarning === void 0 ? err : /* @__PURE__ */ 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* fail$4(withWarning(configRefusal(how.command, hash, differing, how.configReason)));
 	const { setup } = yield* setupFor(config, run, workspace, host);
 	const outcome = yield* promise(() => replayFor(setup));
@@ -27212,8 +27183,7 @@ const startWorkflow = (workflow, varOverrides, json, out, commandLabel) => gen(f
 		workflow: resolved,
 		first: started,
 		commandLabel,
-		vars: varOverrides,
-		config: rest.config
+		vars: varOverrides
 	});
 	if (plan.kind === "refusal") return yield* fail$4(new Error(plan.message));
 	yield* writeScript(json, out, listingCommitted(landingScript(ScriptSurface.render(plan.steps)), rest.changes));
@@ -27370,6 +27340,36 @@ const runRestoreCommand = (json, out) => gen(function* () {
 	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, out) => 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" : void 0;
+	if (refusal !== void 0) return yield* fail$4(/* @__PURE__ */ new Error(`gtd repin: ${refusal}`));
+	const message = formatCommitMessage({
+		actor: "check",
+		from: PIN_STATES.add,
+		to: rest.step.name,
+		pin: "add"
+	});
+	yield* writeScript(json, out, combinedScript(emitScripts([
+		{
+			kind: "gitWrite",
+			command: repinScript(PIN_PATH)
+		},
+		{
+			kind: "gitWrite",
+			command: commitPath(PIN_PATH, message)
+		},
+		{
+			kind: "outcome",
+			command: transitionOutcome(PIN_STATES.add, rest.step.name)
+		}
+	]).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
 * `gtd check <mode>` invocation instead, so there's always something concrete
@@ -27636,6 +27636,7 @@ const dispatchVoidCommand = (command, json, out) => {
 		case "start": return runStartCommand(command, json, out);
 		case "abandon": return runAbandonCommand(json, out);
 		case "restore": return runRestoreCommand(json, out);
+		case "repin": return runRepinCommand(json, out);
 		case "next": return runNextCommand(json, out);
 		case "validate": return runValidateCommand(json, out);
 		case "check":
@@ -27764,6 +27765,7 @@ const SCRIPT_KINDS = /* @__PURE__ */ new Set([
 	"start",
 	"abandon",
 	"restore",
+	"repin",
 	"validate",
 	"historyFetch"
 ]);
@@ -28031,6 +28033,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",
@@ -28215,6 +28227,7 @@ const flagHeader = (row) => {
 };
 const GLOBAL_OPTIONS = [
 	["-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"]
@@ -28226,7 +28239,7 @@ const EXTRA_TOPICS = [[
 ], [
 	"version",
 	"Print the version",
-	"Print gtd's version."
+	"Print gtd's version, and the version of a pinned process's gtd."
 ]];
 const EXAMPLES = `  $ gtd start                                   list what can start
   $ gtd start <name>                            start a process
@@ -29933,9 +29946,9 @@ const recognizeGitBuilders = (repo, block) => {
 };
 /** What the in-memory `gtd bundle` prints: a pin header, and no engine behind it. */
 const IN_MEMORY_PIN = "gtdpin 1 gtd in-memory\n";
-/** A pin or unpin beat's script. */
+/** A pin or unpin beat's script, or `gtd repin`'s. */
 const recognizePinScripts = (repo, block) => {
-	if (block === pinScript(".gtd/process.gtdpin")) {
+	if (block === pinScript(".gtd/process.gtdpin") || block === repinScript(".gtd/process.gtdpin")) {
 		repo.writeFile(PIN_PATH, IN_MEMORY_PIN);
 		return { kind: "applied" };
 	}