gsd-pi 2.73.1 → 2.74.0-dev.0306a2e

package/dist/onboarding.js

@@ -71,8 +71,8 @@ const OTHER_PROVIDERS = [
 ];
 // ─── Dynamic imports ──────────────────────────────────────────────────────────
 /**
- * Dynamically import @clack/prompts and picocolors.
- * Dynamic import with fallback so the module doesn't crash if they're missing.
+ * Dynamically import @clack/prompts.
+ * Dynamic import with fallback so the module doesn't crash if it's missing.
  */
 async function loadClack() {
     try {
@@ -82,10 +82,23 @@ async function loadClack() {
         throw new Error('[gsd] @clack/prompts not found — onboarding wizard requires this dependency');
     }
 }
+/**
+ * Build the PicoModule color surface from chalk. Chalk is already a
+ * dependency of the CLI; this adapter keeps the onboarding call sites stable
+ * while removing the redundant picocolors dep.
+ */
 async function loadPico() {
     try {
-        const mod = await import('picocolors');
-        return mod.default ?? mod;
+        const { default: chalk } = await import('chalk');
+        return {
+            cyan: (s) => chalk.cyan(s),
+            green: (s) => chalk.green(s),
+            yellow: (s) => chalk.yellow(s),
+            dim: (s) => chalk.dim(s),
+            bold: (s) => chalk.bold(s),
+            red: (s) => chalk.red(s),
+            reset: (s) => chalk.reset(s),
+        };
     }
     catch {
         // Fallback: return identity functions
@@ -105,9 +118,29 @@ function openBrowser(url) {
         execFile(cmd, [url], () => { });
     }
 }
-/** Check if an error is a clack cancel signal */
-function isCancelError(p, err) {
-    return p.isCancel(err);
+/** Sentinel returned by runStep when the user cancels — tells the caller
+ *  to abort the entire wizard. */
+const STEP_CANCELLED = Symbol('step-cancelled');
+/**
+ * Run a single onboarding step with shared error handling:
+ *   - user cancel (Ctrl+C) → p.cancel(cancelMessage), returns STEP_CANCELLED
+ *   - other error → p.log.warn + optional info follow-up, returns null
+ *   - success → the step's return value
+ */
+async function runStep(p, warnLabel, fn, opts = {}) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        if (p.isCancel(err)) {
+            p.cancel(opts.cancelMessage ?? 'Setup cancelled.');
+            return STEP_CANCELLED;
+        }
+        p.log.warn(`${warnLabel}: ${err instanceof Error ? err.message : String(err)}`);
+        if (opts.errorInfo)
+            p.log.info(opts.errorInfo);
+        return null;
+    }
 }
 // ─── Public API ───────────────────────────────────────────────────────────────
 /**
@@ -160,55 +193,28 @@ export async function runOnboarding(authStorage) {
     process.stderr.write(renderLogo(pc.cyan));
     p.intro(pc.bold('Welcome to GSD — let\'s get you set up'));
     // ── LLM Provider Selection ────────────────────────────────────────────────
-    let llmConfigured = false;
-    try {
-        llmConfigured = await runLlmStep(p, pc, authStorage);
-    }
-    catch (err) {
-        // User cancelled (Ctrl+C in clack throws) or unexpected error
-        if (isCancelError(p, err)) {
-            p.cancel('Setup cancelled — you can run /login inside GSD later.');
-            return;
-        }
-        p.log.warn(`LLM setup failed: ${err instanceof Error ? err.message : String(err)}`);
-        p.log.info('You can configure your LLM provider later with /login inside GSD.');
-    }
+    const llmResult = await runStep(p, 'LLM setup failed', () => runLlmStep(p, pc, authStorage), {
+        cancelMessage: 'Setup cancelled — you can run /login inside GSD later.',
+        errorInfo: 'You can configure your LLM provider later with /login inside GSD.',
+    });
+    if (llmResult === STEP_CANCELLED)
+        return;
+    const llmConfigured = llmResult ?? false;
     // ── Web Search Provider ──────────────────────────────────────────────────
-    let searchConfigured = null;
-    try {
-        searchConfigured = await runWebSearchStep(p, pc, authStorage, llmConfigured);
-    }
-    catch (err) {
-        if (isCancelError(p, err)) {
-            p.cancel('Setup cancelled.');
-            return;
-        }
-        p.log.warn(`Web search setup failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
+    const searchResult = await runStep(p, 'Web search setup failed', () => runWebSearchStep(p, pc, authStorage, llmConfigured));
+    if (searchResult === STEP_CANCELLED)
+        return;
+    const searchConfigured = searchResult;
     // ── Remote Questions ─────────────────────────────────────────────────────
-    let remoteConfigured = null;
-    try {
-        remoteConfigured = await runRemoteQuestionsStep(p, pc, authStorage);
-    }
-    catch (err) {
-        if (isCancelError(p, err)) {
-            p.cancel('Setup cancelled.');
-            return;
-        }
-        p.log.warn(`Remote questions setup failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
+    const remoteResult = await runStep(p, 'Remote questions setup failed', () => runRemoteQuestionsStep(p, pc, authStorage));
+    if (remoteResult === STEP_CANCELLED)
+        return;
+    const remoteConfigured = remoteResult;
     // ── Tool API Keys ─────────────────────────────────────────────────────────
-    let toolKeyCount = 0;
-    try {
-        toolKeyCount = await runToolKeysStep(p, pc, authStorage);
-    }
-    catch (err) {
-        if (isCancelError(p, err)) {
-            p.cancel('Setup cancelled.');
-            return;
-        }
-        p.log.warn(`Tool key setup failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
+    const toolResult = await runStep(p, 'Tool key setup failed', () => runToolKeysStep(p, pc, authStorage));
+    if (toolResult === STEP_CANCELLED)
+        return;
+    const toolKeyCount = toolResult ?? 0;
     // ── Summary ───────────────────────────────────────────────────────────────
     const summaryLines = [];
     if (llmConfigured) {

package/dist/resource-loader.js

@@ -358,7 +358,7 @@ function reconcileMergedNodeModules(agentNodeModules, hoisted, internal) {
             if (entry.name.startsWith('.'))
                 continue;
             try {
-                symlinkSync(join(hoisted, entry.name), join(agentNodeModules, entry.name));
+                symlinkSync(join(hoisted, entry.name), join(agentNodeModules, entry.name), 'junction');
                 linkedCount++;
             }
             catch { /* skip individual */ }
