p-dev-harness 0.3.1 → 0.4.0

package/workspace-snapshot/files/tests/cursor/run-observer.test.ts

@@ -94,6 +94,42 @@ describe("sendAndObserve", () => {
     await rm(dir, { recursive: true, force: true });
   });
 
+  it("passes per-send model, mode, and idempotencyKey to agent.send", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "harness-observer-"));
+    const events = new EventLogger(dir);
+    await events.init();
+
+    const send = vi.fn().mockResolvedValue({
+      id: "run-idem",
+      requestId: "req-1",
+      stream: async function* () {
+        yield { type: "message" };
+      },
+      wait: vi.fn().mockResolvedValue({
+        id: "run-idem",
+        status: "completed",
+        durationMs: 100,
+        result: "done",
+        git: { branches: [] },
+      }),
+    });
+    const agent = createMockAgent({ send });
+
+    await sendAndObserve(agent as never, "prompt", dir, events, {
+      model: { id: "composer-2.5" },
+      mode: "agent",
+      idempotencyKey: "p-dev:revision:WES-1:comment-1",
+    });
+
+    expect(send).toHaveBeenCalledWith("prompt", {
+      model: { id: "composer-2.5" },
+      mode: "agent",
+      idempotencyKey: "p-dev:revision:WES-1:comment-1",
+    });
+
+    await rm(dir, { recursive: true, force: true });
+  });
+
   it("requires branch and PR for implementation runs", async () => {
     const dir = await mkdtemp(path.join(tmpdir(), "harness-observer-"));
     const events = new EventLogger(dir);

package/workspace-snapshot/files/tests/fixtures/workflows/harness-auto-runner-with-production-sync.yml

@@ -231,15 +231,26 @@ jobs:
           if [ "$FORCE_FLAG_INPUT" = "true" ]; then
             FORCE_FLAG="--force"
           fi
-          npm run harness:run -- --issue "$ISSUE_KEY" --phase "$PHASE" $FORCE_FLAG --json 2>&1 \
-            | tee harness-raw-output.txt
-          EXIT_CODE=${PIPESTATUS[0]}
-          npm run harness:redact-output < harness-raw-output.txt > harness-run-output.json
-          rm -f harness-raw-output.txt
-          echo "Redacted harness output written to harness-run-output.json"
+          npm run harness:run -- --issue "$ISSUE_KEY" --phase "$PHASE" $FORCE_FLAG --json-out harness-run-output.json
+          EXIT_CODE=$?
           echo "exit_code=$EXIT_CODE" >> "$GITHUB_OUTPUT"
           exit $EXIT_CODE
 
+      - name: Finalize harness run
+        if: always()
+        env:
+          ISSUE_KEY: ${{ needs.gate.outputs.issue_key }}
+          EXIT_CODE: ${{ steps.harness.outputs.exit_code }}
+          LINEAR_DELIVERY_ID: ${{ needs.gate.outputs.linear_delivery_id }}
+          LINEAR_API_KEY: ${{ secrets.LINEAR_API_KEY }}
+          HARNESS_CONFIG_JSON_B64: ${{ secrets.HARNESS_CONFIG_JSON_B64 }}
+          HARNESS_CONFIG_FINGERPRINT: ${{ vars.HARNESS_CONFIG_FINGERPRINT }}
+        run: |
+          npx tsx src/workflow/finalize-harness-run.ts \
+            --issue "$ISSUE_KEY" \
+            --json-out harness-run-output.json \
+            --exit-code "${EXIT_CODE:-1}"
+
       - name: Write step summary
         if: always()
         env:
@@ -294,6 +305,7 @@ jobs:
       CURSOR_API_KEY: ${{ secrets.CURSOR_API_KEY }}
       GITHUB_TOKEN: ${{ secrets.HARNESS_GITHUB_TOKEN }}
       HARNESS_CONFIG_JSON_B64: ${{ secrets.HARNESS_CONFIG_JSON_B64 }}
+      HARNESS_CONFIG_FINGERPRINT: ${{ vars.HARNESS_CONFIG_FINGERPRINT }}
 
     steps:
       - name: Checkout harness repo
@@ -340,15 +352,27 @@ jobs:
           if [ "$FORCE_FLAG_INPUT" = "true" ]; then
             FORCE_FLAG="--force"
           fi
-          npm run harness:run -- --issue "$ISSUE_KEY" --phase merge $FORCE_FLAG --json 2>&1 \
-            | tee harness-raw-output.txt
-          EXIT_CODE=${PIPESTATUS[0]}
-          npm run harness:redact-output < harness-raw-output.txt > harness-run-output.json
-          rm -f harness-raw-output.txt
+          npm run harness:run -- --issue "$ISSUE_KEY" --phase merge $FORCE_FLAG --json-out harness-run-output.json
+          EXIT_CODE=$?
           echo "Redacted harness output written to harness-run-output.json"
           echo "exit_code=$EXIT_CODE" >> "$GITHUB_OUTPUT"
           exit $EXIT_CODE
 
+      - name: Finalize merge run
+        if: always()
+        env:
+          ISSUE_KEY: ${{ needs.gate.outputs.issue_key }}
+          EXIT_CODE: ${{ steps.merge.outputs.exit_code }}
+          LINEAR_DELIVERY_ID: ${{ needs.gate.outputs.linear_delivery_id }}
+          LINEAR_API_KEY: ${{ secrets.LINEAR_API_KEY }}
+          HARNESS_CONFIG_JSON_B64: ${{ secrets.HARNESS_CONFIG_JSON_B64 }}
+          HARNESS_CONFIG_FINGERPRINT: ${{ vars.HARNESS_CONFIG_FINGERPRINT }}
+        run: |
+          npx tsx src/workflow/finalize-harness-run.ts \
+            --issue "$ISSUE_KEY" \
+            --json-out harness-run-output.json \
+            --exit-code "${EXIT_CODE:-1}"
+
       - name: Write step summary
         if: always()
         env:
@@ -397,6 +421,7 @@ jobs:
       LINEAR_API_KEY: ${{ secrets.LINEAR_API_KEY }}
       GITHUB_TOKEN: ${{ secrets.HARNESS_GITHUB_TOKEN }}
       HARNESS_CONFIG_JSON_B64: ${{ secrets.HARNESS_CONFIG_JSON_B64 }}
+      HARNESS_CONFIG_FINGERPRINT: ${{ vars.HARNESS_CONFIG_FINGERPRINT }}
 
     steps:
       - name: Resolve sync inputs

package/workspace-snapshot/files/tests/github/auth-verification-retry.test.ts

@@ -0,0 +1,141 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { GitHubApiError, GitHubClient } from "../../src/github/client.js";
+import {
+  DEFAULT_VERIFICATION_MAX_ATTEMPTS,
+  inspectAuthenticatedUserWithTransientRetry,
+  isGitHubVerificationNetworkFailure,
+  isTransientGitHubVerificationFailure,
+} from "../../src/github/auth-verification-retry.js";
+
+const mockFetch = vi.fn();
+const SENTINEL_SECRET = "ghp_sentinelSecretValueForRetryTests";
+
+function userResponse(status: number, login = "weston-uribe") {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    text: async () => JSON.stringify({ login }),
+    headers: new Headers({
+      "x-oauth-scopes": "repo, workflow",
+      "github-authentication-token-type": "classic",
+    }),
+  };
+}
+
+describe("auth-verification-retry", () => {
+  beforeEach(() => {
+    vi.stubGlobal("fetch", mockFetch);
+    mockFetch.mockReset();
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("classifies transient HTTP statuses and network failures", () => {
+    expect(isTransientGitHubVerificationFailure(new GitHubApiError(503, "down"))).toBe(
+      true,
+    );
+    expect(isTransientGitHubVerificationFailure(new GitHubApiError(502, "bad gateway"))).toBe(
+      true,
+    );
+    expect(isTransientGitHubVerificationFailure(new GitHubApiError(401, "nope"))).toBe(
+      false,
+    );
+    expect(isTransientGitHubVerificationFailure(new GitHubApiError(403, "denied"))).toBe(
+      false,
+    );
+    expect(isTransientGitHubVerificationFailure(new TypeError("fetch failed"))).toBe(
+      true,
+    );
+    expect(isGitHubVerificationNetworkFailure(new TypeError("fetch failed"))).toBe(
+      true,
+    );
+    expect(isGitHubVerificationNetworkFailure(new GitHubApiError(503, "down"))).toBe(
+      false,
+    );
+  });
+
+  it("retries a 503 followed by success", async () => {
+    mockFetch
+      .mockResolvedValueOnce(userResponse(503))
+      .mockResolvedValueOnce(userResponse(200));
+
+    const client = new GitHubClient({ token: "test-token" });
+    const result = await inspectAuthenticatedUserWithTransientRetry(client, {
+      sleep: vi.fn(),
+    });
+
+    expect(result.login).toBe("weston-uribe");
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+
+  it("retries two transient failures followed by success", async () => {
+    mockFetch
+      .mockResolvedValueOnce(userResponse(503))
+      .mockResolvedValueOnce(userResponse(502))
+      .mockResolvedValueOnce(userResponse(200));
+
+    const sleep = vi.fn();
+    const client = new GitHubClient({ token: "test-token" });
+    const result = await inspectAuthenticatedUserWithTransientRetry(client, { sleep });
+
+    expect(result.login).toBe("weston-uribe");
+    expect(mockFetch).toHaveBeenCalledTimes(3);
+    expect(sleep).toHaveBeenCalledTimes(2);
+  });
+
+  it("throws after three 503 responses without retrying auth failures", async () => {
+    mockFetch.mockResolvedValue(userResponse(503));
+
+    const client = new GitHubClient({ token: "test-token" });
+    await expect(
+      inspectAuthenticatedUserWithTransientRetry(client, { sleep: vi.fn() }),
+    ).rejects.toMatchObject({ status: 503 });
+    expect(mockFetch).toHaveBeenCalledTimes(DEFAULT_VERIFICATION_MAX_ATTEMPTS);
+  });
+
+  it("retries a network failure followed by success", async () => {
+    mockFetch
+      .mockRejectedValueOnce(new TypeError("fetch failed"))
+      .mockResolvedValueOnce(userResponse(200));
+
+    const client = new GitHubClient({ token: "test-token" });
+    const result = await inspectAuthenticatedUserWithTransientRetry(client, {
+      sleep: vi.fn(),
+    });
+
+    expect(result.login).toBe("weston-uribe");
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+
+  it("does not retry HTTP 401", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 401,
+      text: async () => SENTINEL_SECRET,
+      headers: new Headers(),
+    });
+
+    const client = new GitHubClient({ token: "test-token" });
+    await expect(
+      inspectAuthenticatedUserWithTransientRetry(client, { sleep: vi.fn() }),
+    ).rejects.toMatchObject({ status: 401 });
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not retry HTTP 403", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 403,
+      text: async () => "forbidden",
+      headers: new Headers(),
+    });
+
+    const client = new GitHubClient({ token: "test-token" });
+    await expect(
+      inspectAuthenticatedUserWithTransientRetry(client, { sleep: vi.fn() }),
+    ).rejects.toMatchObject({ status: 403 });
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+  });
+});

package/workspace-snapshot/files/tests/gui/app-shell-settings-menu.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it } from "vitest";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+describe("app shell settings menu", () => {
+  it("renders the polished brand lockup without legacy header copy", async () => {
+    const appShell = await readFile(
+      path.join(process.cwd(), "apps/gui/components/custom/app-shell.tsx"),
+      "utf8",
+    );
+    const applicationHeader = await readFile(
+      path.join(
+        process.cwd(),
+        "apps/gui/components/custom/application-header.tsx",
+      ),
+      "utf8",
+    );
+
+    expect(appShell).toContain("ApplicationHeader");
+    expect(appShell).not.toContain("Product Development Harness");
+    expect(appShell).not.toContain("Local operator GUI");
+    expect(appShell).not.toContain("ThemeToggle");
+    expect(applicationHeader).toContain("PDev Harness");
+    expect(applicationHeader).toContain("enableHomeNavigation");
+    expect(applicationHeader).toContain('href={workflowHref}');
+    expect(applicationHeader).toContain("SettingsMenu");
+  });
+
+  it("uses Radix dropdown menu for settings actions", async () => {
+    const settingsMenu = await readFile(
+      path.join(process.cwd(), "apps/gui/components/custom/settings-menu.tsx"),
+      "utf8",
+    );
+    const dropdownMenu = await readFile(
+      path.join(process.cwd(), "apps/gui/components/ui/dropdown-menu.tsx"),
+      "utf8",
+    );
+
+    expect(settingsMenu).toContain("DropdownMenu");
+    expect(settingsMenu).toContain("Dark mode");
+    expect(settingsMenu).toContain("Light mode");
+    expect(settingsMenu).toContain('href={settingsHref}');
+    expect(settingsMenu).toContain('aria-current={isSettingsActive ? "page" : undefined}');
+    const themeItemMatch = settingsMenu.match(
+      /<DropdownMenuItem[\s\S]*?toggleTheme\(\)[\s\S]*?<\/DropdownMenuItem>/,
+    );
+    expect(themeItemMatch?.[0] ?? "").not.toContain("<Button");
+    expect(dropdownMenu).toContain('@radix-ui/react-dropdown-menu');
+  });
+
+  it("keeps sticky background-matched header tokens", async () => {
+    const layout = await readFile(
+      path.join(process.cwd(), "apps/gui/lib/constants/layout.ts"),
+      "utf8",
+    );
+
+    expect(layout).toContain('header: "sticky top-0 z-50 border-b border-border bg-background"');
+    expect(layout).toContain('APP_HEADER_STICKY_CLASS = "sticky top-0 z-50"');
+  });
+
+  it("shares theme toggle logic without nesting buttons in menu items", async () => {
+    const themeHook = await readFile(
+      path.join(process.cwd(), "apps/gui/lib/use-theme-toggle.ts"),
+      "utf8",
+    );
+    const settingsMenu = await readFile(
+      path.join(process.cwd(), "apps/gui/components/custom/settings-menu.tsx"),
+      "utf8",
+    );
+
+    expect(themeHook).toContain('from "next-themes"');
+    expect(themeHook).toContain("toggleTheme");
+    expect(settingsMenu).toContain("useThemeToggle");
+    expect(settingsMenu).toContain("toggleTheme()");
+  });
+
+  it("defaults to showing product navigation and can suppress it", async () => {
+    const appShell = await readFile(
+      path.join(process.cwd(), "apps/gui/components/custom/app-shell.tsx"),
+      "utf8",
+    );
+    const applicationHeader = await readFile(
+      path.join(
+        process.cwd(),
+        "apps/gui/components/custom/application-header.tsx",
+      ),
+      "utf8",
+    );
+    const settingsMenu = await readFile(
+      path.join(process.cwd(), "apps/gui/components/custom/settings-menu.tsx"),
+      "utf8",
+    );
+
+    expect(appShell).toContain("showProductNavigation = true");
+    expect(appShell).toContain(
+      "showProductNavigation={showProductNavigation}",
+    );
+    expect(appShell).toContain("enableHomeNavigation = true");
+    expect(appShell).toContain(
+      "enableHomeNavigation={enableHomeNavigation}",
+    );
+    expect(applicationHeader).toContain("showProductNavigation = true");
+    expect(applicationHeader).toContain(
+      "showProductNavigation={showProductNavigation}",
+    );
+    expect(applicationHeader).toContain("enableHomeNavigation = true");
+    expect(settingsMenu).toContain("showProductNavigation = true");
+    expect(settingsMenu).toContain("!showProductNavigation");
+    expect(settingsMenu).toContain("{showProductNavigation ? (");
+    expect(settingsMenu).toContain("DropdownMenuSeparator");
+    expect(settingsMenu).toContain("Workflow");
+    expect(settingsMenu).toContain("Dark mode");
+    expect(settingsMenu).toContain("Light mode");
+  });
+});

package/workspace-snapshot/files/tests/gui/configure-fix-loop.test.ts

@@ -22,16 +22,17 @@ describe("configure GUI fix loop", () => {
     expect(source).not.toMatch(
       /RemoteActionConfirmation[\s\S]*disabled=\{!previewIsCurrent/,
     );
+    expect(source).toContain("runPreview");
     expect(source).toMatch(
-      /previewIsCurrent && preview \? preview : await runPreview\(\)/,
+      /previewIsCurrent && previewMode === "workspace" && workspacePreview/,
     );
-    expect(source).toMatch(/if \(!apply\.verified\)/);
-    expect(source).toMatch(/\{!verifiedSuccess \?/);
+    expect(source).toMatch(/if \(!response\.apply\.verified\)/);
+    expect(source).toMatch(/\{loading !== "apply" && !verifiedSuccess \?/);
     expect(source).toMatch(/\{verifiedSuccess && applyResult \?/);
     expect(source).toMatch(/invalidatePreview\(\)/);
   });
 
-  it("Step 3 uses accurate Vercel settings copy and optional direct apply", () => {
+  it("Step 3 uses accurate PDev automation bridge copy and optional direct apply", () => {
     const source = readFileSync(
       path.join(
         repoRoot,
@@ -40,13 +41,17 @@ describe("configure GUI fix loop", () => {
       "utf8",
     );
 
-    expect(source).toContain("Configure Vercel settings");
+    expect(source).toContain("Configure PDev automation bridge");
     expect(source).not.toContain("Set up Vercel webhook bridge");
     expect(source).not.toContain("Select the harness control-plane");
     expect(source).not.toContain("Vercel scope");
     expect(source).toContain("Vercel team name");
+    expect(source).toContain(
+      "Choose the Vercel team and project that hosts the PDev automation bridge.",
+    );
+    expect(source).not.toContain("Env var presence alone is not enough");
     expect(source).not.toContain(
-      "Choose the Vercel project this setup should use for automation and",
+      "Choose the Vercel project this setup should use for automation and preview checks",
     );
     expect(source).toContain("scope=\"vercel-bridge-write\"");
     expect(source).not.toContain("scope=\"remote-secret-write\"");
@@ -59,7 +64,7 @@ describe("configure GUI fix loop", () => {
     expect(source).not.toContain("GitHub dispatch token:");
     expect(source).not.toContain("LINEAR_WEBHOOK_SECRET:");
     expect(source).not.toContain("Bridge not ready");
-    expect(source).toContain("Preview Vercel settings");
+    expect(source).toContain("Preview PDev automation bridge");
     expect(source).not.toMatch(
       /RemoteActionConfirmation[\s\S]*disabled=\{!previewIsCurrent/,
     );
@@ -69,7 +74,7 @@ describe("configure GUI fix loop", () => {
     expect(source).not.toContain(
       "I completed any manual webhook steps and accept bridge readiness.",
     );
-    expect(source).toContain("Apply Vercel Settings");
+    expect(source).toContain("Apply PDev automation bridge");
     expect(source).not.toContain("Apply Vercel bridge setup");
     expect(source).toMatch(
       /previewIsCurrent && preview \? preview : await runPreview\(\)/,
@@ -78,21 +83,21 @@ describe("configure GUI fix loop", () => {
     expect(source).toContain("Create new project");
     expect(source).toContain("deployment-required");
     expect(source).toContain("Deployment status:");
-    expect(source).toContain("Applying Vercel settings…");
-    expect(source).toContain("Retry verification");
-    expect(source).toContain("verifyOnly: true");
-    expect(source).toContain("orchestrationSteps");
+    expect(source).toContain('loading === "apply"');
+    expect(source).toContain("Apply PDev automation bridge");
+    expect(source).not.toContain("Retry verification");
+    expect(source).not.toContain("GITHUB_DISPATCH_TOKEN override");
+    expect(source).toContain("VercelBridgeOrchestrationStatus");
+    expect(source).toContain("resolveOrchestrationStatusMessage");
+    expect(source).toContain("shouldHideApplyButton");
+    expect(source).toContain("resumeOrchestrationFromSummary");
+    expect(source).toContain("githubDispatchEligible");
     expect(source).toContain("buildVercelApplyResultMessage");
-    expect(source).toContain("shouldShowRetryVerification");
-    expect(source).toContain('productionRedeployStatus === "ready"');
-    expect(source).toContain("apply.setupBlocked");
-    expect(source).toContain("shouldShowRetryVerification(applyResult, redeployPollingActive)");
     expect(source).toContain("setupPending");
     expect(source).toContain("pollActionId");
     expect(source).toContain("/api/setup/vercel-bridge-redeploy-status");
     expect(source).toContain('body: JSON.stringify({\n          actionId: pollActionId,\n        })');
     expect(source).toContain("readSetupJsonResponse");
-    expect(source).toContain("Waiting for production redeploy");
     expect(source).toContain("redeployPollingActive");
     expect(source).toContain("controlsLocked");
     expect(source).toContain("REDEPLOY_POLLING_LOCK_MESSAGE");
@@ -100,10 +105,7 @@ describe("configure GUI fix loop", () => {
     expect(source).toMatch(/disabled=\{controlsLocked/);
     expect(source).toMatch(/if \(redeployPollingActive\) \{\s*return;\s*\}/);
     expect(source).toMatch(/handlePreview[\s\S]*if \(redeployPollingActive\)/);
-    expect(source).toMatch(/handleApply[\s\S]*if \(redeployPollingActive && !options\?\.verifyOnly\)/);
-    expect(source).toMatch(
-      /shouldShowRetryVerification\(applyResult, redeployPollingActive\)/,
-    );
+    expect(source).toMatch(/handleApply[\s\S]*if \(redeployPollingActive\)/);
   });
 
   it("Step 3 locks controls during pending redeploy polling", () => {
@@ -123,7 +125,7 @@ describe("configure GUI fix loop", () => {
     );
   });
 
-  it("Step 3 confirmation uses Vercel bridge copy", () => {
+  it("Step 3 confirmation uses PDev automation bridge copy", () => {
     const source = readFileSync(
       path.join(
         repoRoot,
@@ -192,6 +194,8 @@ describe("configure GUI fix loop", () => {
 
     expect(guidedMinimalSource).toContain("Enter harness repo");
     expect(guidedMinimalSource).toContain("Verify and use harness repo");
+    expect(guidedMinimalSource).toContain("harnessRepoInheritedFromStep1");
+    expect(guidedMinimalSource).toContain("!harnessRepoInheritedFromStep1");
     expect(targetSource).toContain("Detected from git remote");
     expect(targetSource).toContain("Saved in .env.local");
     expect(guidedMinimalSource).toContain("{harnessRepoSource}");
@@ -205,6 +209,9 @@ describe("configure GUI fix loop", () => {
 
     expect(workflowSource).toContain("savedHarnessDispatchRepository");
     expect(workflowSource).toContain("suggestedHarnessDispatchRepo ||");
+    expect(workflowSource).toContain("step1TrustedHarnessRepo");
+    expect(workflowSource).toContain("harnessRepoInheritedFromStep1");
+    expect(workflowSource).toContain("isHarnessRepoReadyForGuidedStep4");
     expect(workflowSource).toContain("/api/setup/verify-harness-repo");
     expect(experienceSource).toMatch(
       /githubDispatchRepository:\s*shouldResetDispatch[\s\S]*formDefaults\.env\.githubDispatchRepository \|\| suggested \|\| ""/,
@@ -223,6 +230,8 @@ describe("configure GUI fix loop", () => {
     );
 
     expect(guidedStep4Source).toContain("ReviewGeneratedFilesDisclosure");
+    expect(guidedStep4Source).toContain("TargetRepoCreateConnect");
+    expect(guidedStep4Source).toContain("handleTargetRepoCreated");
     expect(guidedStep4Source).toContain(
       "disabled={Boolean(preview?.validationError)}",
     );
@@ -254,7 +263,8 @@ describe("configure GUI fix loop", () => {
 
     expect(source).toContain("Setup type");
     expect(source).toContain('type="radio"');
-    expect(source).toContain('setupType === "automatic"');
+    expect(source).toContain('useState<CloudSecretsSetupType | null>(() =>');
+    expect(source).toContain('deriveStep6RemoteActionEligibility(initialSummary).allowed');
     expect(source).toContain('setupType === "manual"');
     expect(source).toContain("deriveStep6ContinueEligibility");
     expect(source).toContain("deriveStep6RemoteActionEligibility");
@@ -320,16 +330,14 @@ describe("configure GUI fix loop", () => {
       "utf8",
     );
 
-    // before: local readiness passed shows Continue
-    expect(localReadinessSource).toContain("canContinue");
+    // before: local readiness passed shows Continue via GuidedStepSuccessPanel
     expect(localReadinessSource).toContain("allPassed");
-    expect(localReadinessSource).toMatch(
-      /\{canContinue \?[\s\S]*Continue to cloud secrets/,
-    );
+    expect(localReadinessSource).toContain("GuidedStepSuccessPanel");
+    expect(localReadinessSource).toContain("Continue to cloud secrets");
     expect(localReadinessSource).toContain("!readiness.localReadinessReviewed");
 
     // action: clicking Continue calls the parent handler
-    expect(localReadinessSource).toContain("onClick={onContinue}");
+    expect(localReadinessSource).toContain("onContinue={onContinue}");
     expect(experienceSource).toContain("handleLocalReadinessReviewed");
     expect(experienceSource).toContain(
       "onContinue={handleLocalReadinessReviewed}",
@@ -338,7 +346,7 @@ describe("configure GUI fix loop", () => {
     // after: handler advances guided display to Step 6
     expect(experienceSource).toContain("GUIDED_DISPLAY_STEP_AFTER_LOCAL_READINESS");
     const continueHandler = experienceSource.match(
-      /const handleLocalReadinessReviewed = useCallback\([\s\S]*?\n  \);/,
+      /const handleLocalReadinessReviewed = useCallback\(\(\) => \{[\s\S]*?\n  \}, \[clearPinnedGuidedDisplayStep, recordStepCompleted\]\);/,
     )?.[0];
     expect(continueHandler).toBeDefined();
     expect(continueHandler).toContain("localReadinessReviewed: true");
@@ -381,17 +389,16 @@ describe("configure GUI fix loop", () => {
       "utf8",
     );
 
-    // before: verified success shows Continue
+    // before: verified success shows Continue via GuidedStepSuccessPanel
     expect(cloudSecretsSource).toContain("canContinue");
     expect(cloudSecretsSource).toContain("verifiedAutomaticSuccess");
     expect(cloudSecretsSource).toContain("verifiedManualSuccess");
-    expect(cloudSecretsSource).toMatch(
-      /\{canContinue \?[\s\S]*Continue to target workflow/,
-    );
+    expect(cloudSecretsSource).toContain("GuidedStepSuccessPanel");
+    expect(cloudSecretsSource).toContain("Continue to target workflow");
     expect(cloudSecretsSource).toContain("!readiness.cloudSecretsReviewed");
 
     // action: clicking Continue calls the parent handler
-    expect(cloudSecretsSource).toContain("onClick={onContinue}");
+    expect(cloudSecretsSource).toMatch(/onContinue=\{onContinue\}/);
     expect(experienceSource).toContain("handleCloudSecretsReviewed");
     expect(experienceSource).toContain(
       "onContinue={handleCloudSecretsReviewed}",
@@ -400,7 +407,7 @@ describe("configure GUI fix loop", () => {
     // after: handler advances guided display to Step 7
     expect(experienceSource).toContain("GUIDED_DISPLAY_STEP_AFTER_CLOUD_SECRETS");
     const continueHandler = experienceSource.match(
-      /const handleCloudSecretsReviewed = useCallback\([\s\S]*?\n  \);/,
+      /const handleCloudSecretsReviewed = useCallback\(\(\) => \{[\s\S]*?\n  \}, \[clearPinnedGuidedDisplayStep, recordStepCompleted\]\);/,
     )?.[0];
     expect(continueHandler).toBeDefined();
     expect(continueHandler).toContain("cloudSecretsReviewed: true");
@@ -442,12 +449,18 @@ describe("configure GUI fix loop", () => {
 
     expect(experienceSource).toContain("handleGuidedWorkflowSetupComplete");
     const workflowCompleteHandler = experienceSource.match(
-      /const handleGuidedWorkflowSetupComplete = useCallback\([\s\S]*?\n  \);/,
+      /const handleGuidedWorkflowSetupComplete = useCallback\(\(\) => \{[\s\S]*?\n  \}, \[observabilityNonce, recordStepCompleted\]\);/,
     )?.[0];
     expect(workflowCompleteHandler).toBeDefined();
     expect(workflowCompleteHandler).not.toContain(
       "setDisplayedGuidedStep(GUIDED_DISPLAY_STEP_AFTER_WORKFLOW_READY)",
     );
+    expect(workflowCompleteHandler).toContain('window.location.assign("/workflow")');
+    // Display advance after Step 7 success is owned by Continue, not setup-complete.
+    expect(experienceSource).toContain("handleTargetWorkflowContinue");
+    expect(experienceSource).toContain(
+      "setDisplayedGuidedStep(GUIDED_DISPLAY_STEP_AFTER_WORKFLOW_READY)",
+    );
 
     expect(experienceSource).toContain('title="Setup complete"');
     expect(experienceSource).toContain("readiness.readyForFirstRun");