@pmelab/gtd 20.0.0 → 20.1.0

package/.claude-plugin/plugin.json

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

@@ -19,6 +19,10 @@ to any machine that checks it out.
 npm install -g @pmelab/gtd
 ```
 
+That installs `latest`, which moves once a day to the newest release. Every
+merge to `main` publishes to `next` first: `npm install -g @pmelab/gtd@next`
+gets each one as it lands.
+
 Or run without installing (prefix every `gtd` below with `npx`) — see
 [Configuration](https://github.com/pmelab/gtd/blob/main/docs/configuration.md)
 for the settings most projects tune. A process setting's value is committed to
@@ -63,7 +67,10 @@ for you. Ask your agent if you have any questions.
   back next week: run the driver and it resumes exactly where it stopped.
 - **Shareable.** Push the branch, and the workflow travels with it — the state
   lives in the commits, so another machine (or another person) picks up exactly
-  where you left off.
+  where you left off. Each commit records the history format it was written in
+  (`Gtd-Format:`), so a gtd that cannot read a history says so instead of
+  misreading it — see
+  [History format](https://github.com/pmelab/gtd/blob/main/docs/configuration.md#history-format).
 - **Files, not chat.** Conversation lives in files like `REQUIREMENTS.md` or
   `ARCHITECTURE.md`. Request changes by editing them, approve by leaving the
   tree clean — all in your own editor. There is no chat UI that could flicker.

package/claude/hooks/access.ts

@@ -1,5 +1,3 @@
-import { isAbsolute, relative, resolve } from "node:path"
-
 import { globMatches } from "../../src/replay/Glob.js"
 
 export type AccessDef = { read: string[] | null; write: string[] | null }
@@ -12,10 +10,19 @@ const WRITE: Record<string, string> = {
   NotebookEdit: "notebook_path",
 }
 
+// Hand-rolled because a hooks module may not import `node:path`.
+const segments = (p: string): string[] =>
+  p.split("/").reduce<string[]>((out, s) => {
+    if (s === "..") out.pop()
+    else if (s && s !== ".") out.push(s)
+    return out
+  }, [])
+
 // Repo-relative form of a path; undefined when it lies outside the repo.
 const inRepo = (p: string, root: string): string | undefined => {
-  const rel = relative(root, isAbsolute(p) ? p : resolve(root, p))
-  return rel === ".." || rel.startsWith("../") || isAbsolute(rel) ? undefined : rel
+  const base = segments(root)
+  const target = segments(p.startsWith("/") ? p : `${root}/${p}`)
+  return base.every((s, i) => target[i] === s) ? target.slice(base.length).join("/") : undefined
 }
 
 const deny = (verb: string, path: string, globs: string[]) =>

package/dist/gtd.bundle.mjs

@@ -47564,6 +47564,12 @@ const diffTrees = (before, after) => {
 	};
 };
 const isEmptyDiff = (diff) => diff.added.length === 0 && diff.modified.length === 0 && diff.deleted.length === 0;
+const short$1 = (hash) => hash.slice(0, 7);
+const formatFault = (commits) => {
+	const foreign = commits.find((c) => c.format !== 1);
+	if (foreign === void 0) return void 0;
+	return `gtd: commit ${short$1(foreign.hash)} is written in history format ${foreign.format}, but this gtd reads format 1 — run a gtd release that reads format ${foreign.format} to continue this process`;
+};
 //#endregion
 //#region src/replay/Trailers.ts
 const TRANSITION_SEP = " → ";
@@ -47618,6 +47624,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 FORMAT_RE = /^[1-9][0-9]*$/;
 const TRAILER_READERS = {
 	"Gtd-Step": (value, into) => {
 		into.step ??= parseStepId(value);
@@ -47636,6 +47643,9 @@ const TRAILER_READERS = {
 	"Gtd-Review-Base": (value, into) => {
 		into.reviewBase ??= value.split(/\s/)[0];
 	},
+	"Gtd-Format": (value, into) => {
+		if (FORMAT_RE.test(value)) into.format ??= Number(value);
+	},
 	"Gtd-Cost": (value, into) => {
 		const c = COST_RE.exec(value);
 		if (c !== null) into.cost.push({
@@ -47653,13 +47663,15 @@ const parseCommitMessage = (message) => {
 		reviewBase: void 0,
 		judge: [],
 		vars: {},
-		cost: []
+		cost: [],
+		format: void 0
 	};
 	if (newline !== -1) for (const match of message.slice(newline).matchAll(TRAILER_RE)) TRAILER_READERS[match[1]]?.(match[2], trailers);
 	return {
 		subject,
 		parsed: parseSubject(subject),
-		...trailers
+		...trailers,
+		format: trailers.format ?? 1
 	};
 };
 /** Trailer order is fixed so the same spec always yields the same bytes. */
@@ -47671,8 +47683,8 @@ const formatCommitMessage = (spec) => {
 	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}`);
 	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)}`);
-	const subject = formatSubject(spec.actor, spec.to, spec.from);
-	return lines.length === 0 ? subject : `${subject}\n\n${lines.join("\n")}`;
+	lines.push(`Gtd-Format: 1`);
+	return `${formatSubject(spec.actor, spec.to, spec.from)}\n\n${lines.join("\n")}`;
 };
 //#endregion
 //#region src/replay/Replay.ts
@@ -64437,7 +64449,16 @@ const costEntriesOf = (message) => message.cost.map((c) => ({
 	model: c.model ?? "unspecified"
 }));
 const hashAt = (history, index) => history[index]?.hash;
+const historyFormatFault = (history, location) => formatFault(history.slice(location.baseIndex + 1).concat(history[location.baseIndex]?.message.startsWith("gtd") ? [history[location.baseIndex]] : []).map((c) => ({
+	hash: c.hash,
+	format: parseCommitMessage(c.message).format
+})));
+/** Fails on a history in a format this gtd does not read, before anything acts on it. */
 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 buildRun = (history, location, closingHash) => {
 	const processCommits = history.slice(location.processStart);
 	const parsed = processCommits.map((c) => parseCommitMessage(c.message));
 	const first = parsed[0];
@@ -64540,8 +64561,8 @@ 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) => map$4(historyUpTo(git, def, head), (history) => runOf(history, locateEpisode(def, history)));
-/** The run alone, never replaying — `gtd abandon` must work even when replay would refuse. */
+const computeProcessRun = (git, def, head) => flatMap$4(historyUpTo(git, def, head), (history) => runOf(history, locateEpisode(def, history)));
+/** 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;
 	const config = yield* (yield* ConfigService).load;
@@ -64554,18 +64575,18 @@ const summaryRun = gen(function* () {
 	const headEntry = (yield* git.subjectHistory(1, 0))[0];
 	if (headEntry === void 0) {
 		const history = yield* historyUpTo(git, def, void 0);
-		return runOf(history, locateEpisode(def, history));
+		return yield* runOf(history, locateEpisode(def, history));
 	}
 	if (!(parseCommitMessage(headEntry.subject).parsed?.to === def.initial)) {
 		const history = yield* historyUpTo(git, def, headEntry.hash);
-		return runOf(history, locateEpisode(def, history));
+		return yield* runOf(history, locateEpisode(def, history));
 	}
 	const parentRef = `${headEntry.hash}~1`;
 	const before = yield* historyUpTo(git, def, parentRef);
 	const location = locateEpisode(def, before);
 	let closing = yield* git.commitHistory(parentRef, headEntry.hash);
 	if (closing.length === 0) closing = yield* git.commitHistory(void 0, headEntry.hash);
-	return runOf([...before, ...closing], { ...location }, headEntry.hash);
+	return yield* runOf([...before, ...closing], { ...location }, headEntry.hash);
 });
 const commitTree = (workspace, hash) => {
 	let entries;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "20.0.0",
+  "version": "20.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": {
@@ -55,7 +55,7 @@
     "typecheck": "tsc --noEmit && tsc --noEmit -p src/web/tsconfig.json",
     "lint": "oxlint .",
     "lint:sh": "jiti scripts/generate-shell-corpus.ts --check && shellcheck -s sh tests/shell/corpus/*.sh",
-    "lint:boundaries": "depcruise src tests",
+    "lint:boundaries": "node scripts/lint-boundaries.mjs",
     "format": "oxfmt --write .",
     "format:check": "oxfmt --check .",
     "test:mutation": "stryker run",