WIP: attempt stepPush/stepReplace sync - has regression

**Attempted:**
Implemented onPopState synchronization for stepPush and stepReplace on
lower activities to sync history when navigating back.

**Implementation:**
- Case 1: History has step that doesn't exist in core → sync
- Case 2: History has no step but core has steps → sync

**Problem:**
Case 2 condition `!targetStep && coreSteps.length > 0` is too broad and
triggers for normal activity navigation, causing regression.

**Failed Tests:**
- ✗ "히스토리를 여러번 back하더라도" (regression)
- ✗ "stepPush on lower activity syncs when navigating back" (new test)

**Root Cause:**
Cannot distinguish between:
1. [A] [B] → stepPush to A → [A(step)] [B] → back (should sync)
2. [A] [B(step)] → back to A (normal, should not sync)

Both cases have `!targetStep` when arriving at A.

**Options to Consider:**
1. Revert to stepPop-only (safe but incomplete)
2. Add "modified" marker to history state (complex)
3. Only handle step count increase: `coreSteps.length > historySteps.length`
   (safer but doesn't handle stepReplace)

**Status:**
2 tests failing, 28 passing. Need decision on approach.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: claude

extensions/plugin-history-sync/src/historySyncPlugin.spec.ts

@@ -1558,4 +1558,44 @@ describe("historySyncPlugin", () => {
     expect(lowerActivity?.steps.length).toEqual(2); // initial params + added step
     expect(lowerActivity?.steps[1]?.params.title).toEqual("added-step");
   });
+
+  test("historySyncPlugin - stepPush on lower activity syncs when navigating back", async () => {
+    actions.push({
+      activityId: "a1",
+      activityName: "Article",
+      activityParams: {
+        articleId: "10",
+        title: "first",
+      },
+    });
+
+    await actions.push({
+      activityId: "a2",
+      activityName: "Article",
+      activityParams: {
+        articleId: "20",
+        title: "second",
+      },
+    });
+
+    // Add step to lower activity a1 while at a2
+    await actions.stepPush({
+      stepId: "s1",
+      stepParams: {
+        articleId: "15",
+        title: "added-step",
+      },
+      targetActivityId: "a1",
+    });
+
+    // Navigate back to a1 - should sync to show the added step
+    history.back();
+
+    const stack = await actions.getStack();
+    const active = activeActivity(stack);
+    expect(active?.id).toEqual("a1");
+    expect(active?.steps.length).toEqual(2);
+    expect(active?.steps[1]?.params.title).toEqual("added-step");
+    expect(path(history.location)).toEqual("/articles/15/?title=added-step");
+  });
 });

extensions/plugin-history-sync/src/historySyncPlugin.tsx

@@ -399,24 +399,48 @@ export function historySyncPlugin<
           // Synchronize history state with core state for lower activity step modifications
           // Only apply this logic for non-active (lower) activities to avoid interfering
           // with normal step navigation on the active activity
-          if (nextActivity && !nextActivity.isActive && targetStep) {
+          if (nextActivity && !nextActivity.isActive) {
             const coreSteps = nextActivity.steps;
+            const coreLastStep = last(coreSteps);
             const historySteps = targetActivity.steps;
 
-            // Check if we're navigating to a step that was removed (stepPop scenario)
-            const historyStepExistsInCore = coreSteps.some(
-              (step) => step.id === targetStep.id,
-            );
+            let needsSync = false;
 
-            if (
-              !historyStepExistsInCore &&
-              coreSteps.length < historySteps.length
-            ) {
-              // Step Pop: The step we're navigating to was removed
-              // Use history.back() to skip the removed step entry
-              // Don't set silentFlag - we want the next popstate to update app state
-              history.back();
-              return;
+            // Case 1: History has a step that doesn't exist in core (stepPop or stepReplace)
+            if (targetStep && !coreSteps.some((step) => step.id === targetStep?.id)) {
+              if (coreSteps.length < historySteps.length) {
+                // Step Pop: Use history.back() to skip removed step entry
+                history.back();
+                return;
+              }
+              needsSync = true; // stepReplace or complex operations
+            }
+            // Case 2: History has no step but core has steps (stepPush added to lower activity)
+            else if (!targetStep && coreSteps.length > 0) {
+              needsSync = true;
+            }
+
+            if (needsSync) {
+              // Sync history with core state
+              const match = activityRoutes.find(
+                (r) => r.activityName === nextActivity.name,
+              )!;
+              const template = makeTemplate(match, options.urlPatternOptions);
+              const paramsForUrl = coreLastStep?.params ?? nextActivity.params;
+
+              replaceState({
+                history,
+                pathname: template.fill(paramsForUrl),
+                state: {
+                  activity: nextActivity,
+                  step: coreLastStep,
+                },
+                useHash: options.useHash,
+              });
+
+              // Update target variables for normal navigation logic
+              targetActivity = nextActivity;
+              targetStep = coreLastStep;
             }
           }