gsd-pi 2.41.0 → 2.42.0-dev.1df898f

package/packages/pi-coding-agent/src/modes/interactive/components/login-dialog.ts

@@ -1,7 +1,7 @@
 // GSD Login Dialog Component — OAuth login flow UI
 // Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 import { getOAuthProviders } from "@gsd/pi-ai/oauth";
-import { Container, type Focusable, getEditorKeybindings, Input, Spacer, Text, type TUI } from "@gsd/pi-tui";
+import { Container, type Focusable, getEditorKeybindings, Input, Spacer, Text, truncateToWidth, type TUI } from "@gsd/pi-tui";
 import { execFile } from "child_process";
 import { theme } from "../theme/theme.js";
 import { DynamicBorder } from "./dynamic-border.js";
@@ -121,21 +121,25 @@ export class LoginDialogComponent extends Container implements Focusable {
 	showAuth(url: string, instructions?: string): void {
 		this.contentContainer.clear();
 		this.contentContainer.addChild(new Spacer(1));
-		this.contentContainer.addChild(new Text(theme.fg("accent", url), 1, 0));
+
+		// Truncate the visible URL text so it never wraps (which would break
+		// the OSC 8 hyperlink). The full URL is still the link target.
+		const maxUrlWidth = Math.max(20, this.tui.terminal.columns - 4);
+		const displayUrl = truncateToWidth(url, maxUrlWidth);
+		const urlLink = `\x1b]8;;${url}\x07${theme.fg("accent", displayUrl)}\x1b]8;;\x07`;
+		this.contentContainer.addChild(new Text(urlLink, 1, 0));
 
 		const clickHint = process.platform === "darwin" ? "Cmd+click to open" : "Ctrl+click to open";
-		const hyperlink = `\x1b]8;;${url}\x07${clickHint}\x1b]8;;\x07`;
-		this.contentContainer.addChild(new Text(theme.fg("dim", hyperlink), 1, 0));
+		this.contentContainer.addChild(new Text(theme.fg("dim", clickHint), 1, 0));
 
 		if (instructions) {
 			this.contentContainer.addChild(new Spacer(1));
 			this.contentContainer.addChild(new Text(theme.fg("warning", instructions), 1, 0));
 		}
 
-		// Try to open browser — on Windows, `start` needs an empty title arg
-		// so it treats the URL as a target, not a window title
+		// PowerShell's Start-Process handles URLs with '&' safely; cmd /c start does not.
 		if (process.platform === "win32") {
-			execFile("cmd", ["/c", "start", "", url], () => {});
+			execFile("powershell", ["-c", `Start-Process '${url.replace(/'/g, "''")}'`], () => {});
 		} else {
 			const openCmd = process.platform === "darwin" ? "open" : "xdg-open";
 			execFile(openCmd, [url], () => {});

package/packages/pi-coding-agent/src/modes/interactive/interactive-mode.ts

@@ -1519,6 +1519,13 @@ export class InteractiveMode {
 		options: string[],
 		opts?: ExtensionUIDialogOptions,
 	): Promise<string | undefined> {
+		// If a previous selector is still active, dispose it before creating a
+		// new one.  This avoids leaking the previous promise and DOM state when
+		// showExtensionSelector is called rapidly.
+		if (this.extensionSelector) {
+			this.hideExtensionSelector();
+		}
+
 		return new Promise((resolve) => {
 			if (opts?.signal?.aborted) {
 				resolve(undefined);
@@ -2321,23 +2328,34 @@ export class InteractiveMode {
 	}
 
 	private handleCtrlZ(): void {
+		// On Windows, SIGTSTP doesn't exist - Ctrl+Z is not supported
+		if (process.platform === "win32") {
+			return;
+		}
+
 		// Ignore SIGINT while suspended so Ctrl+C in the terminal does not
 		// kill the backgrounded process. The handler is removed on resume.
 		const ignoreSigint = () => {};
 		process.on("SIGINT", ignoreSigint);
 
-		// Set up handler to restore TUI when resumed
-		process.once("SIGCONT", () => {
-			process.removeListener("SIGINT", ignoreSigint);
-			this.ui.start();
-			this.ui.requestRender(true);
-		});
+		try {
+			// Set up handler to restore TUI when resumed
+			process.once("SIGCONT", () => {
+				process.removeListener("SIGINT", ignoreSigint);
+				this.ui.start();
+				this.ui.requestRender(true);
+			});
 
-		// Stop the TUI (restore terminal to normal mode)
-		this.ui.stop();
+			// Stop the TUI (restore terminal to normal mode)
+			this.ui.stop();
 
-		// Send SIGTSTP to process group (pid=0 means all processes in group)
-		process.kill(0, "SIGTSTP");
+			// Send SIGTSTP to process group (pid=0 means all processes in group)
+			process.kill(0, "SIGTSTP");
+		} catch {
+			// If suspend fails (e.g. SIGTSTP not supported), ensure the
+			// SIGINT listener doesn't leak.
+			process.removeListener("SIGINT", ignoreSigint);
+		}
 	}
 
 	private async handleFollowUp(): Promise<void> {
@@ -2455,7 +2473,14 @@ export class InteractiveMode {
 		// Determine editor (respect $VISUAL, then $EDITOR)
 		const editorCmd = process.env.VISUAL || process.env.EDITOR;
 		if (!editorCmd) {
-			this.showWarning("No editor configured. Set $VISUAL or $EDITOR environment variable.");
+			let msg = "No editor configured. Set $VISUAL or $EDITOR environment variable.";
+			if (process.env.TERM_PROGRAM === "iTerm.app") {
+				msg +=
+					"\n\nTip: If you meant to open the GSD dashboard (Ctrl+Alt+G), set Left Option Key to" +
+					" \"Esc+\" in iTerm2 → Profiles → Keys. With the default \"Normal\" setting," +
+					" Ctrl+Alt+G sends Ctrl+G instead.";
+			}
+			this.showWarning(msg);
 			return;
 		}
 

package/pkg/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glittercowboy/gsd",
-  "version": "2.41.0",
+  "version": "2.42.0",
   "piConfig": {
     "name": "gsd",
     "configDir": ".gsd"

package/src/resources/extensions/async-jobs/async-bash-timeout.test.ts

@@ -0,0 +1,122 @@
+/**
+ * async-bash-timeout.test.ts — Tests for async_bash timeout behavior.
+ *
+ * Reproduces issue #2186: when an async bash job exceeds its timeout and
+ * the child process ignores SIGTERM, the promise hangs indefinitely.
+ * The fix adds a SIGKILL fallback and a hard deadline that force-resolves
+ * the promise so execution can continue.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createAsyncBashTool } from "./async-bash-tool.ts";
+import { AsyncJobManager } from "./job-manager.ts";
+
+function getTextFromResult(result: { content: Array<{ type: string; text?: string }> }): string {
+	return result.content.map((c) => c.text ?? "").join("\n");
+}
+
+const noopSignal = new AbortController().signal;
+
+test("async_bash with timeout resolves even if process ignores SIGTERM", async () => {
+	const manager = new AsyncJobManager();
+	const tool = createAsyncBashTool(() => manager, () => process.cwd());
+
+	// Start a job that traps SIGTERM (ignores it), with a 2s timeout.
+	// The process installs a SIGTERM trap and sleeps for 60s.
+	// Before the fix, this would hang forever because SIGTERM is ignored
+	// and the close event never fires.
+	const result = await tool.execute(
+		"tc-timeout",
+		{
+			command: "trap '' TERM; sleep 60",
+			timeout: 2,
+			label: "sigterm-resistant",
+		},
+		noopSignal,
+		() => {},
+		undefined as never,
+	);
+
+	const text = getTextFromResult(result);
+	assert.match(text, /sigterm-resistant/);
+
+	const jobId = text.match(/\*\*(bg_[a-f0-9]+)\*\*/)?.[1];
+	assert.ok(jobId, "Should have returned a job ID");
+
+	// Now await the job — it should resolve within a reasonable time
+	// (timeout 2s + SIGKILL grace 5s + buffer = well under 15s)
+	const start = Date.now();
+	const job = manager.getJob(jobId)!;
+	assert.ok(job, "Job should exist");
+
+	await Promise.race([
+		job.promise,
+		new Promise<never>((_, reject) => {
+			const t = setTimeout(() => reject(new Error(
+				`Job promise hung for ${Date.now() - start}ms — ` +
+				`this is the bug from issue #2186: timeout hangs indefinitely`,
+			)), 15_000);
+			if (typeof t === "object" && "unref" in t) t.unref();
+		}),
+	]);
+
+	const elapsed = Date.now() - start;
+	// Should have resolved well within 15s (timeout 2s + kill grace ~5s)
+	assert.ok(elapsed < 15_000, `Job took ${elapsed}ms — expected <15s`);
+
+	// Job should have completed (resolved, not rejected) with timeout message
+	assert.ok(
+		job.status === "completed" || job.status === "failed",
+		`Job status should be completed or failed, got: ${job.status}`,
+	);
+
+	if (job.status === "completed") {
+		assert.ok(
+			job.resultText?.includes("timed out") || job.resultText?.includes("Timed out"),
+			`Result should mention timeout, got: ${job.resultText}`,
+		);
+	}
+
+	manager.shutdown();
+});
+
+test("async_bash with timeout resolves normally when process exits on SIGTERM", async () => {
+	const manager = new AsyncJobManager();
+	const tool = createAsyncBashTool(() => manager, () => process.cwd());
+
+	// Start a normal sleep that will die on SIGTERM, with a 1s timeout
+	const result = await tool.execute(
+		"tc-normal-timeout",
+		{
+			command: "sleep 60",
+			timeout: 1,
+			label: "normal-timeout",
+		},
+		noopSignal,
+		() => {},
+		undefined as never,
+	);
+
+	const text = getTextFromResult(result);
+	const jobId = text.match(/\*\*(bg_[a-f0-9]+)\*\*/)?.[1];
+	assert.ok(jobId, "Should have returned a job ID");
+
+	const job = manager.getJob(jobId)!;
+	const start = Date.now();
+
+	await Promise.race([
+		job.promise,
+		new Promise<never>((_, reject) => {
+			const t = setTimeout(() => reject(new Error("Job hung")), 10_000);
+			if (typeof t === "object" && "unref" in t) t.unref();
+		}),
+	]);
+
+	const elapsed = Date.now() - start;
+	assert.ok(elapsed < 5_000, `Expected quick resolution after SIGTERM, took ${elapsed}ms`);
+	assert.equal(job.status, "completed");
+	assert.ok(job.resultText?.includes("timed out"), `Should mention timeout: ${job.resultText}`);
+
+	manager.shutdown();
+});

package/src/resources/extensions/async-jobs/async-bash-tool.ts

@@ -109,6 +109,10 @@ function executeBashInBackground(
 	timeout?: number,
 ): Promise<string> {
 	return new Promise<string>((resolve, reject) => {
+		let settled = false;
+		const safeResolve = (value: string) => { if (!settled) { settled = true; resolve(value); } };
+		const safeReject = (err: unknown) => { if (!settled) { settled = true; reject(err); } };
+
 		const { shell, args } = getShellConfig();
 		const resolvedCommand = sanitizeCommand(command);
 
@@ -121,11 +125,39 @@ function executeBashInBackground(
 
 		let timedOut = false;
 		let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+		let sigkillHandle: ReturnType<typeof setTimeout> | undefined;
+		let hardDeadlineHandle: ReturnType<typeof setTimeout> | undefined;
+
+		/** Grace period (ms) between SIGTERM and SIGKILL. */
+		const SIGKILL_GRACE_MS = 5_000;
+		/** Hard deadline (ms) after SIGKILL to force-resolve the promise. */
+		const HARD_DEADLINE_MS = 3_000;
 
 		if (timeout !== undefined && timeout > 0) {
 			timeoutHandle = setTimeout(() => {
 				timedOut = true;
 				if (child.pid) killTree(child.pid);
+
+				// If the process ignores SIGTERM, escalate to SIGKILL
+				sigkillHandle = setTimeout(() => {
+					if (child.pid) {
+						try { process.kill(-child.pid, "SIGKILL"); } catch { /* ignore */ }
+						try { process.kill(child.pid, "SIGKILL"); } catch { /* ignore */ }
+					}
+
+					// Hard deadline: if even SIGKILL doesn't trigger 'close',
+					// force-resolve so the job doesn't hang forever (#2186).
+					hardDeadlineHandle = setTimeout(() => {
+						const output = Buffer.concat(chunks).toString("utf-8");
+						safeResolve(
+							output
+								? `${output}\n\nCommand timed out after ${timeout} seconds (force-killed)`
+								: `Command timed out after ${timeout} seconds (force-killed)`,
+						);
+					}, HARD_DEADLINE_MS);
+					if (typeof hardDeadlineHandle === "object" && "unref" in hardDeadlineHandle) hardDeadlineHandle.unref();
+				}, SIGKILL_GRACE_MS);
+				if (typeof sigkillHandle === "object" && "unref" in sigkillHandle) sigkillHandle.unref();
 			}, timeout * 1000);
 		}
 
@@ -168,24 +200,28 @@ function executeBashInBackground(
 
 		child.on("error", (err) => {
 			if (timeoutHandle) clearTimeout(timeoutHandle);
+			if (sigkillHandle) clearTimeout(sigkillHandle);
+			if (hardDeadlineHandle) clearTimeout(hardDeadlineHandle);
 			signal.removeEventListener("abort", onAbort);
-			reject(err);
+			safeReject(err);
 		});
 
 		child.on("close", (code) => {
 			if (timeoutHandle) clearTimeout(timeoutHandle);
+			if (sigkillHandle) clearTimeout(sigkillHandle);
+			if (hardDeadlineHandle) clearTimeout(hardDeadlineHandle);
 			signal.removeEventListener("abort", onAbort);
 			if (spillStream) spillStream.end();
 
 			if (signal.aborted) {
 				const output = Buffer.concat(chunks).toString("utf-8");
-				resolve(output ? `${output}\n\nCommand aborted` : "Command aborted");
+				safeResolve(output ? `${output}\n\nCommand aborted` : "Command aborted");
 				return;
 			}
 
 			if (timedOut) {
 				const output = Buffer.concat(chunks).toString("utf-8");
-				resolve(output ? `${output}\n\nCommand timed out after ${timeout} seconds` : `Command timed out after ${timeout} seconds`);
+				safeResolve(output ? `${output}\n\nCommand timed out after ${timeout} seconds` : `Command timed out after ${timeout} seconds`);
 				return;
 			}
 
@@ -208,7 +244,7 @@ function executeBashInBackground(
 				text += `\n\nCommand exited with code ${code}`;
 			}
 
-			resolve(text);
+			safeResolve(text);
 		});
 	});
 }

package/src/resources/extensions/async-jobs/await-tool.test.ts

@@ -118,3 +118,50 @@ test("await_job returns not-found message for invalid job IDs", async () => {
 
 	manager.shutdown();
 });
+
+test("await_job marks jobs as awaited to suppress follow-up delivery (#2248)", async () => {
+	const followUps: string[] = [];
+	const manager = new AsyncJobManager({
+		onJobComplete: (job) => {
+			if (!job.awaited) followUps.push(job.id);
+		},
+	});
+	const tool = createAwaitTool(() => manager);
+
+	// Register a job that completes in 50ms
+	const jobId = manager.register("bash", "awaited-job", async () => {
+		return new Promise<string>((resolve) => setTimeout(() => resolve("result"), 50));
+	});
+
+	// await_job consumes the result — should mark as awaited before promise resolves
+	await tool.execute("tc7", { jobs: [jobId] }, noopSignal, () => {}, undefined as never);
+
+	// Give the onJobComplete callback a tick to fire
+	await new Promise((r) => setTimeout(r, 50));
+
+	assert.equal(followUps.length, 0, "onJobComplete should not deliver follow-up for awaited jobs");
+
+	manager.shutdown();
+});
+
+test("unawaited jobs still get follow-up delivery (#2248)", async () => {
+	const followUps: string[] = [];
+	const manager = new AsyncJobManager({
+		onJobComplete: (job) => {
+			if (!job.awaited) followUps.push(job.id);
+		},
+	});
+
+	// Register a fire-and-forget job
+	const jobId = manager.register("bash", "fire-and-forget", async () => "done");
+	const job = manager.getJob(jobId)!;
+	await job.promise;
+
+	// Give the callback a tick
+	await new Promise((r) => setTimeout(r, 50));
+
+	assert.equal(followUps.length, 1, "onJobComplete should deliver follow-up for unawaited jobs");
+	assert.equal(followUps[0], jobId);
+
+	manager.shutdown();
+});

package/src/resources/extensions/async-jobs/await-tool.ts

@@ -66,6 +66,11 @@ export function createAwaitTool(getManager: () => AsyncJobManager): ToolDefiniti
 				}
 			}
 
+			// Mark all watched jobs as awaited upfront so the onJobComplete
+			// callback (which fires synchronously in the promise .then()) knows
+			// to suppress the follow-up message.
+			for (const j of watched) j.awaited = true;
+
 			// If all watched jobs are already done, return immediately
 			const running = watched.filter((j) => j.status === "running");
 			if (running.length === 0) {

package/src/resources/extensions/async-jobs/index.ts

@@ -42,6 +42,7 @@ export default function AsyncJobs(pi: ExtensionAPI) {
 
 		manager = new AsyncJobManager({
 			onJobComplete: (job) => {
+				if (job.awaited) return;
 				const statusEmoji = job.status === "completed" ? "done" : "error";
 				const elapsed = ((Date.now() - job.startTime) / 1000).toFixed(1);
 				const output = job.status === "completed"

package/src/resources/extensions/async-jobs/job-manager.ts

@@ -22,6 +22,8 @@ export interface Job {
 	promise: Promise<void>;
 	resultText?: string;
 	errorText?: string;
+	/** Set by await_job when results are consumed. Suppresses follow-up delivery. */
+	awaited?: boolean;
 }
 
 export interface JobManagerOptions {

package/src/resources/extensions/gsd/auto/loop-deps.ts

@@ -19,6 +19,7 @@ import type {
 import type { DispatchAction } from "../auto-dispatch.js";
 import type { WorktreeResolver } from "../worktree-resolver.js";
 import type { CmuxLogLevel } from "../../cmux/index.js";
+import type { JournalEntry } from "../journal.js";
 
 /**
  * Dependencies injected by the caller (auto.ts startAuto) so autoLoop
@@ -102,13 +103,12 @@ export interface LoopDeps {
     basePath: string,
     milestoneId: string,
     roadmapContent: string,
-  ) => { pushed: boolean };
+  ) => { pushed: boolean; codeFilesChanged: boolean };
   teardownAutoWorktree: (basePath: string, milestoneId: string) => void;
   createAutoWorktree: (basePath: string, milestoneId: string) => string;
   captureIntegrationBranch: (
     basePath: string,
     mid: string,
-    opts?: { commitDocs?: boolean },
   ) => void;
   getIsolationMode: () => string;
   getCurrentBranch: (basePath: string) => string;
@@ -285,4 +285,7 @@ export interface LoopDeps {
 
   // Session manager
   getSessionFile: (ctx: ExtensionContext) => string;
+
+  // Journal
+  emitJournalEvent: (entry: JournalEntry) => void;
 }

package/src/resources/extensions/gsd/auto/loop.ts

@@ -9,6 +9,7 @@
 
 import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 
+import { randomUUID } from "node:crypto";
 import type { AutoSession, SidecarItem } from "./session.js";
 import type { LoopDeps } from "./loop-deps.js";
 import {
@@ -27,6 +28,7 @@ import {
 } from "./phases.js";
 import { debugLog } from "../debug-logger.js";
 import { isInfrastructureError } from "./infra-errors.js";
+import { resolveEngine } from "../engine-resolver.js";
 
 /**
  * Main auto-mode execution loop. Iterates: derive → dispatch → guards →
@@ -51,6 +53,11 @@ export async function autoLoop(
     iteration++;
     debugLog("autoLoop", { phase: "loop-top", iteration });
 
+    // ── Journal: per-iteration flow grouping ──
+    const flowId = randomUUID();
+    let seqCounter = 0;
+    const nextSeq = () => ++seqCounter;
+
     if (iteration > MAX_LOOP_ITERATIONS) {
       debugLog("autoLoop", {
         phase: "exit",
@@ -84,6 +91,7 @@ export async function autoLoop(
           unitType: sidecarItem.unitType,
           unitId: sidecarItem.unitId,
         });
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "sidecar-dequeue", data: { kind: sidecarItem.kind, unitType: sidecarItem.unitType, unitId: sidecarItem.unitId } });
       }
 
       const sessionLockBase = deps.lockBase();
@@ -106,9 +114,100 @@ export async function autoLoop(
         }
       }
 
-      const ic: IterationContext = { ctx, pi, s, deps, prefs, iteration };
+      const ic: IterationContext = { ctx, pi, s, deps, prefs, iteration, flowId, nextSeq };
+      deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-start", data: { iteration } });
       let iterData: IterationData;
 
+      // ── Custom engine path ──────────────────────────────────────────────
+      // When activeEngineId is a non-dev value, bypass runPreDispatch and
+      // runDispatch entirely — the custom engine drives its own state via
+      // GRAPH.yaml. Shares runGuards and runUnitPhase with the dev path.
+      // After unit execution, verifies then reconciles via the engine layer.
+      //
+      // GSD_ENGINE_BYPASS=1 skips the engine layer entirely — falls through
+      // to the dev path below.
+      if (s.activeEngineId != null && s.activeEngineId !== "dev" && !sidecarItem && process.env.GSD_ENGINE_BYPASS !== "1") {
+        debugLog("autoLoop", { phase: "custom-engine-derive", iteration, engineId: s.activeEngineId });
+
+        const { engine, policy } = resolveEngine({
+          activeEngineId: s.activeEngineId,
+          activeRunDir: s.activeRunDir,
+        });
+
+        const engineState = await engine.deriveState(s.basePath);
+        if (engineState.isComplete) {
+          await deps.stopAuto(ctx, pi, "Workflow complete");
+          break;
+        }
+
+        debugLog("autoLoop", { phase: "custom-engine-dispatch", iteration });
+        const dispatch = await engine.resolveDispatch(engineState, { basePath: s.basePath });
+
+        if (dispatch.action === "stop") {
+          await deps.stopAuto(ctx, pi, dispatch.reason ?? "Engine stopped");
+          break;
+        }
+        if (dispatch.action === "skip") {
+          continue;
+        }
+
+        // dispatch.action === "dispatch"
+        const step = dispatch.step!;
+        const gsdState = await deps.deriveState(s.basePath);
+
+        iterData = {
+          unitType: step.unitType,
+          unitId: step.unitId,
+          prompt: step.prompt,
+          finalPrompt: step.prompt,
+          pauseAfterUatDispatch: false,
+          observabilityIssues: [],
+          state: gsdState,
+          mid: s.currentMilestoneId ?? "workflow",
+          midTitle: "Workflow",
+          isRetry: false,
+          previousTier: undefined,
+        };
+
+        // ── 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") break;
+
+        // ── Unit execution (shared with dev path) ──
+        const unitPhaseResult = await runUnitPhase(ic, iterData, loopState);
+        if (unitPhaseResult.action === "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);
+          break;
+        }
+        if (verifyResult === "retry") {
+          debugLog("autoLoop", { phase: "custom-engine-verify-retry", iteration, unitId: iterData.unitId });
+          continue;
+        }
+
+        // Verification passed — mark step complete
+        debugLog("autoLoop", { phase: "custom-engine-reconcile", iteration, unitId: iterData.unitId });
+        await engine.reconcile(engineState, {
+          unitType: iterData.unitType,
+          unitId: iterData.unitId,
+          startedAt: s.currentUnit?.startedAt ?? Date.now(),
+          finishedAt: Date.now(),
+        });
+
+        deps.clearUnitTimeout();
+        consecutiveErrors = 0;
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
+        debugLog("autoLoop", { phase: "iteration-complete", iteration });
+        continue;
+      }
+
       if (!sidecarItem) {
         // ── Phase 1: Pre-dispatch ─────────────────────────────────────────
         const preDispatchResult = await runPreDispatch(ic, loopState);
@@ -153,6 +252,7 @@ export async function autoLoop(
       if (finalizeResult.action === "continue") continue;
 
       consecutiveErrors = 0; // Iteration completed successfully
+      deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
       debugLog("autoLoop", { phase: "iteration-complete", iteration });
     } catch (loopErr) {
       // ── Blanket catch: absorb unexpected exceptions, apply graduated recovery ──