@pmelab/gtd 23.0.0 → 23.1.0

package/.claude-plugin/plugin.json

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

@@ -60,9 +60,11 @@ enforces it at the OS level. See
 
 Run `gtd install` at your repository's root. It writes a `gtd.config.ts` that
 runs gtd's shipped workflows — commit it; gtd refuses to run without one — and
-prints a briefing. Pipe that briefing into your coding agent and answer its
-questions. It should build you a script that will autonomously run the process
-for you. Ask your agent if you have any questions.
+prints a briefing. The repository need not be a JavaScript project: gtd resolves
+the config's `@pmelab/gtd/*` imports itself, so a Python, Rust or notes
+repository needs no `package.json` and no install. Pipe that briefing into your
+coding agent and answer its questions. It should build you a script that will
+autonomously run the process for you. Ask your agent if you have any questions.
 
 ## Why
 

package/dist/gtd.bundle.mjs

@@ -49222,6 +49222,13 @@ const parseJson$1 = (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]/;
+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$1(raw) : raw;
+	return typeof path === "string" && path !== "" && !CONTROL_CHARACTER$1.test(path) ? path : void 0;
+};
 const FORMAT_RE = /^[1-9][0-9]*$/;
 const TRAILER_READERS = {
 	"Gtd-Step": (value, into) => {
@@ -49238,6 +49245,11 @@ 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];
 	},
@@ -49261,6 +49273,7 @@ const parseCommitMessage = (message) => {
 		reviewBase: void 0,
 		judge: [],
 		vars: {},
+		config: {},
 		cost: [],
 		format: void 0
 	};
@@ -49272,13 +49285,15 @@ const parseCommitMessage = (message) => {
 		format: trailers.format ?? 1
 	};
 };
