gsd-pi 2.73.1 → 2.74.0-dev.0306a2e

package/src/resources/extensions/claude-code-cli/tests/stream-adapter.test.ts

@@ -10,8 +10,10 @@ import {
 	mergePendingToolCalls,
 	resolveClaudePermissionMode,
 	buildPromptFromContext,
+	buildSdkQueryPrompt,
 	buildSdkOptions,
 	createClaudeCodeElicitationHandler,
+	extractImageBlocksFromContext,
 	extractToolResultsFromSdkUserMessage,
 	getClaudeLookupCommand,
 	parseAskUserQuestionsElicitation,
@@ -167,6 +169,92 @@ describe("stream-adapter — full context prompt (#2859)", () => {
 	});
 });
 
+describe("stream-adapter — image prompt forwarding (#4183)", () => {
+	test("extractImageBlocksFromContext maps user image parts to Anthropic base64 image blocks", () => {
+		const context: Context = {
+			messages: [
+				{
+					role: "user",
+					content: [
+						{ type: "text", text: "look" },
+						{
+							type: "image",
+							data: "data:image/png;base64,abc123",
+							mimeType: "image/png",
+						},
+					],
+				} as Message,
+			],
+		};
+
+		const imageBlocks = extractImageBlocksFromContext(context);
+		assert.deepEqual(imageBlocks, [
+			{
+				type: "image",
+				source: {
+					type: "base64",
+					media_type: "image/png",
+					data: "abc123",
+				},
+			},
+		]);
+	});
+
+	test("buildSdkQueryPrompt returns plain string when no images exist in context", () => {
+		const context: Context = {
+			messages: [{ role: "user", content: "hello" } as Message],
+		};
+		const textPrompt = buildPromptFromContext(context);
+
+		const prompt = buildSdkQueryPrompt(context, textPrompt);
+		assert.equal(typeof prompt, "string");
+		assert.equal(prompt, textPrompt);
+	});
+
+	test("buildSdkQueryPrompt wraps images and prompt text in an SDK user message iterable", async () => {
+		const context: Context = {
+			messages: [
+				{
+					role: "user",
+					content: [
+						{ type: "image", data: "ZmFrZQ==", mimeType: "image/jpeg" },
+						{ type: "text", text: "What is in this image?" },
+					],
+				} as Message,
+			],
+		};
+		const textPrompt = buildPromptFromContext(context);
+
+		const prompt = buildSdkQueryPrompt(context, textPrompt);
+		assert.notEqual(typeof prompt, "string");
+		assert.ok(prompt && typeof (prompt as any)[Symbol.asyncIterator] === "function");
+
+		const messages: any[] = [];
+		for await (const item of prompt as AsyncIterable<any>) {
+			messages.push(item);
+		}
+		assert.equal(messages.length, 1);
+		assert.deepEqual(messages[0], {
+			type: "user",
+			message: {
+				role: "user",
+				content: [
+					{
+						type: "image",
+						source: {
+							type: "base64",
+							media_type: "image/jpeg",
+							data: "ZmFrZQ==",
+						},
+					},
+					{ type: "text", text: textPrompt },
+				],
+			},
+			parent_tool_use_id: null,
+		});
+	});
+});
+
 // ---------------------------------------------------------------------------
 // Bug #4102 — transcript fabrication regression tests
 // ---------------------------------------------------------------------------
@@ -343,6 +431,26 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		);
 	});
 
