@pmelab/gtd 8.2.1 → 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
@@ -308,6 +313,13 @@ name surfaced in `gtd next --json`/`gtd status`. The driver uses it for its
 per-beat progress lines; an outer wrapper (a terminal multiplexer, a notifier)
 can use it the same way.
 
+A state can also declare an optional `memory:` scope label: consecutive agent
+turns sharing the same label continue one agent session (remembered in the git
+dir, so it survives restarts across the same worktree), while a changed or
+absent label starts a fresh one. If the remembered session no longer exists
+(retention expired, `~/.claude/projects` wiped, a machine change), the driver
+degrades to a fresh session with a warning instead of stopping the loop.
+
 ### Terminal-multiplexer status: a herdr wrapper
 
 [herdr](https://herdr.dev) shows a per-pane status in its sidebar. This wrapper

package/bin/gtd

@@ -23,7 +23,16 @@ set -euo pipefail
 # Every call the loop body makes below goes through `run_gtd` too, so the loop
 # always drives the exact same build/source it was launched from — no
 # dependence on a `gtd` binary being on PATH.
-SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)"
+# Follow symlinks first: npm's global install exposes this script as a
+# symlink in the node prefix's bin/, and dist/ only exists next to the REAL
+# script inside the package.
+SCRIPT_SOURCE="${BASH_SOURCE[0]}"
+while [[ -L "$SCRIPT_SOURCE" ]]; do
+  SCRIPT_DIR="$(cd -- "$(dirname -- "$SCRIPT_SOURCE")" &>/dev/null && pwd)"
+  SCRIPT_SOURCE="$(readlink "$SCRIPT_SOURCE")"
+  [[ "$SCRIPT_SOURCE" != /* ]] && SCRIPT_SOURCE="$SCRIPT_DIR/$SCRIPT_SOURCE"
+done
+SCRIPT_DIR="$(cd -- "$(dirname -- "$SCRIPT_SOURCE")" &>/dev/null && pwd)"
 
 run_gtd() {
   if [[ -n "${GTD_BIN:-}" ]]; then
@@ -172,6 +181,23 @@ emit_output_since() {
   emit_block "$bytes"
 }
 
+# A resume that failed because the session it names no longer exists — claude
+# prints "No conversation found with session ID: <uuid>". Loose on purpose: any
+# adapter whose CLI says something session-shaped gets the same recovery
+# instead of stopping the loop.
+SESSION_GONE_RE='no conversation found with session id|no such session|session (id )?[^ ]*( was)? not found|session [^ ]* does not exist'
+
+# session_gone_since <offset> — true when the log bytes appended since <offset>
+# carry the missing-session signature above. Blind (returns false) when no log
+# is configured, so recovery is best-effort, never a hard dependency.
+session_gone_since() {
+  local offset="$1" bytes=""
+  if [[ -n "${GTD_LOOP_LOG:-}" && -f "$GTD_LOOP_LOG" ]]; then
+    bytes="$(tail -c "+$((offset + 1))" "$GTD_LOOP_LOG" 2>/dev/null || true)"
+  fi
+  [[ -n "$bytes" ]] && grep -qiE "$SESSION_GONE_RE" <<<"$bytes"
+}
+
 # emit_warn <message> — a surfaced but NON-fatal failure (a check script that
 # exited non-zero).
 emit_warn() {
@@ -330,7 +356,18 @@ fi
 # still resumes one planning session. The scope, session id, and a
 # resume-or-fresh flag are exported as $GTD_LOOP_MEMORY / $GTD_LOOP_SESSION_ID
 # / $GTD_LOOP_MEMORY_RESUME; the default adapter turns them into
-# `--resume`/`--session-id`. An adapter that ignores them keeps working.
+# `--resume`/`--session-id`. An adapter that ignores them keeps working. A
+# remembered session that has since vanished (the retention window elapsed, a
+# wiped `~/.claude/projects`, a machine change) degrades to a fresh session
+# with a warning rather than failing the turn — see run_agent_turn's own
+# comment.
+
+# new_session_id — mints an opaque session id for a fresh memory scope
+# (uuidgen, falling back to the kernel's random uuid, or empty when neither is
+# available — the default adapter then omits --session-id entirely).
+new_session_id() {
+  uuidgen 2>/dev/null || cat /proc/sys/kernel/random/uuid 2>/dev/null || echo ""
+}
 
 prev_state=""
 prev_content=""
@@ -362,7 +399,7 @@ fi
 # the resume flag; the memory scope ($memory/$session_id) is read from the
 # enclosing iteration, so a same-turn re-prompt (the validate gate) resumes the
 # same session.
-run_agent_turn() {
+invoke_agent() {
   local prompt="$1" do_resume="$2" cmd="${GTD_LOOP_AGENT_CMD:-}"
   if [[ -z "$cmd" ]]; then
     cmd='claude -p "$GTD_LOOP_PROMPT"'
@@ -379,6 +416,33 @@ run_agent_turn() {
     >>"${GTD_LOOP_LOG:-/dev/null}" 2>&1
 }
 
+# run_agent_turn <prompt> <resume> — invoke_agent, with one recovery: a
+# resumed turn (do_resume == 1) that fails AND whose output carries the
+# missing-session signature (session_gone_since) means the marker's session no
+# longer exists on disk. Rather than failing the turn (and every turn after
+# it, since the dead id would just be resumed again), mint a fresh session,
+# rewrite $memory_marker with it — the self-healing part, so a later launch
+# doesn't repeat this — and retry the SAME prompt once with resume off. $resume
+# and $session_id are the enclosing iteration's globals; recovery rewrites them
+# too, so a later validate-gate re-prompt in the same turn resumes the newly
+# pinned session. Blind to the failure mode when session_gone_since can't tell
+# (no log configured): a genuine agent failure then correctly propagates.
+run_agent_turn() {
+  local prompt="$1" do_resume="$2" offset status=0
+  offset="$(log_offset)"
+  invoke_agent "$prompt" "$do_resume" && return 0
+  status=$?
+  if [[ "$do_resume" == "1" ]] && session_gone_since "$offset"; then
+    emit_warn "the remembered agent session for '$memory' is gone — continuing in a fresh session (this turn starts without its previous context)"
+    session_id="$(new_session_id)"
+    resume=0
+    printf '%s\n%s\n' "$memory" "$session_id" >"$memory_marker"
+    invoke_agent "$prompt" 0
+    return $?
+  fi
+  return $status
+}
+
 # The furthest commit already reported to the terminal by report_commits (see
 # its own comment) — a global high-water mark rather than a per-beat
 # head_before, so a review checkout window's HEAD rewind between beats never
@@ -528,7 +592,7 @@ $next_out"
       resume=1
       session_id="$prev_session"
     else
-      session_id="$(uuidgen 2>/dev/null || cat /proc/sys/kernel/random/uuid 2>/dev/null || echo "")"
+      session_id="$(new_session_id)"
     fi
     printf '%s\n%s\n' "$memory" "$session_id" >"$memory_marker"
   else

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.2.1",
+  "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": {