@pmelab/gtd 27.7.1 → 27.9.0

package/.claude-plugin/plugin.json

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

@@ -649,7 +649,7 @@ gtd is one package, `@pmelab/gtd`, and every entrypoint shares its version and
 
 | Import                                                                                                                                                         | What it is                                                                                                                                                                                             |
 | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `@pmelab/gtd/flows`                                                                                                                                            | The flow API a workflow is written in: the steps (`agent`, `human`, `run`, …), workflow factories, `defineConfig` and `FLOWS_PROTOCOL`.                                                                |
+| `@pmelab/gtd/flows`                                                                                                                                            | The flow API a workflow is written in: the steps (`agent`, `human`, `run`, …), `scope` and `slice` (named spans of a process), workflow factories, `defineConfig` and `FLOWS_PROTOCOL`.                |
 | `@pmelab/gtd/wire`                                                                                                                                             | The driver protocol: `WIRE_SCHEMA`, the exit codes and the types of every `--json` document.                                                                                                           |
 | `@pmelab/gtd/steering`                                                                                                                                         | The steering-file formats (`qa`, `review`) and the review-note readers.                                                                                                                                |
 | `@pmelab/gtd/workflow-kit`                                                                                                                                     | Policy-free building blocks to compose a workflow from: health checks, quality laps, scenario freezing, review tails.                                                                                  |
@@ -662,10 +662,15 @@ install for any of these but `./testkit`: gtd resolves a `gtd.config.ts`'s
 `@pmelab/gtd/*` imports to its own copy.
 
 The `gtd` bin's commands — `next`, `land`, `abandon`, `restore`, `validate`,