+const sortedEntries = (record = {}) => Object.entries(record).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
 /** Trailer order is fixed so the same spec always yields the same bytes. */
 const formatCommitMessage = (spec) => {
 	const lines = [];
 	if (spec.step !== void 0) lines.push(`Gtd-Step: ${formatStepId(spec.step)}`);
 	if (spec.workflow !== void 0) lines.push(`Gtd-Workflow: ${spec.workflow}`);
 	if (spec.reviewBase !== void 0) lines.push(`Gtd-Review-Base: ${spec.reviewBase}`);
-	for (const [name, value] of Object.entries(spec.vars ?? {}).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) lines.push(`Gtd-Var: ${name}=${value}`);
+	for (const [name, value] of sortedEntries(spec.vars)) lines.push(`Gtd-Var: ${name}=${value}`);
+	for (const [path, hash] of sortedEntries(spec.config)) lines.push(`Gtd-Config: ${hash} ${encodePath(path)}`);
 	if (spec.cost !== void 0) lines.push(`Gtd-Cost: ${spec.cost.cost}${spec.cost.model !== void 0 ? ` ${spec.cost.model}` : ""}`);
 	for (const verdict of spec.judge ?? []) lines.push(`Gtd-Judge: ${JSON.stringify(verdict)}`);
 	lines.push(`Gtd-Format: 1`);
@@ -50438,6 +50453,35 @@ const resolveScopeAccess = (def, skills, vars) => gen(function* () {
 //#region src/workflow/Workflow.ts
 const knownModes = (def) => Object.keys(def.modes);
 //#endregion
+//#region src/workflow/fingerprint.ts
+const HASH_LENGTH = 16;
+const CONTROL_CHARACTER = /[\x00-\x1f\x7f-\x9f]/;
+const contentHash = (content) => createHash("sha256").update(content).digest("hex").slice(0, HASH_LENGTH);
+const realOr = (path) => {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+};
+const configFingerprint = (files, root) => {
+	const fingerprint = {};
+	const realRoot = realOr(root);
+	for (const file of files) {
+		const path = relative(realRoot, realOr(file)).split(sep).join("/");
+		if (CONTROL_CHARACTER.test(path)) continue;
+		let content;
+		try {
+			content = readFileSync(file);
+		} catch {
+			continue;
+		}
+		fingerprint[path] = contentHash(content);
+	}
+	return fingerprint;
+};
+const changedConfigFiles = (recorded, current) => [.../* @__PURE__ */ new Set([...Object.keys(recorded), ...Object.keys(current)])].filter((path) => recorded[path] !== current[path]).sort();
+//#endregion
 //#region src/judges/providers/fixed.ts
 const fail$3 = (message) => {
 	throw new Error(`gtd judge run: ${message}`);
@@ -56082,7 +56126,8 @@ const checkOverrides = (commandLabel, varOverrides, declaredNames, envNames) =>
 * `gtd --workflow <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.
+* a `Gtd-Review-Base:` trailer when the workflow fixes the process's diff base,
+* and a `Gtd-Config:` trailer per config file.
 * All validation is a REFUSAL, not an Effect failure.
 */
 const planStart = (current, actor, start) => gen(function* () {
@@ -56117,7 +56162,8 @@ const planStart = (current, actor, start) => gen(function* () {
 					to: firstStep,
 					workflow: name,
 					...base !== void 0 ? { reviewBase: base } : {},
-					vars
+					vars,
+					config: start.config
 				})
 			}
 		}, {
@@ -56218,6 +56264,15 @@ const runOf = (history, location, closingHash = void 0) => {
 	const fault = historyFormatFault(history, location);
 	return fault === void 0 ? succeed$3(buildRun(history, location, closingHash)) : fail$7(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 buildRun = (history, location, closingHash) => {
 	const processCommits = history.slice(location.processStart);
 	const parsed = processCommits.map((c) => parseCommitMessage(c.message));
@@ -56234,6 +56289,7 @@ const buildRun = (history, location, closingHash) => {
 		costEntries: parsed.flatMap(costEntriesOf),
 		judgeVerdicts: parsed.flatMap((m) => m.judge),
 		pinnedVars: { ...first?.vars },
+		pinnedConfig: pinnedConfigOf(history.slice(Math.max(location.baseIndex, 0))),
 		headTurn: headTurnOf(head),
 		closingHash,
 		episode: {
@@ -56322,6 +56378,18 @@ const findBoundaryBase = (git, def, head) => gen(function* () {
 });
 const historyUpTo = (git, def, head) => flatMap$4(findBoundaryBase(git, def, head), ({ base, head: resolvedHead }) => git.commitHistory(base, resolvedHead));
 const computeProcessRun = (git, def, head) => flatMap$4(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;
@@ -56621,6 +56689,8 @@ const restAt = (ref, startOverrides = {}) => gen(function* () {
 		path: e.path
 	})) : [];
 	const memory = memoryOf(outcome.trace, run);
+	const configNow = configFingerprint(config.workflowFiles, host.root);
+	if (ref === void 0) yield* warnConfigChanges(run, configNow, workspace);
 	return {
 		def,
 		workflowName: resolved.name,
@@ -56632,6 +56702,7 @@ const restAt = (ref, startOverrides = {}) => gen(function* () {
 		run,
 		vars,
 		env,
+		config: configNow,
 		changes,
 		memory: memory.key,
 		memoryResumed: memory.resumed,
@@ -56763,7 +56834,10 @@ const landingTo = (rest, to) => {
 			from: rest.state,
 			to,
 			step: rest.step.id,
-			...starts ? { vars: rest.vars } : {}
+			...starts ? {
+				vars: rest.vars,
+				config: rest.config
+			} : {}
 		}
 	};
 };
@@ -69222,8 +69296,8 @@ const normalizeScriptNewline = (script) => script.length === 0 ? script : `${scr
 const landingScript = (required) => combinedScript(required, "");
 const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 /** Decides `gtd land`'s one transition without performing it. Refusals fail the Effect; a no-op returns `subject: null` and empty scripts. */
-const planLanding = (opts = {}) => gen(function* () {
-	const rest = yield* currentRest;
+const planLanding = (opts = {}, current) => gen(function* () {
+	const rest = current ?? (yield* currentRest);
 	const outcome = planStep(yield* snapshotFromRest(rest, opts.judge), opts);
 	if (outcome.kind === "refusal") return yield* fail$7(new Error(outcome.message));
 	if (outcome.kind === "noop") {
@@ -69358,7 +69432,7 @@ const runJudgeAnswerCommand = (json, out) => gen(function* () {
 		catch: () => new SelectorUsageError("gtd judge answer: stdin is not valid JSON")
 	});
 	const verdict = yield* decodeUnknown(verdictSchemaFor(ids))(parsed).pipe(mapError$1((e) => new SelectorUsageError(`gtd judge answer: the verdict on stdin does not match the pending questions — ${e.message}`)));
-	const built = landFields(yield* planLanding({ judge: verdict }));
+	const built = landFields(yield* planLanding({ judge: verdict }, rest));
 	if (json.kind === "document") out.write(renderLandJson(built));
 	else if (json.kind === "select") yield* writeSelection(out, built, json.path);
 	else out.write(renderLandPlain(built, "judge answer"));
@@ -69398,7 +69472,8 @@ const runStartCommand = (actor, workflow, varOverrides, out, commandLabel) => ge
 		workflow: resolved,
 		first: started,
 		commandLabel,
-		vars: varOverrides
+		vars: varOverrides,
+		config: rest.config
 	});
 	if (plan.kind === "refusal") return yield* fail$7(new Error(plan.message));
 	out.write(landingScript(ScriptSurface.render(plan.steps)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "23.0.0",
+  "version": "23.1.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {

package/skills/authoring/SKILL.md

@@ -186,9 +186,13 @@ certainly a bug.
 ## Rules for flow code
 
 Flow code is replayed on every command, so it must reach the same steps every
-time it sees the same history. `run()` bodies and module top-level code are
-exempt. gtd does not read the source ahead of time: breaking a rule shows up
-when replay runs, as an error or, for nondeterminism, as a divergence later.
+time it sees the same history. Only `run()` bodies are exempt: module top-level
+code and every local import are evaluated on every command too, so they read no
+`process.env`, clock, network or files either (a per-machine value is an
+`envDefaults` setting). A process records the config's hashes when it starts and
+warns whenever it differs. gtd does not read the source ahead of time: breaking
+a rule shows up when replay runs, as an error or, for nondeterminism, as a
+divergence later.
 
 - No IO or nondeterminism in flow code — no clock, randomness, environment,
   network or filesystem. Read the tree through the helpers; do IO inside a