gsd-pi 2.74.0 → 2.75.0-dev.063e5a3

package/dist/cli.js

@@ -141,6 +141,91 @@ if (cliFlags.messages[0] === 'update') {
     await runUpdate();
     process.exit(0);
 }
+// ---------------------------------------------------------------------------
+// Graph subcommand — `gsd graph build|status|query|diff`
+// ---------------------------------------------------------------------------
+if (cliFlags.messages[0] === 'graph') {
+    const sub = cliFlags.messages[1];
+    const { buildGraph, writeGraph, graphStatus, graphQuery, graphDiff, resolveGsdRoot } = await import('@gsd-build/mcp-server');
+    const projectDir = process.cwd();
+    const gsdRoot = resolveGsdRoot(projectDir);
+    if (!sub || sub === 'build') {
+        try {
+            const graph = await buildGraph(projectDir);
+            await writeGraph(gsdRoot, graph);
+            process.stdout.write(`Graph built: ${graph.nodes.length} nodes, ${graph.edges.length} edges\n`);
+        }
+        catch (err) {
+            process.stderr.write(`[gsd] graph build failed: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+    }
+    else if (sub === 'status') {
+        try {
+            const result = await graphStatus(projectDir);
+            if (!result.exists) {
+                process.stdout.write('Graph: not built yet. Run: gsd graph build\n');
+            }
+            else {
+                process.stdout.write(`Graph status:\n`);
+                process.stdout.write(`  exists:    ${result.exists}\n`);
+                process.stdout.write(`  nodes:     ${result.nodeCount}\n`);
+                process.stdout.write(`  edges:     ${result.edgeCount}\n`);
+                process.stdout.write(`  stale:     ${result.stale}\n`);
+                process.stdout.write(`  ageHours:  ${result.ageHours !== undefined ? result.ageHours.toFixed(2) : 'n/a'}\n`);
+                process.stdout.write(`  lastBuild: ${result.lastBuild ?? 'n/a'}\n`);
+            }
+        }
+        catch (err) {
+            process.stderr.write(`[gsd] graph status failed: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+    }
+    else if (sub === 'query') {
+        const term = cliFlags.messages[2];
+        if (!term) {
+            process.stderr.write('Usage: gsd graph query <term>\n');
+            process.exit(1);
+        }
+        try {
+            const result = await graphQuery(projectDir, term);
+            if (result.nodes.length === 0) {
+                process.stdout.write(`No nodes found for term: "${term}"\n`);
+            }
+            else {
+                process.stdout.write(`Query results for "${term}" (${result.nodes.length} nodes, ${result.edges.length} edges):\n`);
+                for (const node of result.nodes) {
+                    process.stdout.write(`  [${node.type}] ${node.label} (${node.confidence})\n`);
+                }
+            }
+        }
+        catch (err) {
+            process.stderr.write(`[gsd] graph query failed: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+    }
+    else if (sub === 'diff') {
+        try {
+            const result = await graphDiff(projectDir);
+            process.stdout.write(`Graph diff:\n`);
+            process.stdout.write(`  nodes added:    ${result.nodes.added.length}\n`);
+            process.stdout.write(`  nodes removed:  ${result.nodes.removed.length}\n`);
+            process.stdout.write(`  nodes changed:  ${result.nodes.changed.length}\n`);
+            process.stdout.write(`  edges added:    ${result.edges.added.length}\n`);
+            process.stdout.write(`  edges removed:  ${result.edges.removed.length}\n`);
+        }
+        catch (err) {
+            process.stderr.write(`[gsd] graph diff failed: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+    }
+    else {
+        process.stderr.write(`Unknown graph command: ${sub}\n`);
+        process.stderr.write('Commands: build, status, query <term>, diff\n');
+        process.exit(1);
+    }
+    process.exit(0);
+}
 exitIfManagedResourcesAreNewer(agentDir);
 // Early TTY check — must come before heavy initialization to avoid dangling
 // handles that prevent process.exit() from completing promptly.

package/dist/headless-query.js

@@ -33,7 +33,9 @@ async function loadExtensionModules() {
     const dispatchModule = await jiti.import(gsdExtensionPath('auto-dispatch.ts'), {});
     const sessionModule = await jiti.import(gsdExtensionPath('session-status-io.ts'), {});
     const prefsModule = await jiti.import(gsdExtensionPath('preferences.ts'), {});
+    const autoStartModule = await jiti.import(gsdExtensionPath('auto-start.ts'), {});
     return {
+        openProjectDbIfPresent: autoStartModule.openProjectDbIfPresent,
         deriveState: stateModule.deriveState,
         resolveDispatch: dispatchModule.resolveDispatch,
         readAllSessionStatuses: sessionModule.readAllSessionStatuses,
@@ -42,7 +44,8 @@ async function loadExtensionModules() {
 }
 // ─── Implementation ─────────────────────────────────────────────────────────
 export async function handleQuery(basePath) {
-    const { deriveState, resolveDispatch, readAllSessionStatuses, loadEffectiveGSDPreferences } = await loadExtensionModules();
+    const { openProjectDbIfPresent, deriveState, resolveDispatch, readAllSessionStatuses, loadEffectiveGSDPreferences, } = await loadExtensionModules();
+    await openProjectDbIfPresent(basePath);
     const state = await deriveState(basePath);
     // Derive next dispatch action
     let next;

package/dist/help-text.js

@@ -84,6 +84,28 @@ const SUBCOMMAND_HELP = {
         '  gsd worktree remove old-branch      Remove a specific worktree',
         '  gsd worktree remove old-branch --force  Remove even with unmerged changes',
     ].join('\n'),
+    graph: [
+        'Usage: gsd graph <subcommand> [options]',
+        '',
+        'Manage the GSD project knowledge graph. Reads .gsd/ artifacts and builds',
+        'a queryable graph of milestones, slices, tasks, rules, patterns, and lessons.',
+        '',
+        'Subcommands:',
+        '  build   Parse .gsd/ artifacts (STATE.md, milestone ROADMAPs, slice PLANs,',
+        '          KNOWLEDGE.md) and write .gsd/graphs/graph.json atomically.',
+        '  query   Search graph nodes by term (BFS from seed matches, budget-trimmed).',
+        '          Returns matching nodes and reachable edges within the token budget.',
+        '  status  Show whether graph.json exists, its age, node/edge counts, and',
+        '          whether it is stale (built more than 24 hours ago).',
+        '  diff    Compare current graph.json with .last-build-snapshot.json.',
+        '          Returns added, removed, and changed nodes and edges.',
+        '',
+        'Examples:',
+        '  gsd graph build                        Build the graph from .gsd/ artifacts',
+        '  gsd graph status                       Check graph age and node/edge counts',
+        '  gsd graph query auth                   Find nodes related to "auth"',
+        '  gsd graph diff                         Show changes since last snapshot',
+    ].join('\n'),
     headless: [
         'Usage: gsd headless [flags] [command] [args...]',
         '',
@@ -165,6 +187,7 @@ export function printHelp(version) {
     process.stdout.write('  worktree <cmd>           Manage worktrees (list, merge, clean, remove)\n');
     process.stdout.write('  auto [args]              Run auto-mode without TUI (pipeable)\n');
     process.stdout.write('  headless [cmd] [args]    Run /gsd commands without TUI (default: auto)\n');
+    process.stdout.write('  graph <subcommand>       Manage knowledge graph (build, query, status, diff)\n');
     process.stdout.write('\nRun gsd <subcommand> --help for subcommand-specific help.\n');
 }
 export function printSubcommandHelp(subcommand, version) {

package/dist/resources/extensions/gsd/activity-log.js

@@ -13,6 +13,8 @@ import { join } from "node:path";
 import { GSDError, GSD_IO_ERROR } from "./errors.js";
 const SEQ_PREFIX_RE = /^(\d+)-/;
 import { gsdRoot } from "./paths.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
+import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
 const activityLogState = new Map();
 /**
  * Clear accumulated activity log state (#611).
@@ -110,6 +112,20 @@ export function saveActivityLog(ctx, basePath, unitType, unitId) {
         }
         state.nextSeq += 1;
         state.lastSnapshotKeyByUnit.set(unitKey, key);
+        if (isUnifiedAuditEnabled()) {
+            emitUokAuditEvent(basePath, buildAuditEnvelope({
+                traceId: `activity:${unitType}:${unitId}`,
+                turnId: unitId,
+                category: "execution",
+                type: "activity-log-saved",
+                payload: {
+                    unitType,
+                    unitId,
+                    filePath,
+                    entryCount: entries.length,
+                },
+            }));
+        }
         return filePath;
     }
     catch (e) {

package/dist/resources/extensions/gsd/auto/detect-stuck.js

@@ -3,6 +3,7 @@
  *
  * Leaf node in the import DAG.
  */
+import { summarizeLogs } from "../workflow-logger.js";
 /**
  * Pattern matching ENOENT errors with a file path.
  * Matches: "ENOENT: no such file or directory, access '/path/to/file'"
@@ -22,13 +23,19 @@ const ENOENT_PATH_RE = /ENOENT[^']*'([^']+)'/;
 export function detectStuck(window) {
     if (window.length < 2)
         return null;
+    // Peek (not drain) the workflow-logger buffer so stuck reasons can surface
+    // the underlying diagnostic context (projection failures, DB degradations,
+    // reconcile warnings) that usually explains *why* the loop is stuck. The
+    // auto-loop's finalize step owns the buffer lifecycle — this is read-only.
+    const loggerSummary = summarizeLogs();
+    const suffix = loggerSummary ? ` — ${loggerSummary}` : "";
     const last = window[window.length - 1];
     const prev = window[window.length - 2];
     // Rule 1: Same error repeated consecutively
     if (last.error && prev.error && last.error === prev.error) {
         return {
             stuck: true,
-            reason: `Same error repeated: ${last.error.slice(0, 200)}`,
+            reason: `Same error repeated: ${last.error.slice(0, 200)}${suffix}`,
         };
     }
     // Rule 2: Same unit 3+ consecutive times
@@ -37,7 +44,7 @@ export function detectStuck(window) {
         if (lastThree.every((u) => u.key === last.key)) {
             return {
                 stuck: true,
-                reason: `${last.key} derived 3 consecutive times without progress`,
+                reason: `${last.key} derived 3 consecutive times without progress${suffix}`,
             };
         }
     }
@@ -49,7 +56,7 @@ export function detectStuck(window) {
             w[0].key !== w[1].key) {
             return {
                 stuck: true,
-                reason: `Oscillation detected: ${w[0].key} ↔ ${w[1].key}`,
+                reason: `Oscillation detected: ${w[0].key} ↔ ${w[1].key}${suffix}`,
             };
         }
     }
@@ -67,7 +74,7 @@ export function detectStuck(window) {
         if (count >= 2) {
             return {
                 stuck: true,
-                reason: `Missing file referenced twice: ${filePath} (ENOENT)`,
+                reason: `Missing file referenced twice: ${filePath} (ENOENT)${suffix}`,
             };
         }
         enoentPaths.set(filePath, count);

package/dist/resources/extensions/gsd/auto/loop.js

@@ -15,6 +15,8 @@ import { isInfrastructureError, isTransientCooldownError, getCooldownRetryAfterM
 import { resolveEngine } from "../engine-resolver.js";
 import { logWarning } from "../workflow-logger.js";
 import { gsdRoot } from "../paths.js";
+import { resolveUokFlags } from "../uok/flags.js";
+import { scheduleSidecarQueue } from "../uok/execution-graph.js";
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 // ── Stuck detection persistence (#3704) ──────────────────────────────────
@@ -104,6 +106,40 @@ export async function autoLoop(ctx, pi, s, deps) {
         const flowId = randomUUID();
         let seqCounter = 0;
         const nextSeq = () => ++seqCounter;
+        const turnId = randomUUID();
+        s.currentTraceId = flowId;
+        s.currentTurnId = turnId;
+        const turnStartedAt = new Date().toISOString();
+        let observedUnitType;
+        let observedUnitId;
+        let turnFinished = false;
+        const finishTurn = (status, failureClass = "none", error) => {
+            if (turnFinished)
+                return;
+            turnFinished = true;
+            deps.uokObserver?.onTurnResult({
+                traceId: flowId,
+                turnId,
+                iteration,
+                unitType: observedUnitType,
+                unitId: observedUnitId,
+                status,
+                failureClass,
+                phaseResults: [],
+                error,
+                startedAt: turnStartedAt,
+                finishedAt: new Date().toISOString(),
+            });
+            s.currentTraceId = null;
+            s.currentTurnId = null;
+        };
+        deps.uokObserver?.onTurnStart({
+            traceId: flowId,
+            turnId,
+            iteration,
+            basePath: s.basePath,
+            startedAt: turnStartedAt,
+        });
         if (iteration > MAX_LOOP_ITERATIONS) {
             debugLog("autoLoop", {
                 phase: "exit",
@@ -111,6 +147,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 iteration,
             });
             await deps.stopAuto(ctx, pi, `Safety: loop exceeded ${MAX_LOOP_ITERATIONS} iterations — possible runaway`);
+            finishTurn("stopped", "manual-attention", "max-iterations");
             break;
         }
         // ── Memory pressure check (#3331) ──
@@ -123,19 +160,30 @@ export async function autoLoop(ctx, pi, s, deps) {
                 await deps.stopAuto(ctx, pi, `Memory pressure: heap at ${mem.heapMB}MB / ${mem.limitMB}MB (${Math.round(mem.pct * 100)}%). ` +
                     `Stopping gracefully to prevent OOM kill after ${iteration} iterations. ` +
                     `Resume with /gsd auto to continue from where you left off.`);
+                finishTurn("stopped", "timeout", "memory-pressure");
                 break;
             }
         }
         if (!s.cmdCtx) {
             debugLog("autoLoop", { phase: "exit", reason: "no-cmdCtx" });
+            finishTurn("stopped", "manual-attention", "missing-command-context");
             break;
         }
         try {
             // ── Blanket try/catch: one bad iteration must not kill the session
             const prefs = deps.loadEffectiveGSDPreferences()?.preferences;
+            const uokFlags = resolveUokFlags(prefs);
             // ── Check sidecar queue before deriveState ──
             let sidecarItem;
             if (s.sidecarQueue.length > 0) {
+                if (uokFlags.executionGraph && s.sidecarQueue.length > 1) {
+                    try {
+                        s.sidecarQueue = await scheduleSidecarQueue(s.sidecarQueue);
+                    }
+                    catch (err) {
+                        logWarning("dispatch", `sidecar queue scheduling failed: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
                 sidecarItem = s.sidecarQueue.shift();
                 debugLog("autoLoop", {
                     phase: "sidecar-dequeue",
@@ -210,25 +258,49 @@ export async function autoLoop(ctx, pi, s, deps) {
                     isRetry: false,
                     previousTier: undefined,
                 };
+                observedUnitType = iterData.unitType;
+                observedUnitId = iterData.unitId;
                 // ── Progress widget (mirrors dev path in runDispatch) ──
                 deps.updateProgressWidget(ctx, iterData.unitType, iterData.unitId, iterData.state);
                 // ── Guards (shared with dev path) ──
                 const guardsResult = await runGuards(ic, s.currentMilestoneId ?? "workflow");
-                if (guardsResult.action === "break")
+                deps.uokObserver?.onPhaseResult("guard", guardsResult.action, {
+                    unitType: iterData.unitType,
+                    unitId: iterData.unitId,
+                });
+                if (guardsResult.action === "break") {
+                    finishTurn("stopped", "manual-attention", "guard-break");
                     break;
+                }
                 // ── Unit execution (shared with dev path) ──
                 const unitPhaseResult = await runUnitPhase(ic, iterData, loopState);
-                if (unitPhaseResult.action === "break")
+                deps.uokObserver?.onPhaseResult("unit", unitPhaseResult.action, {
+                    unitType: iterData.unitType,
+                    unitId: iterData.unitId,
+                });
+                if (unitPhaseResult.action === "break") {
+                    finishTurn("stopped", "execution", "unit-break");
                     break;
+                }
                 // ── Verify first, then reconcile (only mark complete on pass) ──
                 debugLog("autoLoop", { phase: "custom-engine-verify", iteration, unitId: iterData.unitId });
                 const verifyResult = await policy.verify(iterData.unitType, iterData.unitId, { basePath: s.basePath });
                 if (verifyResult === "pause") {
                     await deps.pauseAuto(ctx, pi);
+                    deps.uokObserver?.onPhaseResult("custom-engine", "pause", {
+                        unitType: iterData.unitType,
+                        unitId: iterData.unitId,
+                    });
+                    finishTurn("paused", "manual-attention", "custom-engine-verify-pause");
                     break;
                 }
                 if (verifyResult === "retry") {
                     debugLog("autoLoop", { phase: "custom-engine-verify-retry", iteration, unitId: iterData.unitId });
+                    deps.uokObserver?.onPhaseResult("custom-engine", "retry", {
+                        unitType: iterData.unitType,
+                        unitId: iterData.unitId,
+                    });
+                    finishTurn("retry");
                     continue;
                 }
                 // Verification passed — mark step complete
@@ -248,37 +320,73 @@ export async function autoLoop(ctx, pi, s, deps) {
                 debugLog("autoLoop", { phase: "iteration-complete", iteration });
                 if (reconcileResult.outcome === "milestone-complete") {
                     await deps.stopAuto(ctx, pi, "Workflow complete");
+                    deps.uokObserver?.onPhaseResult("custom-engine", "milestone-complete", {
+                        unitType: iterData.unitType,
+                        unitId: iterData.unitId,
+                    });
+                    finishTurn("completed");
                     break;
                 }
                 if (reconcileResult.outcome === "pause") {
                     await deps.pauseAuto(ctx, pi);
+                    deps.uokObserver?.onPhaseResult("custom-engine", "pause", {
+                        unitType: iterData.unitType,
+                        unitId: iterData.unitId,
+                    });
+                    finishTurn("paused", "manual-attention");
                     break;
                 }
                 if (reconcileResult.outcome === "stop") {
                     await deps.stopAuto(ctx, pi, reconcileResult.reason ?? "Engine stopped");
+                    deps.uokObserver?.onPhaseResult("custom-engine", "stop", {
+                        unitType: iterData.unitType,
+                        unitId: iterData.unitId,
+                        reason: reconcileResult.reason,
+                    });
+                    finishTurn("stopped", "manual-attention", reconcileResult.reason);
                     break;
                 }
+                deps.uokObserver?.onPhaseResult("custom-engine", "continue", {
+                    unitType: iterData.unitType,
+                    unitId: iterData.unitId,
+                });
+                finishTurn("completed");
                 continue;
             }
             if (!sidecarItem) {
                 // ── Phase 1: Pre-dispatch ─────────────────────────────────────────
                 const preDispatchResult = await runPreDispatch(ic, loopState);
-                if (preDispatchResult.action === "break")
+                deps.uokObserver?.onPhaseResult("pre-dispatch", preDispatchResult.action);
+                if (preDispatchResult.action === "break") {
+                    finishTurn("stopped", "manual-attention", "pre-dispatch-break");
                     break;
-                if (preDispatchResult.action === "continue")
+                }
+                if (preDispatchResult.action === "continue") {
+                    finishTurn("skipped");
                     continue;
+                }
                 const preData = preDispatchResult.data;
                 // ── Phase 2: Guards ───────────────────────────────────────────────
                 const guardsResult = await runGuards(ic, preData.mid);
-                if (guardsResult.action === "break")
+                deps.uokObserver?.onPhaseResult("guard", guardsResult.action);
+                if (guardsResult.action === "break") {
+                    finishTurn("stopped", "manual-attention", "guard-break");
                     break;
+                }
                 // ── Phase 3: Dispatch ─────────────────────────────────────────────
                 const dispatchResult = await runDispatch(ic, preData, loopState);
-                if (dispatchResult.action === "break")
+                deps.uokObserver?.onPhaseResult("dispatch", dispatchResult.action);
+                if (dispatchResult.action === "break") {
+                    finishTurn("stopped", "manual-attention", "dispatch-break");
                     break;
-                if (dispatchResult.action === "continue")
+                }
+                if (dispatchResult.action === "continue") {
+                    finishTurn("skipped");
                     continue;
+                }
                 iterData = dispatchResult.data;
+                observedUnitType = iterData.unitType;
+                observedUnitId = iterData.unitId;
             }
             else {
                 // ── Sidecar path: use values from the sidecar item directly ──
@@ -294,21 +402,46 @@ export async function autoLoop(ctx, pi, s, deps) {
                     midTitle: sidecarState.activeMilestone?.title,
                     isRetry: false, previousTier: undefined,
                 };
+                observedUnitType = iterData.unitType;
+                observedUnitId = iterData.unitId;
+                deps.uokObserver?.onPhaseResult("dispatch", "sidecar", {
+                    unitType: iterData.unitType,
+                    unitId: iterData.unitId,
+                    sidecarKind: sidecarItem.kind,
+                });
             }
             const unitPhaseResult = await runUnitPhase(ic, iterData, loopState, sidecarItem);
-            if (unitPhaseResult.action === "break")
+            deps.uokObserver?.onPhaseResult("unit", unitPhaseResult.action, {
+                unitType: iterData.unitType,
+                unitId: iterData.unitId,
+            });
+            if (unitPhaseResult.action === "break") {
+                finishTurn("stopped", "execution", "unit-break");
                 break;
+            }
             // ── Phase 5: Finalize ───────────────────────────────────────────────
             const finalizeResult = await runFinalize(ic, iterData, loopState, sidecarItem);
-            if (finalizeResult.action === "break")
+            deps.uokObserver?.onPhaseResult("finalize", finalizeResult.action, {
+                unitType: iterData.unitType,
+                unitId: iterData.unitId,
+            });
+            if (finalizeResult.action === "break") {
+                const finalizeFailureClass = finalizeResult.reason === "git-closeout-failure"
+                    ? "git"
+                    : "closeout";
+                finishTurn("stopped", finalizeFailureClass, "finalize-break");
                 break;
-            if (finalizeResult.action === "continue")
+            }
+            if (finalizeResult.action === "continue") {
+                finishTurn("retry");
                 continue;
+            }
             consecutiveErrors = 0; // Iteration completed successfully
             consecutiveCooldowns = 0;
             recentErrorMessages.length = 0;
             deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
             debugLog("autoLoop", { phase: "iteration-complete", iteration });
+            finishTurn("completed");
         }
         catch (loopErr) {
             // ── Blanket catch: absorb unexpected exceptions, apply graduated recovery ──
@@ -330,6 +463,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 });
                 ctx.ui.notify(`Auto-mode stopped: infrastructure error ${infraCode} — ${msg}`, "error");
                 await deps.stopAuto(ctx, pi, `Infrastructure error (${infraCode}): not recoverable by retry`);
+                finishTurn("failed", "execution", msg);
                 break;
             }
             // ── Credential cooldown: wait and retry with bounded budget ──
@@ -358,6 +492,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                     : COOLDOWN_FALLBACK_WAIT_MS;
                 ctx.ui.notify(`Credentials in cooldown (${consecutiveCooldowns}/${MAX_COOLDOWN_RETRIES}) — waiting ${Math.round(waitMs / 1000)}s before retrying.`, "warning");
                 await new Promise(resolve => setTimeout(resolve, waitMs));
+                finishTurn("retry", "timeout", msg);
                 continue; // Retry iteration without incrementing consecutiveErrors
             }
             consecutiveErrors++;
@@ -375,6 +510,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                     .join("\n");
                 ctx.ui.notify(`Auto-mode stopped: ${consecutiveErrors} consecutive iteration failures:\n${errorHistory}`, "error");
                 await deps.stopAuto(ctx, pi, `${consecutiveErrors} consecutive iteration failures`);
+                finishTurn("failed", "execution", msg);
                 break;
             }
             else if (consecutiveErrors === 2) {
@@ -386,6 +522,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 // 1st error: log and retry — transient failures happen
                 ctx.ui.notify(`Iteration error: ${msg}. Retrying.`, "warning");
             }
+            finishTurn("retry", "execution", msg);
         }
     }
     _clearCurrentResolve();