@pmelab/gtd 27.7.1 → 27.9.0

package/dist/testkit.mjs

@@ -1,5 +1,5 @@
 import { checkScript, configProblems, configure, installContext, isFactoryWorkflow, moveScript, protocolMismatch, removeScript, restoreScript, revertScript, showScript, t as flows_exports } from "./flows.mjs";
-import { E as ACCESS_REFUSAL, _ as demandOf, a as landFields, c as renderLandJson, d as renderBeatPlain, f as beatDocument, g as beatKindOf, i as judgeJson, k as renderFormat, l as renderLandPlain, m as statusOf, n as resolveSession, p as renderBeatJson, r as selectPath, s as noopText, t as globMatches } from "./chunks/wire-C12dahrH.mjs";
+import { O as ACCESS_REFUSAL, a as selectPath, d as renderLandPlain, g as statusOf, h as renderBeatJson, i as resolveSession, j as renderFormat, l as noopText, m as beatDocument, n as slicesDocument, o as judgeJson, p as renderBeatPlain, r as globMatches, s as landFields, t as renderSlicesJson, u as renderLandJson, v as beatKindOf, y as demandOf } from "./chunks/wire-D3Rc5r22.mjs";
 import { C as headingSections, S as headingSectionBodies, a as unansweredQuestions, b as parseThreadsWithFindings, n as openThreads, r as steeringFormatFor, s as parseCodeThreads, t as BUILT_IN_MODE_NAMES, w as formatFinding } from "./chunks/steering-DVILanVf.mjs";
 import { $ as logWarning, $i as NodeInspectSymbol, $n as map$5, $r as make$19, $t as provide$1, A as catchIf, Ai as add, An as scopeMake, Ar as flatMap$3, At as suspend$5, B as flatMap$4, Bi as getOrElse, Bn as get$3, Br as sync$1, Bt as unsafeMakeLatch, C as all$1, Ci as toArray, Cn as isInterrupted, Cr as exitFail, Ct as sandbox, D as async, Di as GenericTag, Dn as squash, Dr as exitZipRight, Dt as scopedWith$1, E as asVoid$1, Ei as unsafeHead, En as reduceWithContext, Er as exitVoid, Et as scoped$4, F as ensuring$2, Fi as fromIterable, Fn as join$3, Fr as map$3, Ft as tryMap, G as forkIn, Gi as none, Gn as TypeId$10, Gr as whenEffect, Gt as zipLeft, H as fnUntraced, Hi as isSome, Hn as modify$1, Hr as uninterruptible, Ht as when, I as exit, Ii as splitAt, In as sequential, Ir as onInterrupt, It as tryPromise, J as ignore, Ji as left, Jn as all, Jr as DeferredTypeId$1, Jt as spaced$1, K as forkScoped, Ki as some, Kn as Class, Kr as withFiberRuntime, Kt as zipRight$3, L as fail$5, Li as filter$1, Ln as bind, Lr as scopeClose, Lt as try_, M as die$2, Mi as getOption, Mn as _await$2, Mr as interruptAsFiber, Mt as tap, N as dieMessage, Ni as omit, Nn as inheritAll$1, Nr as interruptFiber, Nt as tapErrorCause, O as catchAll$1, Oi as Reference, On as ensuring$3, Or as fiberId, Ot as serviceOption, P as either, Pi as empty$5, Pn as interruptAllAs$1, Pr as interruptible$1, Pt as timeout, Q as isEffect, Qi as BaseProto, Qn as isFailure, Qr as ids, Qt as mergeAll$2, R as failCause$4, Ri as flatMap$5, Rn as bindTo, Rr as succeed$4, Rt as uninterruptible$1, S as addFinalizer$1, Si as takeRight, Sn as isDieType, Sr as exitAs, St as runtime, T as as, Ti as unsafeGet, Tn as map$6, Tr as exitSucceed, Tt as scopeWith, U as forEach$2, Ui as map$8, Un as set$1, Ur as uninterruptibleMask$1, Ut as withFiberRuntime$1, V as flatten$4, Vi as isNone, Vn as make$16, Vr as tap$1, Vt as unsafeMakeSemaphore$1, W as forkDaemon, Wi as match$4, Wn as update$1, Wr as void_$2, Wt as zip$1, X as interruptible, Xi as right, Xn as fail$4, Xr as combine, Xt as tagged, Y as interrupt$4, Yi as match$2, Yn as die, Yr as empty$6, Yt as TaggedError$1, Z as intoDeferred, Zi as pipeArguments, Zn as failCause$3, Zr as combineAll, Zt as fromEffect$5, _ as decodeSync, _i as of, _n as fail$3, _r as deferredIsDone, _t as raceWith, a as Literal, aa as constTrue, ai as size$2, an as updateContext$1, ar as zipRight$2, at as matchCause, b as acquireRelease, bi as reverse, bn as interrupt$3, br as deferredUnsafeDone, bt as runPromise, c as String$, ca as dual, ci as append$1, cn as Scope, cr as asyncInterrupt, ct as negate, d as Union, di as empty$4, dn as close, dr as deferredAwait, dt as orElse, ea as format, ei as none$1, en as provideMerge$1, er as mapBoth, et as makeSemaphore, f as between, fi as filter, fn as extend, fr as deferredComplete, ft as orElseSucceed, gi as map$7, gn as die$1, gr as deferredInterruptWith, gt as race, hi as isEmpty$2, hn as NoSuchElementException, hr as deferredInterrupt, ht as provideService, i as Defect, ia as constFalse, ii as has, in as unsafeRunPromiseExit, ir as zip$2, it as match$5, j as catchTag, ji as get$5, jn as scopeTag, jr as interrupt$2, jt as sync$2, k as catchAllCause, ki as Tag, kn as forEachConcurrentDiscard, kr as fiberRefLocally, kt as succeed$6, l as Struct, la as identity, li as appendAll, ln as addFinalizer, lr as catchAll, lt as onError, m as optional$1, mi as isChunk, mn as make$18, mr as deferredFailCause, mt as provide$2, n as Boolean$, na as equals, ni as make$17, nn as succeed$3, nr as succeed$5, nt as mapBoth$1, o as Never, oa as constUndefined, oi as decode, on as forkIn$1, or as as$1, ot as matchCauseEffect, p as decodeUnknown, pi as fromIterable$1, pn as fork, pr as deferredFail, pt as promise, q as gen, qi as isLeft, qn as spanTag, qr as zipRight$1, qt as zipWith, r as Cause, ra as hasProperty, ri as set$2, rn as unsafeFork, rr as void_$3, rt as mapError, s as Number$, sa as constVoid, si as isFinite, sn as unsafeMakeSemaphore, sr as asVoid, st as matchEffect, t as Array$, ta as toJSON, ti as get$4, tn as scoped$3, tr as match$3, tt as map$4, u as TaggedError, ua as pipe, ui as drop, un as addFinalizerExit, ur as currentContext$1, ut as orDie, v as encodeSync, vi as prepend, vn as failureOrCause, vr as deferredMake, vt as repeat, w as annotateLogs, wi as unsafeFromArray, wn as isInterruptedOnly, wr as exitFailCause, wt as scope, x as acquireUseRelease$2, xi as take$2, xn as interruptors, xr as deferredUnsafeMake, xt as runPromiseExit$1, y as _void, yi as reduce, yn as flipCauseOption, yr as deferredSucceed, yt as retry, z as fiberIdWith, zi as fromNullable, zn as sleep, zr as suspend$4, zt as uninterruptibleMask } from "./chunks/Schema-DO5ttJaI.mjs";
 import { createRequire } from "node:module";
