@pmelab/gtd 61.0.0 → 62.1.0

package/dist/gtd.bundle.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire as __createRequire } from 'module';
 const require = __createRequire(import.meta.url);
-import { createRequire, isBuiltin } from "node:module";
+import { createRequire, isBuiltin, registerHooks } from "node:module";
 import * as OS from "node:os";
 import { homedir, networkInterfaces, tmpdir } from "node:os";
 import * as NodeChildProcess from "node:child_process";
@@ -14,7 +14,7 @@ import * as NFS from "node:fs";
 import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import * as Path from "node:path";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { gzipSync } from "node:zlib";
+import { gunzipSync, gzipSync } from "node:zlib";
 import * as NodeUrl from "node:url";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { stripVTControlCharacters } from "node:util";
@@ -12054,6 +12054,57 @@ const restorability = (git, headHash, tipHash) => gen(function* () {
 	};
 });
 //#endregion
+//#region src/platform/PinFile.ts
+const livePinFile = (cwd, path) => () => {
+	const file = join(cwd, path);
+	if (existsSync(file)) try {
+		return {
+			path: file,
+			bytes: readFileSync(file)
+		};
+	} catch {
+		return {
+			path: file,
+			bytes: /* @__PURE__ */ new Uint8Array()
+		};
+	}
+	try {
+		return {
+			path: file,
+			bytes: execFileSync("git", ["show", `HEAD:${path}`], {
+				cwd,
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				]
+			})
+		};
+	} catch {
+		return;
+	}
+};
+/**
+* Runs a pin's module as this process's main program. Node refuses an unknown
+* extension, so a load hook serves the unpacked source under the pin's own
+* URL — `import.meta.url` stays a file in the repository.
+*/
+const runPinModule = async (path, source) => {
+	const url = pathToFileURL(path).href;
+	registerHooks({
+		resolve: (specifier, context, nextResolve) => specifier === url ? {
+			url,
+			shortCircuit: true
+		} : nextResolve(specifier, context),
+		load: (requested, context, nextLoad) => requested === url ? {
+			format: "module",
+			source,
+			shortCircuit: true
+		} : nextLoad(requested, context)
+	});
+	await import(url);
+};
+//#endregion
 //#region src/flags/index.ts
 const FLAGS$1 = [];
 const BOOL = {
@@ -29513,13 +29564,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;
@@ -29571,11 +29616,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];
 	},
@@ -29620,7 +29660,6 @@ const parseCommitMessage = (message) => {
 		judge: [],
 		marks: [],
 		vars: {},
-		config: {},
 		cost: [],
 		format: void 0
 	};
@@ -29642,7 +29681,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}`),
@@ -30564,7 +30602,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) => {
@@ -31218,8 +31257,6 @@ const knownModes = (def) => Object.keys(def.modes);
 //#endregion
 //#region src/workflow/pin.ts
 init_dist$1();
-/** 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.
@@ -31245,8 +31282,26 @@ 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 })]);
 });
+/** A pin's header line, read without unpacking it; undefined when the bytes are no pin. */
+const pinHeader = (bytes) => {
+	const end = bytes.indexOf(10);
+	const header = end < 0 ? null : /^gtdpin (\d+) gtd (\S+)$/.exec(Buffer.from(bytes.subarray(0, end)).toString());
+	return header === null ? void 0 : {
+		format: Number(header[1]),
+		version: header[2]
+	};
+};
+/** A pin's header and module source. */
+const readPin = (bytes) => {
+	const header = pinHeader(bytes);
+	if (header === void 0) throw new Error("not a gtd pin");
+	return {
+		...header,
+		source: gunzipSync(bytes.subarray(bytes.indexOf(10) + 1)).toString("utf8")
+	};
+};
 //#endregion
 //#region src/emit/GitScript.ts
 const shellQuote$1 = (value) => `'${value.replace(/'/g, "'\\''")}'`;