-`check`, `uncheck`, `install`, `summary`, `base`, `door`, `doors`, `version`,
-`help`, `history list`, `history show`, `history fetch`, `strays`, and the tools
-`ui`, `lsp`, `loop` and `judge` (`judge answer`, `judge run`) — are listed in
-the [CLI reference](https://github.com/pmelab/gtd/blob/main/docs/cli.md).
+`check`, `uncheck`, `install`, `summary`, `base`, `door`, `doors`, `slices`,
+`version`, `help`, `history list`, `history show`, `history fetch`, `strays`,
+and the tools `ui`, `lsp`, `loop`, `judge` (`judge answer`, `judge run`) — are
+listed in the
+[CLI reference](https://github.com/pmelab/gtd/blob/main/docs/cli.md).
+`gtd slices` lists the spans a flow's `slice()` calls mark. It refuses (exit 1)
+when HEAD neither closes nor sits inside a process, or when today's config
+disagrees with history about the process; a version mismatch only warns on
+stderr.
 
 ## License
 

package/dist/chunks/{wire-C12dahrH.mjs → wire-D3Rc5r22.mjs}

@@ -475,4 +475,17 @@ const compile = (glob) => {
 };
 const globMatches = (path, glob) => compile(glob).test(path);
 //#endregion
-export { EXIT_SIGTERM as C, UNATTRIBUTED_MODEL as D, ACCESS_REFUSAL as E, WIRE_SCHEMA as O, EXIT_SIGINT as S, EXIT_USAGE_ERROR as T, demandOf as _, landFields as a, EXIT_OK as b, renderLandJson as c, renderBeatPlain as d, beatDocument as f, beatKindOf as g, BEAT_KINDS as h, judgeJson as i, renderFormat as k, renderLandPlain as l, statusOf as m, resolveSession as n, landProseText as o, renderBeatJson as p, selectPath as r, noopText as s, globMatches as t, DEMAND_BRIEFING as u, stallDiagnosis as v, EXIT_STRAYS_FOUND as w, EXIT_RUNTIME_ERROR as x, EXIT_CODES as y };
+//#region src/wire/Slices.ts
+/** The ONLY place `gtd slices --json`'s shape is built; copies exactly the four fields, in order. */
+const slicesDocument = (slices) => ({
+	schema: 1,
+	slices: slices.map(({ name, base, tip, closed }) => ({
+		name,
+		base,
+		tip,
+		closed
+	}))
+});
+const renderSlicesJson = (document) => JSON.stringify(document) + "\n";
+//#endregion
+export { WIRE_SCHEMA as A, EXIT_RUNTIME_ERROR as C, EXIT_USAGE_ERROR as D, EXIT_STRAYS_FOUND as E, ACCESS_REFUSAL as O, EXIT_OK as S, EXIT_SIGTERM as T, BEAT_KINDS as _, selectPath as a, stallDiagnosis as b, landProseText as c, renderLandPlain as d, DEMAND_BRIEFING as f, statusOf as g, renderBeatJson as h, resolveSession as i, renderFormat as j, UNATTRIBUTED_MODEL as k, noopText as l, beatDocument as m, slicesDocument as n, judgeJson as o, renderBeatPlain as p, globMatches as r, landFields as s, renderSlicesJson as t, renderLandJson as u, beatKindOf as v, EXIT_SIGINT as w, EXIT_CODES as x, demandOf as y };

package/dist/flows.mjs

@@ -86,6 +86,20 @@ const scope = async (scope, fn) => {
 		context.popScope();
 	}
 };
+/**
+* Mark the span `fn` covers as one named slice of the process. Lands no
+* commit, prefixes no step name, opens no memory scope.
+*/
+const slice = async (name, fn) => {
+	const context = ctx();
+	if (typeof context.enterSlice !== "function") return fn();
+	context.enterSlice(name);
+	try {
+		return await fn();
+	} finally {
+		context.leaveSlice?.();
+	}
+};
 const read = (path) => ctx().read(path);
 /** Every path in the tree matching `pattern` (`*` stays within a segment, `**` crosses them). */
 const glob = (pattern) => ctx().glob(pattern);
@@ -652,10 +666,11 @@ var flows_exports = /* @__PURE__ */ __exportAll({
 	sections: () => sections,
 	showScript: () => showScript,
 	skillsFor: () => skillsFor,
+	slice: () => slice,
 	start: () => start,
 	threads: () => threads,
 	vars: () => vars,
 	wrote: () => wrote
 });
 //#endregion
-export { FLOWS_PROTOCOL, FlowsProtocolError, accessFor, agent, answered, changes, changesSince, check, checkScript, codeChanges, codeThreads, configProblems, configure, defineConfig, defineWorkflow, displayPath, env, glob, hasThreadFor, head, human, installContext, isFactoryWorkflow, judge, judgeDiffShape, kept, mark, matches, moveScript, numeric, openQuestions, protocolMismatch, quote, read, refuse, removeScript, requireAnswers, requireProgress, requireReplies, requireRevert, requireThreadsClosed, restart, restoreScript, revertScript, run, scope, seamGate, sectionBodies, sections, showScript, skillsFor, start, flows_exports as t, threads, vars, wrote };
+export { FLOWS_PROTOCOL, FlowsProtocolError, accessFor, agent, answered, changes, changesSince, check, checkScript, codeChanges, codeThreads, configProblems, configure, defineConfig, defineWorkflow, displayPath, env, glob, hasThreadFor, head, human, installContext, isFactoryWorkflow, judge, judgeDiffShape, kept, mark, matches, moveScript, numeric, openQuestions, protocolMismatch, quote, read, refuse, removeScript, requireAnswers, requireProgress, requireReplies, requireRevert, requireThreadsClosed, restart, restoreScript, revertScript, run, scope, seamGate, sectionBodies, sections, showScript, skillsFor, slice, start, flows_exports as t, threads, vars, wrote };

package/dist/gtd.bundle.mjs

@@ -21724,6 +21724,20 @@ const scope = async (scope, fn) => {
 		context.popScope();
 	}
 };
+/**
+* Mark the span `fn` covers as one named slice of the process. Lands no
+* commit, prefixes no step name, opens no memory scope.
+*/
+const slice = async (name, fn) => {
+	const context = ctx();
+	if (typeof context.enterSlice !== "function") return fn();
+	context.enterSlice(name);
+	try {
+		return await fn();
+	} finally {
+		context.leaveSlice?.();
+	}
+};
 const read = (path) => ctx().read(path);
 /** Every path in the tree matching `pattern` (`*` stays within a segment, `**` crosses them). */
 const glob = (pattern) => ctx().glob(pattern);