@@ -6817,6 +6817,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(),
@@ -6973,7 +6999,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;
@@ -7164,6 +7190,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) => {
@@ -7370,7 +7397,8 @@ const replay = async (input) => {
 			rest: step,
 			trace,
 			landed,
-			marks
+			marks,
+			slices: slices.map((s) => ({ ...s }))
 		});
 		return landPending(step, input.pending);
 	};
@@ -7409,7 +7437,8 @@ const replay = async (input) => {
 		via,
 		trace,
 		landed,
-		marks
+		marks,
+		slices: slices.map((s) => ({ ...s }))
 	};
 	const changesSince = (hash) => {
 		const tree = treeAt(hash);
@@ -7434,6 +7463,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),
@@ -8814,22 +8868,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);
 });
+const runAtHead = (git, def) => gen(function* () {
+	return yield* runAtTip(git, def, (yield* git.subjectHistory(1, 0))[0]);
+});
 /** 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;
-	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* () {
-	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;
@@ -9112,6 +9158,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;
@@ -9159,6 +9209,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$5(/* @__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$5(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.
@@ -9392,7 +9485,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);
@@ -9423,22 +9516,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$5(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$5(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,
@@ -9447,6 +9537,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$5(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$5(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 = (value) => `'${value.replace(/'/g, "'\\''")}'`;
@@ -10315,6 +10423,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
@@ -10650,6 +10769,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);
@@ -10706,12 +10826,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",
@@ -11181,6 +11301,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",

package/dist/wire.mjs

@@ -1,2 +1,2 @@
-import { C as EXIT_SIGTERM, D as UNATTRIBUTED_MODEL, E as ACCESS_REFUSAL, O as WIRE_SCHEMA, S as EXIT_SIGINT, T as EXIT_USAGE_ERROR, _ as demandOf, a as landFields, b as EXIT_OK, c as renderLandJson, d as renderBeatPlain, f as beatDocument, g as beatKindOf, h as BEAT_KINDS, i as judgeJson, k as renderFormat, l as renderLandPlain, m as statusOf, n as resolveSession, o as landProseText, p as renderBeatJson, r as selectPath, s as noopText, t as globMatches, u as DEMAND_BRIEFING, v as stallDiagnosis, w as EXIT_STRAYS_FOUND, x as EXIT_RUNTIME_ERROR, y as EXIT_CODES } from "./chunks/wire-C12dahrH.mjs";
-export { ACCESS_REFUSAL, BEAT_KINDS, DEMAND_BRIEFING, EXIT_CODES, EXIT_OK, EXIT_RUNTIME_ERROR, EXIT_SIGINT, EXIT_SIGTERM, EXIT_STRAYS_FOUND, EXIT_USAGE_ERROR, UNATTRIBUTED_MODEL, WIRE_SCHEMA, beatDocument, beatKindOf, demandOf, globMatches, judgeJson, landFields, landProseText, noopText, renderBeatJson, renderBeatPlain, renderFormat, renderLandJson, renderLandPlain, resolveSession, selectPath, stallDiagnosis, statusOf };
+import { A as WIRE_SCHEMA, C as EXIT_RUNTIME_ERROR, D as EXIT_USAGE_ERROR, E as EXIT_STRAYS_FOUND, O as ACCESS_REFUSAL, S as EXIT_OK, T as EXIT_SIGTERM, _ as BEAT_KINDS, a as selectPath, b as stallDiagnosis, c as landProseText, d as renderLandPlain, f as DEMAND_BRIEFING, g as statusOf, h as renderBeatJson, i as resolveSession, j as renderFormat, k as UNATTRIBUTED_MODEL, l as noopText, m as beatDocument, n as slicesDocument, o as judgeJson, p as renderBeatPlain, r as globMatches, s as landFields, t as renderSlicesJson, u as renderLandJson, v as beatKindOf, w as EXIT_SIGINT, x as EXIT_CODES, y as demandOf } from "./chunks/wire-D3Rc5r22.mjs";
+export { ACCESS_REFUSAL, BEAT_KINDS, DEMAND_BRIEFING, EXIT_CODES, EXIT_OK, EXIT_RUNTIME_ERROR, EXIT_SIGINT, EXIT_SIGTERM, EXIT_STRAYS_FOUND, EXIT_USAGE_ERROR, UNATTRIBUTED_MODEL, WIRE_SCHEMA, beatDocument, beatKindOf, demandOf, globMatches, judgeJson, landFields, landProseText, noopText, renderBeatJson, renderBeatPlain, renderFormat, renderLandJson, renderLandPlain, renderSlicesJson, resolveSession, selectPath, slicesDocument, stallDiagnosis, statusOf };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "27.7.1",
+  "version": "27.9.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/src/cli/Cli.test.ts

@@ -112,6 +112,7 @@ describe("parseArgv — scope", () => {
       ["judge", "--json"],
       ["judge", "answer", "--json"],
       ["doors", "--json"],
+      ["slices", "--json"],
     ]) {
       const ok = parseArgv(["node", "gtd.js", ...args])
       expect(ok.kind).toBe("command")
@@ -927,6 +928,40 @@ describe("parseArgv — doors", () => {
   })
 })
 
+describe("parseArgv — slices", () => {
+  const parse = (...args: string[]): CliPlan => parseArgv(["node", "gtd.js", ...args])
+
+  it("`gtd slices` parses with every --json shape", () => {
+    expect(parse("slices")).toMatchObject({
+      kind: "command",
+      command: { kind: "slices" },
+      json: { kind: "off" },
+    })
+    expect(parse("slices", "--json")).toMatchObject({ json: { kind: "document" } })
+    expect(parse("slices", "--json=slices.0.name")).toMatchObject({
+      json: { kind: "select", path: "slices.0.name" },
+    })
+  })
+
+  it("`gtd slices` takes no argument", () => {
+    const plan = parse("slices", "extra")
+    expect(plan.kind).toBe("usage")
+    if (plan.kind === "usage") expect(plan.message).toContain("too many arguments")
+  })
+
+  it("help lists the command, and --json names it", () => {
+    const help = renderHelp()
+    expect(help).toMatch(/^ {2}slices\b/m)
+    expect(help).toContain("gtd slices")
+  })
+
+  it("--json's scope error names gtd slices", () => {
+    const plan = parse("lsp", "--json")
+    expect(plan.kind).toBe("usage")
+    if (plan.kind === "usage") expect(plan.message).toContain("`gtd slices`")
+  })
+})
+
 describe("parseArgv — gtd history", () => {
   const parse = (...args: string[]) => parseArgv(["node", "gtd.js", ...args])
   const usage = (plan: CliPlan): string => (plan.kind === "usage" ? plan.message : "")
@@ -1057,6 +1092,7 @@ describe("standaloneKinds / needsOf", () => {
       "judgeAnswer",
       "door",
       "doors",
+      "slices",
       "historyList",
       "historyShow",
       "historyFetch",
@@ -1136,9 +1172,9 @@ describe("renderHelp", () => {
       expect(match, file).not.toBeNull()
       return new Set([...match![1]!.matchAll(/`([a-z]+(?: [a-z]+)?)`/g)].map(([, name]) => name!))
     }
-    expect(listed("../../README.md", /The `gtd` bin's commands — ([\s\S]*?) — are listed/)).toEqual(
-      commands,
-    )
+    expect(
+      listed("../../README.md", /The `gtd` bin's commands — ([\s\S]*?) — are\s+listed/),
+    ).toEqual(commands)
     expect(listed("../../COMPATIBILITY.md", /every command \(([\s\S]*?)\), option/)).toEqual(
       commands,
     )

package/src/cli/Cli.ts

@@ -101,16 +101,17 @@ const FLAGS: readonly FlagRow[] = [
       kind === "judge" ||
       kind === "judgeAnswer" ||
       kind === "doors" ||
+      kind === "slices" ||
       kind === "historyList" ||
       kind === "historyShow" ||
       kind === "strays",
     decode: ([raw]) => Either.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` — " +
+      "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",
@@ -636,6 +637,25 @@ const COMMAND_ROWS: readonly CommandRow[] = [
       "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",
@@ -1304,6 +1324,7 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
       | "install"
       | "loop"
       | "doors"
+      | "slices"
       | "summary"
       | "base"
       | "judge"

package/src/cli/Program.test.ts

@@ -1677,6 +1677,7 @@ describe("runCommand — refuses in a repository with no commits", () => {
     start: { kind: "start", actor: "human", workflow: "feature", vars: {}, label: "" },
     door: { kind: "door", name: "fix", args: [] },
     doors: { kind: "doors" },
+    slices: { kind: "slices" },
     abandon: { kind: "abandon" },
     restore: { kind: "restore" },
     next: { kind: "next" },
@@ -1703,13 +1704,14 @@ describe("runCommand — refuses in a repository with no commits", () => {
   const NO_COMMITS_MESSAGE =
     "gtd requires a repository with at least one commit — make an initial commit, then run gtd again"
 
-  it("derives exactly the sixteen non-standalone kinds — a canary for the table-driven cases below", () => {
+  it("derives exactly the seventeen non-standalone kinds — a canary for the table-driven cases below", () => {
     expect(stateKinds.sort()).toEqual(
       [
         "abandon",
         "base",
         "door",
         "doors",
+        "slices",
         "start",
         "land",
         "next",

package/src/cli/Program.ts

@@ -43,6 +43,8 @@ import {
   type StatusChange,
   selectPath,
   EXIT_OK,
+  renderSlicesJson,
+  slicesDocument,
 } from "../wire/index.js"
 import {
   currentRest,
@@ -51,6 +53,7 @@ import {
   renderRest,
   restAt,
   previewLanding,
+  processSlices,
   noProcessUnderway,
   restIsIdle,
   reviewBaseFor,
@@ -143,6 +146,7 @@ export type Command =
     }
   | { readonly kind: "door"; readonly name: string; readonly args: readonly string[] }
   | { readonly kind: "doors" }
+  | { readonly kind: "slices" }
   | { readonly kind: "abandon" }
   | { readonly kind: "restore" }
   | { readonly kind: "next" }
@@ -659,6 +663,22 @@ const runDoorsCommand = (
     else yield* writeSelection(out, document, json.path)
   })
 
+const runSlicesCommand = (
+  json: JsonMode,
+  out: ArtifactOut,
+): Effect.Effect<void, Error, CommandRequirements> =>
+  Effect.gen(function* () {
+    const { slices, versionWarning } = yield* processSlices
+    if (versionWarning !== undefined) 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
@@ -1223,6 +1243,8 @@ const dispatchVoidCommand = (
       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":