@pmelab/gtd 8.3.0 → 8.3.1

package/README.md

@@ -117,18 +117,23 @@ steering-file entries are chosen by which file you create:
 Both flows converge on the same tail: an agent hands you a `.gtd/REVIEW.md`
 checkbox review of the diff — the prompt never inlines the diff itself; it names
 the commit the changes are based at and the agent runs `git diff` to read the
-range before writing the review. Tick a box as you review each hunk (ticking
-just records "I read this"), and leave a **comment** to request changes: a note
-on a line, an inline `// TODO`-style comment in the code, or a direct code edit.
-Any comment sends a build + re-review round — an agent first turns your comments
-into an explicit instruction list, then a build turn implements it (a re-review
-then covers only the follow-through, and a hand-edit is treated as your own fix
-the agent completes without reverting your lines; a comment can't be silently
-dropped — a build turn that addresses nothing is refused). Ticking every box
-with no comment is the sign-off, which collapses the whole cycle into one commit
-(a **squash finale** whose message an agent drafts). Stepping with a box still
-unticked and no comment is refused (finish reviewing first), as is deleting
-`.gtd/REVIEW.md`.
+range before writing the review. While the cycle rests at that gate, gtd opens a
+**review checkout window**: HEAD is rewound to the review base with the working
+tree untouched, so the whole reviewable change shows up as ordinary uncommitted
+changes in your editor's normal git integration (and files added during the
+cycle show up as ordinary untracked files, so discarding one deletes it). The
+window closes on the next gtd invocation. Tick a box as you review each hunk
+(ticking just records "I read this"), and leave a **comment** to request
+changes: a note on a line, an inline `// TODO`-style comment in the code, or a
+direct code edit. Any comment sends a build + re-review round — an agent first
+turns your comments into an explicit instruction list, then a build turn
+implements it (a re-review then covers only the follow-through, and a hand-edit
+is treated as your own fix the agent completes without reverting your lines; a
+comment can't be silently dropped — a build turn that addresses nothing is
+refused). Ticking every box with no comment is the sign-off, which collapses the
+whole cycle into one commit (a **squash finale** whose message an agent drafts).
+Stepping with a box still unticked and no comment is refused (finish reviewing
+first), as is deleting `.gtd/REVIEW.md`.
 
 The same review tail also has a direct entry point — `gtd review <commitish>`
 starts a brand new process reviewing `<commitish>..HEAD` with no cycle of its

package/dist/gtd.bundle.mjs