@@ -22290,6 +22304,7 @@ var flows_exports = /* @__PURE__ */ __exportAll({
 	sections: () => sections,
 	showScript: () => showScript,
 	skillsFor: () => skillsFor,
+	slice: () => slice,
 	start: () => start,
 	threads: () => threads,
 	vars: () => vars,
@@ -37637,6 +37652,22 @@ var init_Glob = __esmMin((() => {
 	globMatches = (path, glob) => compile(glob).test(path);
 }));
 //#endregion
+//#region src/wire/Slices.ts
+var slicesDocument, renderSlicesJson;
+var init_Slices = __esmMin((() => {
+	init_constants();
+	slicesDocument = (slices) => ({
+		schema: 1,
+		slices: slices.map(({ name, base, tip, closed }) => ({
+			name,
+			base,
+			tip,
+			closed
+		}))
+	});
+	renderSlicesJson = (document) => JSON.stringify(document) + "\n";
+}));
+//#endregion
 //#region src/wire/index.ts
 var init_wire = __esmMin((() => {
 	init_constants();
@@ -37651,6 +37682,7 @@ var init_wire = __esmMin((() => {
 	init_Select();
 	init_Sessions();
 	init_Glob();
+	init_Slices();
 }));
 //#endregion
 //#region src/replay/RefName.ts
@@ -37670,6 +37702,32 @@ const refNameFault = (name) => {
 	}
 };
 //#endregion
+//#region src/replay/Slices.ts
+const IMPLICIT_SLICE = "main";
+/** Same shape as mark()'s name rule; kept local so @pmelab/gtd/flows publishes no regex. */
+const SLICE_NAME = /^[a-z][a-z0-9-]*$/;
+/**
+* Folds boundaries into ranges: each kept span's base is the previous kept
+* span's `leftAt`, so a gap before a span belongs to it, and the last span
+* runs to the episode tip. A closed span that landed nothing is dropped.
+*/
+const sliceRanges = (spans, episode) => {
+	if (spans.some((s) => s.enteredAt === "" || s.leftAt === "")) throw new Error("sliceRanges: a pending turn's \"\" hash is not a commit");
+	const kept = spans.filter((s) => s.leftAt === void 0 || s.enteredAt !== s.leftAt);
+	if (kept.length === 0) return [{
+		name: IMPLICIT_SLICE,
+		base: episode.base,
+		tip: episode.tip,
+		open: true
+	}];
+	return kept.map((s, i) => ({
+		name: s.name,
+		base: i === 0 ? episode.base : kept[i - 1].leftAt ?? episode.base,
+		tip: i === kept.length - 1 ? episode.tip : s.leftAt ?? episode.tip,
+		open: i === kept.length - 1
+	}));
+};
+//#endregion
 //#region src/replay/Tree.ts
 const treeFromRecord = (files) => ({
 	paths: () => Object.keys(files).sort(),
@@ -37826,7 +37884,7 @@ const TRAILER_READERS = {
 		if (value !== "") into.branch ??= value;
 	},
 	"Gtd-Version": (value, into) => {
-		if (value !== "") into.version ??= value;
+		if (value !== "" && !/[\u0000-\u001f\u007f-\u009f]/.test(value)) into.version ??= value;
 	},
 	"Gtd-Kept": (value, into) => {
 		if (HASH_RE.test(value)) into.kept ??= value;
@@ -38017,6 +38075,7 @@ const replay = async (input) => {
 	const keptTips = /* @__PURE__ */ new Map();
 	let landed;
 	const marks = [];
+	const slices = [];
 	let outcome;
 	let signal;
 	const settled = new Promise((resolve) => {
@@ -38223,7 +38282,8 @@ const replay = async (input) => {
 			rest: step,
 			trace,
 			landed,
-			marks
+			marks,
+			slices: slices.map((s) => ({ ...s }))
 		});
 		return landPending(step, input.pending);
 	};
@@ -38262,7 +38322,8 @@ const replay = async (input) => {
 		via,
 		trace,
 		landed,
-		marks
+		marks,
+		slices: slices.map((s) => ({ ...s }))
 	};
 	const changesSince = (hash) => {
 		const tree = treeAt(hash);
@@ -38287,6 +38348,31 @@ const replay = async (input) => {
 			scopes.pop();
 			scopeCallIds.pop();
 		},
+		enterSlice: (name) => {
+			if (outcome !== void 0) return;
+			const fail = (message) => {
+				finish({
+					kind: "failed",
+					message
+				});
+				throw new Stop();
+			};
+			if (typeof name !== "string" || !SLICE_NAME.test(name)) fail(`gtd: slice "${name}": name must match ${SLICE_NAME}`);
+			if (name === "main") fail(`gtd: slice "${IMPLICIT_SLICE}" is reserved for the implicit slice`);
+			const open = slices.find((s) => s.leftAt === void 0);
+			if (open !== void 0) fail(`gtd: slice "${name}" is entered inside slice "${open.name}" — slices do not nest`);
+			if (slices.some((s) => s.name === name)) fail(`gtd: slice "${name}" is entered twice in this episode — a loop must sit inside its slice`);
+			slices.push({
+				name,
+				enteredAt: position.hash,
+				leftAt: void 0
+			});
+		},
+		leaveSlice: () => {
+			if (outcome !== void 0) return;
+			const open = slices.find((s) => s.leftAt === void 0);
+			if (open !== void 0) open.leftAt = position.hash;
+		},
 		read: (path) => position.tree.read(path),
 		glob: (pattern) => position.tree.paths().filter((path) => globMatches(path, pattern)),
 		changes: () => changesBetween(previousPosition.tree, position.tree),
@@ -39678,22 +39764,14 @@ const runAtTip = (git, def, tip) => gen(function* () {
 	if (closing.length === 0) closing = yield* git.commitHistory(void 0, tip.hash);
 	return yield* runOf([...before, ...closing], { ...location }, tip.hash);
 });
-/** The process HEAD closes or sits inside — `gtd summary`'s run. */
-const summaryRun = gen(function* () {
-	const git = yield* GitService;
-	const def = (yield* (yield* ConfigService).load).workflow;
+const runAtHead = (git, def) => gen(function* () {
 	return yield* runAtTip(git, def, (yield* git.subjectHistory(1, 0))[0]);
 });
-/** The process whose finishing commit is `tip` — reads from `tip`'s own ancestry, so it works when no branch reaches it. */
-const closedRunAt = (tip) => gen(function* () {
+/** The process HEAD closes or sits inside — `gtd summary`'s run. */
+const summaryRun = gen(function* () {
 	const git = yield* GitService;
 	const def = (yield* (yield* ConfigService).load).workflow;
-	const hash = yield* git.resolveRef(tip);
-	const subject = yield* git.lastCommitSubject(hash);
-	return yield* runAtTip(git, def, {
-		hash,
-		subject
-	});
+	return yield* runAtHead(git, def);
 });
 const commitTree = (workspace, hash) => {
 	let entries;
@@ -39976,6 +40054,10 @@ const pendingChanges = (git, withIndex) => gen(function* () {
 	const seen = new Set(worktree.map((e) => e.path));
 	return [...worktree, ...(yield* git.stagedPaths()).filter((e) => !seen.has(e.path))];
 });
+const sliceRangesOf = (slices, run) => sliceRanges(slices, {
+	base: run.startParentHash,
+	tip: run.trace.at(-1)?.hash ?? run.startParentHash
+});
 /** Resolve the rest at `ref`, or at HEAD when `ref` is `undefined`. */
 const restAt = (ref, startOverrides = {}) => gen(function* () {
 	const git = yield* GitService;
@@ -40023,6 +40105,49 @@ const restAt = (ref, startOverrides = {}) => gen(function* () {
 });
 const currentRest = restAt(void 0);
 /**
+* The slices of the process HEAD closes or sits inside, current episode only,
+* stack order. Reads like `historyTrail`, never `restAt`: it narrates and
+* writes nothing, and returns a version warning for a closed run.
+*/
+const processSlices = gen(function* () {
+	const git = yield* GitService;
+	const config = yield* (yield* ConfigService).load;
+	const workspace = yield* Workspace;
+	const host = yield* Host;
+	const run = yield* runAtHead(git, config.workflow);
+	if (run.trace.length === 0) return yield* fail$7(/* @__PURE__ */ new Error("gtd slices: refused — HEAD neither closes nor sits inside a process"));
+	const closing = run.closingHash;
+	let outcome;
+	let versionWarning;
+	if (closing !== void 0) {
+		const replayed = yield* replayFinishedProcess(config, run, closing, {
+			command: "gtd slices",
+			configReason: "HEAD's process replays under today's config; revert or stash the edit to list its slices",
+			notEnded: (o) => slicesDivergence(run, o)
+		});
+		outcome = replayed.outcome;
+		versionWarning = replayed.versionWarning;
+	} else {
+		const { setup } = yield* setupFor(config, run, workspace, host);
+		outcome = yield* promise(() => replayFor(setup));
+		if (outcome.kind !== "rest") return yield* fail$7(slicesDivergence(run, outcome));
+	}
+	return {
+		slices: sliceRangesOf(outcome.slices, run).map(({ name, base, tip, open }) => ({
+			name,
+			base,
+			tip,
+			closed: closing !== void 0 || !open
+		})),
+		...versionWarning !== void 0 ? { versionWarning } : {}
+	};
+});
+/** Every `gtd slices` refusal reads `gtd slices: refused — <reason>`; replay's own `gtd: ` lead is dropped. */
+const slicesDivergence = (run, outcome) => {
+	const reason = outcome.kind === "rest" && run.closingHash !== void 0 ? `${run.closingHash.slice(0, 7)} closes a process that does not end under today's config` : replayError(outcome)?.message.replace(/^gtd: /, "") ?? "replay failed";
+	return /* @__PURE__ */ new Error(`gtd slices: refused — ${reason}`);
+};
+/**
 * Whether `gtd --workflow <name>` can start a process here: the workflow must
 * reach a step from the tree the opening commit would capture. That step is
 * what the opening commit's subject names.
@@ -40256,7 +40381,7 @@ const inRepoConfigPaths = (root, files, recorded) => {
 	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 = (tip, paths) => /* @__PURE__ */ new Error(`gtd history: refused — config differs at ${tip.slice(0, 7)}: ${paths.join(", ")}. A history ref replays under today's config, so it is unreadable after the config changes`);
+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 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);
@@ -40287,22 +40412,19 @@ const versionWarningFor = (recorded) => recorded === GTD_VERSION ? void 0 : `gtd
 const historyTrail = (tip) => gen(function* () {
 	const git = yield* GitService;
 	const config = yield* (yield* ConfigService).load;
-	const workspace = yield* Workspace;
-	const host = yield* Host;
 	const hash = yield* git.resolveRef(tip);
-	const run = yield* closedRunAt(hash);
-	const differing = yield* differingConfigPaths(git, workspace, host.root, config, run, hash);
-	if (differing.length > 0) return yield* fail$7(configRefusal(hash, differing));
-	const { setup } = yield* setupFor(config, run, workspace, host);
-	yield* workspace.episodeTrees(run.episode.base, run.episode.commits.map((c) => c.hash));
-	const outcome = yield* promise(() => replayFor(setup));
-	if (outcome.kind !== "ended") return yield* fail$7(notClosedError(hash, outcome));
-	const steps = historySteps(run);
-	const recorded = parseCommitMessage(yield* git.lastCommitMessage(hash)).version;
-	const versionWarning = versionWarningFor(recorded);
+	const subject = yield* git.lastCommitSubject(hash);
+	const run = yield* runAtTip(git, config.workflow, {
+		hash,
+		subject
+	});
+	const { outcome, recorded, versionWarning } = yield* replayFinishedProcess(config, run, hash, {
+		command: "gtd history",
+		notEnded: (o) => notClosedError(hash, o)
+	});
 	return {
 		tip: hash,
-		steps,
+		steps: historySteps(run),
 		ended: outcome.via,
 		version: {
 			recorded,
@@ -40311,6 +40433,24 @@ const historyTrail = (tip) => gen(function* () {
 		...versionWarning !== void 0 ? { versionWarning } : {}
 	};
 });
+/** Refuses on config drift before replaying, so a stale config never runs the flow. */
+const replayFinishedProcess = (config, run, hash, how) => gen(function* () {
+	const git = yield* GitService;
+	const workspace = yield* Workspace;
+	const host = yield* Host;
+	const differing = yield* differingConfigPaths(git, workspace, host.root, config, run, hash);
+	if (differing.length > 0) return yield* fail$7(configRefusal(how.command, hash, differing, how.configReason));
+	const { setup } = yield* setupFor(config, run, workspace, host);
+	const outcome = yield* promise(() => replayFor(setup));
+	if (outcome.kind !== "ended") return yield* fail$7(how.notEnded(outcome));
+	const recorded = parseCommitMessage(run.episode.commits.find((c) => c.hash === hash)?.message ?? "").version;
+	const versionWarning = versionWarningFor(recorded);
+	return {
+		outcome,
+		recorded,
+		...versionWarning !== void 0 ? { versionWarning } : {}
+	};
+});
 //#endregion
 //#region src/emit/GitScript.ts
 const shellQuote$1 = (value) => `'${value.replace(/'/g, "'\\''")}'`;
@@ -41183,6 +41323,17 @@ const runDoorsCommand = (json, out) => gen(function* () {
 	if (json.kind === "document") out.write(`${JSON.stringify(document)}\n`);
 	else yield* writeSelection(out, document, json.path);
 });
+const runSlicesCommand = (json, out) => gen(function* () {
+	const { slices, versionWarning } = yield* processSlices;
+	if (versionWarning !== void 0) yield* (yield* Narrator).warn(versionWarning);
+	if (json.kind === "off") {
+		out.write(slices.map((s) => `${s.name} ${s.base}..${s.tip}\n`).join(""));
+		return;
+	}
+	const document = slicesDocument(slices);
+	if (json.kind === "document") out.write(renderSlicesJson(document));
+	else yield* writeSelection(out, document, json.path);
+});
 /**
 * Ends the process underway without completing it. Nothing is discarded: a
 * `git reset --mixed` to the process's start commit leaves every turn
@@ -41518,6 +41669,7 @@ const dispatchVoidCommand = (command, json, out) => {
 		case "start": return runStartCommand(command.actor, command.workflow, command.vars, out, command.label);
 		case "door": return runDoorCommand(command.name, command.args, out);
 		case "doors": return runDoorsCommand(json, out);
+		case "slices": return runSlicesCommand(json, out);
 		case "abandon": return runAbandonCommand(out);
 		case "restore": return runRestoreCommand(out);
 		case "next": return runNextCommand(json, out);
@@ -41576,12 +41728,12 @@ const FLAGS = [
 		name: "--json",
 		arity: "optional",
 		repeatable: false,
-		scope: (kind) => kind === "next" || kind === "land" || kind === "judge" || kind === "judgeAnswer" || kind === "doors" || kind === "historyList" || kind === "historyShow" || kind === "strays",
+		scope: (kind) => kind === "next" || kind === "land" || kind === "judge" || kind === "judgeAnswer" || kind === "doors" || kind === "slices" || kind === "historyList" || kind === "historyShow" || kind === "strays",
 		decode: ([raw]) => right(raw ?? ""),
-		scopeError: "gtd: --json is only valid for `gtd next`/`gtd land`/`gtd judge`/`gtd judge answer`/`gtd doors`/`gtd history list`/`gtd history show`/`gtd strays` — every other command prints plain text; see `gtd install` for the driver protocol briefing",
+		scopeError: "gtd: --json is only valid for `gtd next`/`gtd land`/`gtd judge`/`gtd judge answer`/`gtd doors`/`gtd slices`/`gtd history list`/`gtd history show`/`gtd strays` — every other command prints plain text; see `gtd install` for the driver protocol briefing",
 		valueHint: "<path>",
 		help: [
-			"(gtd next/gtd land/gtd judge/gtd judge answer/gtd doors/gtd history",
+			"(gtd next/gtd land/gtd judge/gtd judge answer/gtd doors/gtd slices/gtd history",
 			"list/gtd history show/gtd strays only) output structured JSON. Bare --json prints the whole document;",
 			"--json=<path> (a dotted key path into that document, e.g.",
 			"kind, content, session.id) prints just that value: a",
@@ -42051,6 +42203,25 @@ const COMMAND_ROWS = [
 			"value off it. Writes nothing"
 		]
 	},
+	{
+		token: "slices",
+		kind: "slices",
+		arity: "none",
+		details: [
+			"List the slices of the process HEAD closes or sits inside,",
+			"first slice first: one `name base..tip` line each (full",
+			"hashes; plain output carries no promise). --json prints",
+			"{ schema: 1, slices: [{ name, base, tip, closed }] };",
+			"--json=<path> reads one value off it. Writes nothing: no",
+			"git, no state transition, no session identity. When HEAD",
+			"closes a process, every slice is listed as closed; a gtd",
+			"version mismatch only warns on stderr. Refuses (exit 1)",
+			"when HEAD neither closes nor sits inside a process, or when",
+			"today's config disagrees with history about the process:",
+			"HEAD closes it and its config files differ from the working",
+			"tree, or the replay diverged"
+		]
+	},
 	{
 		token: "judge",
 		kind: "judge",