+	test("buildSdkOptions maps reasoning to effort for adaptive Claude Code models (#3917)", () => {
+		const options = buildSdkOptions("claude-sonnet-4-6", "test", undefined, { reasoning: "high" });
+		assert.equal(options.effort, "high");
+	});
+
+	test("buildSdkOptions upgrades xhigh reasoning to max for opus 4.6 (#3917)", () => {
+		const options = buildSdkOptions("claude-opus-4-6", "test", undefined, { reasoning: "xhigh" });
+		assert.equal(options.effort, "max");
+	});
+
+	test("buildSdkOptions omits effort when reasoning is undefined (#3917)", () => {
+		const options = buildSdkOptions("claude-sonnet-4-6", "test");
+		assert.equal("effort" in options, false);
+	});
+
+	test("buildSdkOptions omits effort for non-adaptive Claude models (#3917)", () => {
+		const options = buildSdkOptions("claude-sonnet-4-20250514", "test", undefined, { reasoning: "high" });
+		assert.equal("effort" in options, false);
+	});
+
 	test("buildSdkOptions includes workflow MCP server config when env is set", () => {
 		const prev = {
 			GSD_WORKFLOW_MCP_COMMAND: process.env.GSD_WORKFLOW_MCP_COMMAND,
@@ -774,11 +882,12 @@ describe("stream-adapter — MCP elicitation bridge", () => {
 			},
 		};
 
+		const secureValue = "ui-collected-value";
 		const inputCalls: Array<{ opts?: { secure?: boolean } }> = [];
 		const handler = createClaudeCodeElicitationHandler({
 			input: async (_title: string, _placeholder?: string, opts?: { secure?: boolean }) => {
 				inputCalls.push({ opts });
-				return "example-secure-input";
+				return secureValue;
 			},
 		} as any);
 		assert.ok(handler);
@@ -787,7 +896,7 @@ describe("stream-adapter — MCP elicitation bridge", () => {
 		assert.deepEqual(result, {
 			action: "accept",
 			content: {
-				TEST_SECURE_FIELD: "example-secure-input",
+				TEST_SECURE_FIELD: secureValue,
 			},
 		});
 		assert.equal(inputCalls.length, 1);

package/src/resources/extensions/gsd/activity-log.ts

@@ -16,6 +16,8 @@ import { GSDError, GSD_IO_ERROR } from "./errors.js";
 const SEQ_PREFIX_RE = /^(\d+)-/;
 import type { ExtensionContext } from "@gsd/pi-coding-agent";
 import { gsdRoot } from "./paths.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
+import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
 
 interface ActivityLogState {
   nextSeq: number;
@@ -132,6 +134,25 @@ export function saveActivityLog(
     }
     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) {
     // Don't let logging failures break auto-mode

package/src/resources/extensions/gsd/auto/detect-stuck.ts

@@ -5,6 +5,7 @@
  */
 
 import type { WindowEntry } from "./types.js";
+import { summarizeLogs } from "../workflow-logger.js";
 
 /**
  * Pattern matching ENOENT errors with a file path.
@@ -28,6 +29,13 @@ export function detectStuck(
 ): { stuck: true; reason: string } | null {
   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];
 
@@ -35,7 +43,7 @@ export function detectStuck(
   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}`,
     };
   }
 
@@ -45,7 +53,7 @@ export function detectStuck(
     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}`,
       };
     }
   }
@@ -60,7 +68,7 @@ export function detectStuck(
     ) {
       return {
         stuck: true,
-        reason: `Oscillation detected: ${w[0].key} ↔ ${w[1].key}`,
+        reason: `Oscillation detected: ${w[0].key} ↔ ${w[1].key}${suffix}`,
       };
     }
   }
@@ -77,7 +85,7 @@ export function detectStuck(
     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/src/resources/extensions/gsd/auto/loop-deps.ts

@@ -21,6 +21,7 @@ import type { WorktreeResolver } from "../worktree-resolver.js";
 import type { CmuxLogLevel } from "../../cmux/index.js";
 import type { JournalEntry } from "../journal.js";
 import type { MergeReconcileResult } from "../auto-recovery.js";
+import type { UokTurnObserver } from "../uok/contracts.js";
 
 /**
  * Dependencies injected by the caller (auto.ts startAuto) so autoLoop
@@ -180,6 +181,12 @@ export interface LoopDeps {
     startedAt: number,
     opts?: CloseoutOptions & Record<string, unknown>,
   ) => Promise<void>;
+  autoCommitUnit?: (
+    basePath: string,
+    unitType: string,
+    unitId: string,
+    ctx?: ExtensionContext,
+  ) => Promise<string | null>;
   recordOutcome: (unitType: string, tier: string, success: boolean) => void;
   writeLock: (
     lockBase: string,
@@ -268,4 +275,7 @@ export interface LoopDeps {
 
   // Journal
   emitJournalEvent: (entry: JournalEntry) => void;
+
+  // UOK (optional, flag-gated)
+  uokObserver?: UokTurnObserver;
 }

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

@@ -31,6 +31,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";
 
@@ -128,6 +130,43 @@ export async function autoLoop(
     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: string | undefined;
+    let observedUnitId: string | undefined;
+    let turnFinished = false;
+    const finishTurn = (
+      status: "completed" | "failed" | "paused" | "stopped" | "skipped" | "retry",
+      failureClass: "none" | "unknown" | "manual-attention" | "timeout" | "execution" | "closeout" | "git" = "none",
+      error?: string,
+    ): void => {
+      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", {
@@ -140,6 +179,7 @@ export async function autoLoop(
         pi,
         `Safety: loop exceeded ${MAX_LOOP_ITERATIONS} iterations — possible runaway`,
       );
+      finishTurn("stopped", "manual-attention", "max-iterations");
       break;
     }
 
@@ -157,22 +197,32 @@ export async function autoLoop(
           `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: SidecarItem | undefined;
       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",
@@ -256,27 +306,53 @@ export async function autoLoop(
           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") 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") 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;
         }
 
@@ -299,36 +375,77 @@ export async function autoLoop(
 
         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") break;
-        if (preDispatchResult.action === "continue") continue;
+        deps.uokObserver?.onPhaseResult("pre-dispatch", preDispatchResult.action);
+        if (preDispatchResult.action === "break") {
+          finishTurn("stopped", "manual-attention", "pre-dispatch-break");
+          break;
+        }
+        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") 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") break;
-        if (dispatchResult.action === "continue") continue;
+        deps.uokObserver?.onPhaseResult("dispatch", dispatchResult.action);
+        if (dispatchResult.action === "break") {
+          finishTurn("stopped", "manual-attention", "dispatch-break");
+          break;
+        }
+        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 ──
         const sidecarState = await deps.deriveState(s.basePath);
@@ -343,22 +460,50 @@ export async function autoLoop(
           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") 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") break;
-      if (finalizeResult.action === "continue") continue;
+      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") {
+        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 ──
       const msg = loopErr instanceof Error ? loopErr.message : String(loopErr);
@@ -388,6 +533,7 @@ export async function autoLoop(
           pi,
           `Infrastructure error (${infraCode}): not recoverable by retry`,
         );
+        finishTurn("failed", "execution", msg);
         break;
       }
 
@@ -429,6 +575,7 @@ export async function autoLoop(
           "warning",
         );
         await new Promise(resolve => setTimeout(resolve, waitMs));
+        finishTurn("retry", "timeout", msg);
         continue; // Retry iteration without incrementing consecutiveErrors
       }
 
@@ -455,6 +602,7 @@ export async function autoLoop(
           pi,
           `${consecutiveErrors} consecutive iteration failures`,
         );
+        finishTurn("failed", "execution", msg);
         break;
       } else if (consecutiveErrors === 2) {
         // 2nd consecutive: try invalidating caches + re-deriving state
@@ -467,6 +615,7 @@ export async function autoLoop(
         // 1st error: log and retry — transient failures happen
         ctx.ui.notify(`Iteration error: ${msg}. Retrying.`, "warning");
       }
+      finishTurn("retry", "execution", msg);
     }
   }