@@ -382,7 +382,7 @@ function reconcileMergedNodeModules(agentNodeModules, hoisted, internal) {
             }
             catch { /* didn't exist — will create below */ }
             try {
-                symlinkSync(join(internal, entry.name), link);
+                symlinkSync(join(internal, entry.name), link, 'junction');
                 linkedCount++;
             }
             catch { /* skip individual */ }

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -6,7 +6,7 @@
  * AssistantMessageEvents for TUI rendering, then strips tool-call blocks from
  * the final AssistantMessage so GSD's agent loop doesn't try to dispatch them.
  */
-import { EventStream } from "@gsd/pi-ai";
+import { EventStream, mapThinkingLevelToEffort, supportsAdaptiveThinking } from "@gsd/pi-ai";
 import { execSync } from "node:child_process";
 import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.js";
 import { buildWorkflowMcpServers } from "../gsd/workflow-mcp.js";
@@ -123,6 +123,63 @@ export function buildPromptFromContext(context) {
     }
     return parts.join("\n\n");
 }
+function stripDataUriPrefix(value) {
+    const commaIndex = value.indexOf(",");
+    if (value.startsWith("data:") && commaIndex !== -1) {
+        return value.slice(commaIndex + 1);
+    }
+    return value;
+}
+function inferMimeTypeFromDataUri(value) {
+    const match = /^data:([^;,]+);base64,/.exec(value);
+    return match?.[1] ?? null;
+}
+export function extractImageBlocksFromContext(context) {
+    const imageBlocks = [];
+    for (const msg of context.messages) {
+        if (msg.role !== "user" || !Array.isArray(msg.content))
+            continue;
+        for (const part of msg.content) {
+            if (!part || typeof part !== "object")
+                continue;
+            const block = part;
+            if (block.type !== "image" || typeof block.data !== "string")
+                continue;
+            const mimeType = typeof block.mimeType === "string" && block.mimeType.length > 0
+                ? block.mimeType
+                : inferMimeTypeFromDataUri(block.data);
+            if (!mimeType)
+                continue;
+            imageBlocks.push({
+                type: "image",
+                source: {
+                    type: "base64",
+                    media_type: mimeType,
+                    data: stripDataUriPrefix(block.data),
+                },
+            });
+        }
+    }
+    return imageBlocks;
+}
+export function buildSdkQueryPrompt(context, textPrompt = buildPromptFromContext(context)) {
+    const imageBlocks = extractImageBlocksFromContext(context);
+    if (imageBlocks.length === 0) {
+        return textPrompt;
+    }
+    const content = [...imageBlocks];
+    if (textPrompt) {
+        content.push({ type: "text", text: textPrompt });
+    }
+    const sdkMessage = {
+        type: "user",
+        message: { role: "user", content },
+        parent_tool_use_id: null,
+    };
+    return (async function* () {
+        yield sdkMessage;
+    })();
+}
 // ---------------------------------------------------------------------------
 // Error helper
 // ---------------------------------------------------------------------------