@@ -6541,6 +6541,14 @@ const Equivalence$3 = (self, that) => matchWith(self, that, {
 * @since 2.0.0
 * @category math
 */
+const times = /*#__PURE__*/ dual(2, (self, times) => match$6(self, {
+	onMillis: (millis) => make$40(millis * times),
+	onNanos: (nanos) => make$40(nanos * BigInt(times))
+}));
+/**
+* @since 2.0.0
+* @category math
+*/
 const sum = /*#__PURE__*/ dual(2, (self, that) => matchWith(self, that, {
 	onMillis: (self, that) => make$40(self + that),
 	onNanos: (self, that) => make$40(self + that)
@@ -9804,6 +9812,10 @@ const defaultServicesWith = (f) => withFiberRuntime$1((fiber) => f(fiber.current
 const clockWith = (f) => defaultServicesWith((services) => f(services.unsafeMap.get(clockTag.key)));
 /** @internal */
 const currentTimeMillis$1 = /*#__PURE__*/ clockWith((clock) => clock.currentTimeMillis);
+/** @internal */
+const randomWith = (f) => defaultServicesWith((services) => f(services.unsafeMap.get(randomTag.key)));
+/** @internal */
+const next$1 = /*#__PURE__*/ randomWith((random) => random.next);
 //#endregion
 //#region node_modules/effect/dist/esm/Boolean.js
 /**
@@ -11786,7 +11798,7 @@ const fromIterable = (iterable) => {
 	return new MetricBoundariesImpl(pipe(iterable, appendAll$2(of$1(Number.POSITIVE_INFINITY)), dedupe));
 };
 /** @internal */
-const exponential = (options) => pipe(makeBy(options.count - 1, (i) => options.start * Math.pow(options.factor, i)), unsafeFromArray, fromIterable);
+const exponential$2 = (options) => pipe(makeBy(options.count - 1, (i) => options.start * Math.pow(options.factor, i)), unsafeFromArray, fromIterable);
 /** @internal */
 const MetricKeyTypeTypeId = /*#__PURE__*/ Symbol.for("effect/MetricKeyType");
 /** @internal */
@@ -12860,7 +12872,7 @@ const fiberSuccesses = /*#__PURE__*/ counter("effect_fiber_successes", { increme
 /** @internal */
 const fiberFailures = /*#__PURE__*/ counter("effect_fiber_failures", { incremental: true });
 /** @internal */
-const fiberLifetimes = /*#__PURE__*/ tagged$1(/*#__PURE__*/ histogram("effect_fiber_lifetimes", /*#__PURE__*/ exponential({
+const fiberLifetimes = /*#__PURE__*/ tagged$1(/*#__PURE__*/ histogram("effect_fiber_lifetimes", /*#__PURE__*/ exponential$2({
 	start: .5,
 	factor: 2,
 	count: 35
@@ -14303,7 +14315,7 @@ const isEmpty$3 = (self) => {
 	return self.startMillis >= self.endMillis;
 };
 /** @internal */
-const intersect$4 = /*#__PURE__*/ dual(2, (self, that) => {
+const intersect$5 = /*#__PURE__*/ dual(2, (self, that) => {
 	const start = Math.max(self.startMillis, that.startMillis);
 	const end = Math.min(self.endMillis, that.endMillis);
 	return make$22(start, end);
@@ -14356,7 +14368,7 @@ const isEmpty$2 = isEmpty$3;
 * @since 2.0.0
 * @category ordering
 */
-const intersect$3 = intersect$4;
+const intersect$4 = intersect$5;
 /**
 * Calculates the size of the `Interval` as the `Duration` from the start of the
 * interval to the end of the interval.
@@ -14383,14 +14395,14 @@ const make$20 = (intervals) => {
 	};
 };
 /** @internal */
-const intersect$2 = /*#__PURE__*/ dual(2, (self, that) => intersectLoop(self.intervals, that.intervals, empty$24()));
+const intersect$3 = /*#__PURE__*/ dual(2, (self, that) => intersectLoop(self.intervals, that.intervals, empty$24()));
 /** @internal */
 const intersectLoop = (_left, _right, _acc) => {
 	let left = _left;
 	let right = _right;
 	let acc = _acc;
 	while (isNonEmpty$4(left) && isNonEmpty$4(right)) {
-		const interval = pipe(headNonEmpty(left), intersect$3(headNonEmpty(right)));
+		const interval = pipe(headNonEmpty(left), intersect$4(headNonEmpty(right)));
 		const intervals = isEmpty$2(interval) ? acc : pipe(acc, prepend$1(interval));
 		if (pipe(headNonEmpty(left), lessThan$3(headNonEmpty(right)))) left = tailNonEmpty(left);
 		else right = tailNonEmpty(right);
@@ -14427,7 +14439,7 @@ const make$19 = make$20;
 * @since 2.0.0
 * @category utils
 */
-const intersect$1 = intersect$2;
+const intersect$2 = intersect$3;
 /**
 * The start of the earliest interval in the specified `Intervals`.
 *
@@ -15740,6 +15752,15 @@ const uncapitalize = (self) => {
 * @since 2.0.0
 */
 const isNonEmpty$1 = (self) => self.length > 0;
+//#endregion
+//#region node_modules/effect/dist/esm/Random.js
+/**
+* Returns the next numeric value from the pseudo-random number generator.
+*
+* @since 2.0.0
+* @category constructors
+*/
+const next = next$1;
 /** @internal */
 const ScheduleTypeId = /*#__PURE__*/ Symbol.for("effect/Schedule");
 /** @internal */
@@ -15866,9 +15887,18 @@ const checkEffect = /*#__PURE__*/ dual(2, (self, test) => makeWithState(self.ini
 	]);
 })));
 /** @internal */
+const delayedEffect = /*#__PURE__*/ dual(2, (self, f) => modifyDelayEffect(self, (_, delay) => f(delay)));
+/** @internal */
+const delayedSchedule = (schedule) => addDelay(schedule, (x) => x);
+/** @internal */
 const driver = (self) => pipe(make$29([none$4(), self.initial]), map$8((ref) => new ScheduleDriverImpl(self, ref)));
 /** @internal */
-const intersect = /*#__PURE__*/ dual(2, (self, that) => intersectWith(self, that, intersect$1));
+const exponential$1 = (baseInput, factor = 2) => {
+	const base = decode(baseInput);
+	return delayedSchedule(map$5(forever, (i) => times(base, Math.pow(factor, i))));
+};
+/** @internal */
+const intersect$1 = /*#__PURE__*/ dual(2, (self, that) => intersectWith(self, that, intersect$2));
 /** @internal */
 const intersectWith = /*#__PURE__*/ dual(3, (self, that, f) => makeWithState([self.initial, that.initial], (now, input, state) => pipe(zipWith$2(self.step(now, input, state[0]), that.step(now, input, state[1]), (a, b) => [a, b]), flatMap$6(([[lState, out, lDecision], [rState, out2, rDecision]]) => {
 	if (isContinue(lDecision) && isContinue(rDecision)) return intersectWithLoop(self, that, input, lState, out, lDecision.intervals, rState, out2, rDecision.intervals, f);
@@ -15904,6 +15934,23 @@ const intersectWithLoop = (self, that, input, lState, out, lInterval, rState, ou
 	});
 };
 /** @internal */
+const jittered$1 = (self) => jitteredWith(self, {
+	min: .8,
+	max: 1.2
+});
+/** @internal */
+const jitteredWith = /*#__PURE__*/ dual(2, (self, options) => {
+	const { max, min } = Object.assign({
+		min: .8,
+		max: 1.2
+	}, options);
+	return delayedEffect(self, (duration) => map$8(next, (random) => {
+		const d = toMillis(duration);
+		const jittered = d * min * (1 - random) + d * max * random;
+		return millis(jittered);
+	}));
+});
+/** @internal */
 const map$5 = /*#__PURE__*/ dual(2, (self, f) => mapEffect(self, (out) => sync$2(() => f(out))));
 /** @internal */
 const mapEffect = /*#__PURE__*/ dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => flatMap$6(self.step(now, input, state), ([state, out, decision]) => map$8(f(out), (out2) => [
@@ -15941,7 +15988,7 @@ const passthrough = (self) => makeWithState(self.initial, (now, input, state) =>
 	decision
 ])));
 /** @internal */
-const recurs = (n) => whileOutput(forever, (out) => out < n);
+const recurs$1 = (n) => whileOutput(forever, (out) => out < n);
 /** @internal */
 const spaced$1 = (duration) => addDelay(forever, () => duration);
 /** @internal */
@@ -15990,7 +16037,7 @@ const repeat_combined = /*#__PURE__*/ dual(2, (self, options) => {
 		if (typeof applied === "boolean") return succeed$8(applied);
 		return scheduleDefectWrap(applied);
 	}) : withWhile;
-	const withTimes = options.times ? intersect(withUntil, recurs(options.times)).pipe(map$5((intersectionPair) => intersectionPair[0])) : withUntil;
+	const withTimes = options.times ? intersect$1(withUntil, recurs$1(options.times)).pipe(map$5((intersectionPair) => intersectionPair[0])) : withUntil;
 	return scheduleDefectRefail(repeat_Effect(self, withTimes));
 });
 /** @internal */
@@ -16026,7 +16073,7 @@ const fromRetryOptions = (options) => {
 		if (typeof applied === "boolean") return succeed$8(applied);
 		return scheduleDefectWrap(applied);
 	}) : withWhile;
-	return options.times !== void 0 ? intersect(withUntil, recurs(options.times)) : withUntil;
+	return options.times !== void 0 ? intersect$1(withUntil, recurs$1(options.times)) : withUntil;
 };
 /** @internal */
 const retryOrElse_Effect = /*#__PURE__*/ dual(3, (self, policy, orElse) => flatMap$6(driver(policy), (driver) => retryOrElse_EffectLoop(provideServiceEffect(self, CurrentIterationMetadata, get$4(driver.iterationMeta)), driver, (e, out) => provideServiceEffect(orElse(e, out), CurrentIterationMetadata, get$4(driver.iterationMeta)))));
@@ -20184,6 +20231,79 @@ const provideMerge = provideMerge$1;
 //#endregion
 //#region node_modules/effect/dist/esm/Schedule.js
 /**
+* Creates a schedule that recurs indefinitely with exponentially increasing
+* delays.
+*
+* **Details**
+*
+* This schedule starts with an initial delay of `base` and increases the delay
+* exponentially on each repetition using the formula `base * factor^n`, where
+* `n` is the number of times the schedule has executed so far. If no `factor`
+* is provided, it defaults to `2`, causing the delay to double after each
+* execution.
+*
+* @since 2.0.0
+* @category Constructors
+*/
+const exponential = exponential$1;
+/**
+* Combines two schedules, continuing only if both schedules want to continue,
+* using the longer delay.
+*
+* **Details**
+*
+* This function takes two schedules and creates a new schedule that only
+* continues execution if both schedules allow it. The interval between
+* recurrences is determined by the longer delay between the two schedules.
+*
+* The output of the resulting schedule is a tuple containing the outputs of
+* both schedules. The input type is the intersection of both schedules' input
+* types.
+*
+* This is useful when coordinating multiple scheduling conditions where
+* execution should proceed only when both schedules permit it.
+*
+* @see {@link intersectWith} If you need to use a custom merge function.
+*
+* @since 2.0.0
+* @category Composition
+*/
+const intersect = intersect$1;
+/**
+* Returns a new schedule that randomly adjusts the interval size within a
+* range.
+*
+* **Details**
+*
+* This function modifies a schedule so that its delay between executions is
+* randomly varied within a range. By default, the delay is adjusted between
+* `80%` (`0.8 * interval`) and `120%` (`1.2 * interval`) of the original
+* interval size.
+*
+* This is useful for adding randomness to repeated executions, reducing
+* contention in distributed systems, and avoiding synchronized execution
+* patterns that can cause bottlenecks.
+*
+* @see {@link jitteredWith} If you need to specify custom min/max values.
+*
+* @since 2.0.0
+* @category Timing & Delay
+*/
+const jittered = jittered$1;
+/**
+* A schedule that recurs a fixed number of times before terminating.
+*
+* **Details**
+*
+* This schedule will continue executing until it has been stepped `n` times,
+* after which it will stop. The output of the schedule is the current count of
+* recurrences.
+*
+* @category Constructors
+* @since 2.0.0
+*/
+const recurs = recurs$1;
+/**
 * Returns a schedule that recurs continuously, with each repetition
 * spaced by the specified `duration` from the last run.
 *
@@ -191264,15 +191384,40 @@ const parseNameStatus = (out) => {
 	return result;
 };
 /**
+* True when `error` is git's `index.lock` contention failure — another process
+* held the index lock when git tried to take it. gtd shares one worktree index
+* with every git-aware tool the reviewer runs (editor SCM, `gtd lsp`,
+* git-aware shell prompts): each refreshes its stat cache by WRITING the index
+* whenever a `git reset --mixed` in the review window wakes it, so gtd's own
+* index writes lose the `index.lock` race often on a large repo (where each
+* write takes long enough for the windows to overlap). The lock failure is a
+* pure "couldn't start" — git did nothing — so the losing command is safe to
+* retry verbatim (see `withIndexLockRetry`).
+*/
+const isIndexLockError = (error) => /index\.lock[\s\S]*File exists|Another git process seems to be running/i.test(error.message);
+/**
+* Retry an index-writing git command through transient `index.lock` contention
+* with jittered exponential backoff (~10ms → ~640ms, capped at 6 retries), and
+* ONLY on that error — any other failure propagates on the first attempt. This
+* is the general defense for the concurrent reality `isIndexLockError`
+* describes; it covers every index writer (`git add -A`, `reset`, `restore`),
+* not just the review window's own steps.
+*/
+const withIndexLockRetry = (eff) => retry(eff, {
+	schedule: intersect(recurs(6), exponential(millis(10), 2)).pipe(jittered),
+	while: (error) => isIndexLockError(error)
+});
+/**
 * Run a command and return its stdout — FAILING on a non-zero exit code with
 * the command line and stderr in the error message. `Command.string` alone
 * only collects stdout and silently ignores exit codes, which used to make
 * gtd report success on rejected commits (hooks, gpg), resolve Idle outside a
 * repository, and lose files whose quoted paths broke a swallowed `git add`.
 * Callers that expect a probe to fail (missing refs, empty repos) handle it
-* with an explicit `catchAll`.
+* with an explicit `catchAll`. `index.lock` contention is retried transparently
+* (`withIndexLockRetry`) before any caller's `catchAll` sees it.
 */
-const run = (root, ...args) => scoped$3(gen(function* () {
+const run = (root, ...args) => withIndexLockRetry(scoped$3(gen(function* () {
 	const process = yield* (yield* CommandExecutor).start(make$1(...args).pipe(workingDirectory(root), stdout("pipe"), stderr("pipe")));
 	const collect = (stream) => stream.pipe(decodeText(), mkString);
 	const [stdout$2, stderr$2, exitCode] = yield* all([
@@ -191282,7 +191427,7 @@ const run = (root, ...args) => scoped$3(gen(function* () {
 	], { concurrency: "unbounded" });
 	if (exitCode !== 0) return yield* fail$2(/* @__PURE__ */ new Error(`${args.join(" ")} failed (exit ${exitCode}): ${stderr$2.trim()}`));
 	return stdout$2;
-})).pipe(mapError$1((e) => e instanceof Error ? e : new Error(String(e))));
+})).pipe(mapError$1((e) => e instanceof Error ? e : new Error(String(e)))));
 const makeGitImpl = (executor, root) => {
 	const exec = (...args) => run(root, ...args).pipe(provide$1(succeed$2(CommandExecutor, executor)));
 	return {
@@ -191348,8 +191493,7 @@ const makeGitImpl = (executor, root) => {
 		deleteRef: (ref) => exec("git", "update-ref", "-d", ref).pipe(asVoid),
 		mixedResetTo: (ref) => exec("git", "reset", "--mixed", ref).pipe(asVoid),
 		hardResetTo: (ref) => exec("git", "reset", "--hard", ref).pipe(asVoid),
-		restoreStagedFrom: (source, paths) => paths.length === 0 ? _void : exec("git", "restore", "--staged", `--source=${source}`, "--", ...paths).pipe(catchAll(() => _void)),
-		addIntentToAdd: () => exec("git", "add", "--intent-to-add", ".").pipe(asVoid)
+		restoreStagedFrom: (source, paths) => paths.length === 0 ? _void : exec("git", "restore", "--staged", `--source=${source}`, "--", ...paths).pipe(catchAll(() => _void))
 	};
 };
 const makeLiveEffect = gen(function* () {
@@ -192525,8 +192669,8 @@ const closeReviewWindow = gen(function* () {
 * is nothing to surface and the window stays closed.
 *
 * Ordering is crash-safe: base ref → head ref → mixed reset → `.gtd/` index
-* pin → intent-to-add. A crash before the head-ref write leaves only a stale
-* base ref (overwritten on the next open); a crash after it leaves HEAD ==
+* pin. A crash before the head-ref write leaves only a stale base ref
+* (overwritten on the next open); a crash after it leaves HEAD ==
 * review-head, which the next invocation's close restores as a no-op.
 */
 const openReviewWindow = gen(function* () {
@@ -192542,7 +192686,6 @@ const openReviewWindow = gen(function* () {
 	yield* git.updateRef(REVIEW_HEAD_REF, headHash);
 	yield* git.mixedResetTo(base);
 	yield* git.restoreStagedFrom(REVIEW_HEAD_REF, [".gtd"]);
-	yield* git.addIntentToAdd();
 	return { opened: true };
 });
 //#endregion

package/package.json

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