@@ -31280,6 +31335,12 @@ const pinScript = (path) => {
 	const slash = path.lastIndexOf("/");
 	return `${slash === -1 ? "" : `mkdir -p ${shellQuote$1(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$1(path);
+	const next = shellQuote$1(`${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$1(path)}`;
 /**
@@ -31508,6 +31569,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$1(from),
+	shellQuote$1(to)
+]);
 /** One already-rendered plain line. */
 const noteOutcome = (text) => printfLine("%s\n", [shellQuote$1(text)]);
 /**
@@ -31876,8 +31943,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* () {
@@ -31915,8 +31981,7 @@ const planStart = (current, actor, start) => gen(function* () {
 					to: firstStep,
 					workflow: name,
 					...base !== void 0 ? { reviewBase: base } : {},
-					vars,
-					config: start.config
+					vars
 				})
 			}
 		}, {
@@ -32025,15 +32090,6 @@ const runOf = (history, location, closingHash = void 0) => {
 	const fault = historyFormatFault(history, location);
 	return fault === void 0 ? succeed$1(buildRun(history, location, closingHash)) : fail$8(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,
@@ -32061,7 +32117,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: {
@@ -32151,18 +32206,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;
@@ -32478,8 +32521,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,
@@ -32493,7 +32535,6 @@ const restAt = (ref, startOverrides = {}) => gen(function* () {
 		run,
 		vars,
 		env,
-		config: configNow,
 		changes,
 		memory: memory.key,
 		memoryResumed: memory.resumed,
@@ -32757,10 +32798,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
@@ -32831,16 +32869,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");
@@ -32897,7 +32939,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$8(withWarning(configRefusal(how.command, hash, differing, how.configReason)));
 	const { setup } = yield* setupFor(config, run, workspace, host);
 	const outcome = yield* promise(() => replayFor(setup));
@@ -33868,8 +33910,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$8(new Error(plan.message));
 	yield* writeScript(json, out, listingCommitted(landingScript(ScriptSurface.render(plan.steps)), rest.changes));
@@ -34026,6 +34067,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$8(/* @__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
@@ -34292,6 +34363,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":
@@ -34421,6 +34493,7 @@ const SCRIPT_KINDS = /* @__PURE__ */ new Set([
 	"start",
 	"abandon",
 	"restore",
+	"repin",
 	"validate",
 	"historyFetch"
 ]);
@@ -34688,6 +34761,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",
@@ -34872,6 +34955,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"]
@@ -34883,7 +34967,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
@@ -35381,6 +35465,109 @@ const runCli = (argv, io) => {
 	}), provide(io.layers(plan.verbose)), sandbox, catch_((cause) => hasInterruptsOnly(cause) ? failCause$1(cause) : report(io, plan.json.kind !== "off")(cause)));
 };
 //#endregion
+//#region src/cli/Launch.ts
+/** What the core a pin carries lacks, or what must read the live state: these never hand over. */
+const LIVE_KINDS = /* @__PURE__ */ new Set([
+	"ui",
+	"lsp",
+	"guide",
+	"bundle",
+	"repin",
+	"historyList",
+	"historyShow",
+	"historyMetrics",
+	"historyJudges",
+	"historyFetch"
+]);
+const LIVE_FLAG = "--live";
+const optionWords = (argv) => {
+	const end = argv.indexOf("--", 2);
+	return argv.slice(2, end < 0 ? void 0 : end);
+};
+const withoutLiveFlag = (argv) => {
+	const end = argv.indexOf("--", 2);
+	return argv.filter((word, i) => word !== LIVE_FLAG || i < 2 || end >= 0 && i > end);
+};
+/**
+* Whether this gtd runs the command or hands it to the process's pin. A pin
+* this gtd cannot run is refused, never guessed at; a usage error the live
+* parser finds is still the pin's to judge, since its engine may read
+* another CLI.
+*/
+const launchFor = (argv, pinFile) => {
+	if (globalThis[PIN_KEY] !== void 0) return {
+		kind: "live",
+		argv
+	};
+	const live = optionWords(argv).includes(LIVE_FLAG);
+	const rest = withoutLiveFlag(argv);
+	if (live) return {
+		kind: "live",
+		argv: rest
+	};
+	const plan = parseArgv(rest);
+	const version = plan.kind === "output" && plan.stdout === `${GTD_VERSION}\n`;
+	if (plan.kind === "output" && !version) return {
+		kind: "live",
+		argv: rest
+	};
+	if (plan.kind === "command" && LIVE_KINDS.has(plan.command.kind)) return {
+		kind: "live",
+		argv: rest
+	};
+	const found = pinFile();
+	if (found === void 0) return {
+		kind: "live",
+		argv: rest
+	};
+	const header = pinHeader(found.bytes);
+	if (version) return {
+		kind: "output",
+		stdout: header === void 0 ? plan.stdout : `${GTD_VERSION} (this process is pinned to gtd ${header.version})\n`
+	};
+	if (header === void 0 || header.format !== 1) {
+		const what = header === void 0 ? "is no pin this gtd can read" : `is pin format ${header.format}, made by gtd ${header.version}`;
+		return {
+			kind: "refuse",
+			message: `gtd: ${found.path} ${what}; gtd ${GTD_VERSION} runs pin format 1 — upgrade gtd (\`gtd --live\` runs this gtd instead, and may misread the process)`
+		};
+	}
+	return {
+		kind: "pin",
+		argv: rest,
+		path: found.path,
+		version: header.version,
+		source: () => readPin(found.bytes).source
+	};
+};
+const isJsonFlag = (word) => word === "--json" || word.startsWith("--json=");
+const refusalText = (argv, message) => (optionWords(argv).some(isJsonFlag) ? `${JSON.stringify({
+	state: "error",
+	prompt: message
+})}\n` : "") + `${message}\n`;
+const runPin = async (launch, launcher) => {
+	const words = optionWords(launch.argv);
+	if (words.includes("--verbose") || words.includes("-v")) launcher.stderr(`launcher: running the pin ${launch.path} (gtd ${launch.version})\n`);
+	try {
+		await launcher.pin(launch);
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		launcher.stderr(`gtd: could not run the pin ${launch.path}: ${reason}\n`);
+		launcher.exit(1);
+	}
+};
+const runLauncher = async (argv, pinFile, launcher) => {
+	const launch = launchFor(argv, pinFile);
+	switch (launch.kind) {
+		case "live": return launcher.live(launch.argv);
+		case "output": return launcher.stdout(launch.stdout);
+		case "refuse":
+			launcher.stderr(refusalText(argv, launch.message));
+			return launcher.exit(1);
+		case "pin": return runPin(launch, launcher);
+	}
+};
+//#endregion
 //#region node_modules/@trpc/server/dist/codes-DagpWZLc.mjs
 /**
 * Ensures there are no duplicate keys when building a procedure.
@@ -51407,25 +51594,40 @@ const liveToolCommands = effect(ToolCommands, gen(function* () {
 //#endregion
 //#region src/main.ts
 init_dist$1();
-let deathSignal;
-process.once("SIGINT", () => {
-	deathSignal = "SIGINT";
-});
-process.once("SIGTERM", () => {
-	deathSignal ??= "SIGTERM";
-});
-process.once("SIGHUP", () => {
-	deathSignal = "SIGHUP";
-	process.kill(process.pid, "SIGTERM");
+const runLive = (argv) => {
+	let deathSignal;
+	process.once("SIGINT", () => {
+		deathSignal = "SIGINT";
+	});
+	process.once("SIGTERM", () => {
+		deathSignal ??= "SIGTERM";
+	});
+	process.once("SIGHUP", () => {
+		deathSignal = "SIGHUP";
+		process.kill(process.pid, "SIGTERM");
+	});
+	runMain(runCli(argv, nodeCliIo(liveToolCommands)), { teardown: (exit, onExit) => {
+		if (deathSignal === void 0) {
+			defaultTeardown(exit, onExit);
+			return;
+		}
+		const signal = deathSignal;
+		process.removeAllListeners(signal);
+		process.kill(process.pid, signal);
+	} });
+};
+await runLauncher(process.argv, livePinFile(process.cwd(), PIN_PATH), {
+	stdout: (chunk) => {
+		process.stdout.write(chunk);
+	},
+	stderr: (chunk) => {
+		process.stderr.write(chunk);
+	},
+	exit: (code) => {
+		process.exitCode = code;
+	},
+	live: runLive,
+	pin: (launch) => runPinModule(launch.path, launch.source())
 });
-runMain(runCli(process.argv, nodeCliIo(liveToolCommands)), { teardown: (exit, onExit) => {
-	if (deathSignal === void 0) {
-		defaultTeardown(exit, onExit);
-		return;
-	}
-	const signal = deathSignal;
-	process.removeAllListeners(signal);
-	process.kill(process.pid, signal);
-} });
 //#endregion
 export {};