@@ -437,6 +494,7 @@ export async function resolveClaudePermissionMode(env = process.env) {
  * behaviour pass `permissionMode: "bypassPermissions"` explicitly.
  */
 export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
+    const { reasoning, ...sdkExtraOptions } = extraOptions;
     const mcpServers = buildWorkflowMcpServers();
     const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
     const disallowedTools = ["AskUserQuestion"];
@@ -455,6 +513,9 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
         "Bash(pwd)",
         ...(mcpServers ? Object.keys(mcpServers).map((serverName) => `mcp__${serverName}__*`) : []),
     ];
+    const effort = reasoning && supportsAdaptiveThinking(modelId)
+        ? mapThinkingLevelToEffort(reasoning, modelId)
+        : undefined;
     return {
         pathToClaudeCodeExecutable: getClaudePath(),
         model: modelId,
@@ -469,7 +530,8 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
         ...(allowedTools.length > 0 ? { allowedTools } : {}),
         ...(mcpServers ? { mcpServers } : {}),
         betas: modelId.includes("sonnet") ? ["context-1m-2025-08-07"] : [],
-        ...extraOptions,
+        ...(effort ? { effort } : {}),
+        ...sdkExtraOptions,
     };
 }
 function normalizeToolResultContent(content) {
@@ -617,14 +679,16 @@ async function pumpSdkMessages(model, context, options, stream) {
             options.signal.addEventListener("abort", () => controller.abort(), { once: true });
         }
         const prompt = buildPromptFromContext(context);
+        const queryPrompt = buildSdkQueryPrompt(context, prompt);
         const permissionMode = await resolveClaudePermissionMode();
         const sdkOpts = buildSdkOptions(modelId, prompt, { permissionMode }, typeof options?.extensionUIContext === "object"
             ? {
+                reasoning: options?.reasoning,
                 onElicitation: createClaudeCodeElicitationHandler(options?.extensionUIContext),
             }
-            : {});
+            : { reasoning: options?.reasoning });
         const queryResult = sdk.query({
-            prompt,
+            prompt: queryPrompt,
             options: {
                 ...sdkOpts,
                 abortController: controller,

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();