@mycadet/assistant 0.12.10 → 0.13.0

package/src/__tests__/rebind-secrets-screen.test.ts

@@ -1,876 +0,0 @@
-/**
- * Tests for the rebind secrets screen view model.
- *
- * Covers:
- * - Disabled state: screen not accessible when earlier steps incomplete
- * - Active state: checklist displayed with tasks and progress tracking
- * - Complete state: all required tasks done, migration finalized
- * - Task management: toggle, mark complete, mark pending
- * - Task completion state: fresh state, required task gating
- * - Complete migration action: requires all required tasks, delegates to wizard
- * - Back navigation: return to transfer step
- * - Non-skippable tasks: required tasks prevent completion when pending
- * - Query helpers: accessibility, task IDs, counts
- * - State persistence/resume: derive correct screen state after resume
- * - Task definitions: correct metadata for all tasks
- */
-
-import { describe, expect, test } from "bun:test";
-
-import type {
-  ImportCommitResponse,
-  ImportPreflightResponse,
-  ValidateResponse,
-} from "../runtime/migrations/migration-transport.js";
-import type {
-  MigrationWizardState,
-  WizardStep,
-} from "../runtime/migrations/migration-wizard.js";
-import {
-  completeRebindSecrets,
-  createWizardState,
-  deserializeWizardState,
-  isWizardComplete,
-  prepareForResume,
-  selectDirection,
-  serializeWizardState,
-  setBundleUploaded,
-} from "../runtime/migrations/migration-wizard.js";
-import type { RebindTaskCompletionState } from "../runtime/migrations/rebind-secrets-screen.js";
-import {
-  areAllRequiredTasksComplete,
-  completeMigration,
-  createTaskCompletionState,
-  deriveRebindSecretsScreenState,
-  getRequiredTaskCount,
-  getTaskIds,
-  getTotalTaskCount,
-  goBackToTransfer,
-  isRebindSecretsScreenAccessible,
-  markTaskComplete,
-  markTaskPending,
-  toggleTaskCompletion,
-} from "../runtime/migrations/rebind-secrets-screen.js";
-
-// ---------------------------------------------------------------------------
-// Test helpers
-// ---------------------------------------------------------------------------
-
-function makeValidateSuccess(): ValidateResponse {
-  return {
-    is_valid: true,
-    errors: [],
-    manifest: {
-      schema_version: 1,
-      bundle_id: "00000000-0000-4000-8000-000000000000",
-      created_at: "2026-03-01T00:00:00Z",
-      assistant: { id: "self", name: "Test", runtime_version: "0.0.0-test" },
-      origin: { mode: "self-hosted-local" },
-      compatibility: {
-        min_runtime_version: "0.0.0-test",
-        max_runtime_version: null,
-      },
-      contents: [{ path: "config.json", sha256: "abc123", size_bytes: 1024 }],
-      checksum: "manifest-hash",
-      secrets_redacted: false,
-      export_options: {
-        include_logs: false,
-        include_browser_state: false,
-        include_memory_vectors: false,
-      },
-    },
-  };
-}
-
-function makePreflightSuccess(): ImportPreflightResponse {
-  return {
-    can_import: true,
-    summary: {
-      total_files: 3,
-      files_to_create: 1,
-      files_to_overwrite: 1,
-      files_unchanged: 1,
-      files_to_skip: 0,
-    },
-    files: [
-      {
-        path: "config.json",
-        action: "overwrite",
-        bundle_size: 1024,
-        current_size: 800,
-        bundle_sha256: "abc123",
-        current_sha256: "old123",
-      },
-    ],
-    conflicts: [],
-    manifest: {
-      schema_version: 1,
-      bundle_id: "00000000-0000-4000-8000-000000000000",
-      created_at: "2026-03-01T00:00:00Z",
-      assistant: { id: "self", name: "Test", runtime_version: "0.0.0-test" },
-      origin: { mode: "self-hosted-local" },
-      compatibility: {
-        min_runtime_version: "0.0.0-test",
-        max_runtime_version: null,
-      },
-      contents: [{ path: "config.json", sha256: "abc123", size_bytes: 1024 }],
-      checksum: "manifest-hash",
-      secrets_redacted: false,
-      export_options: {
-        include_logs: false,
-        include_browser_state: false,
-        include_memory_vectors: false,
-      },
-    },
-  };
-}
-
-function makeImportSuccess(): ImportCommitResponse {
-  return {
-    success: true,
-    summary: {
-      total_files: 3,
-      files_created: 1,
-      files_overwritten: 1,
-      files_skipped: 1,
-      backups_created: 1,
-    },
-    files: [
-      {
-        path: "config.json",
-        disk_path: "/data/config.json",
-        action: "overwritten",
-        size: 1024,
-        sha256: "abc123",
-        backup_path: "/data/config.json.bak",
-      },
-    ],
-    manifest: {
-      schema_version: 1,
-      bundle_id: "00000000-0000-4000-8000-000000000000",
-      created_at: "2026-03-01T00:00:00Z",
-      assistant: { id: "self", name: "Test", runtime_version: "0.0.0-test" },
-      origin: { mode: "self-hosted-local" },
-      compatibility: {
-        min_runtime_version: "0.0.0-test",
-        max_runtime_version: null,
-      },
-      contents: [{ path: "config.json", sha256: "abc123", size_bytes: 1024 }],
-      checksum: "manifest-hash",
-      secrets_redacted: false,
-      export_options: {
-        include_logs: false,
-        include_browser_state: false,
-        include_memory_vectors: false,
-      },
-    },
-    warnings: ["Backup created for config.json"],
-  };
-}
-
-/** Advance state to a specific step for testing. */
-function advanceTo(step: WizardStep): MigrationWizardState {
-  let state = createWizardState();
-  const stepOrder: WizardStep[] = [
-    "select-direction",
-    "upload-bundle",
-    "validate",
-    "preflight-review",
-    "transfer",
-    "rebind-secrets",
-    "complete",
-  ];
-  const targetIdx = stepOrder.indexOf(step);
-
-  if (targetIdx >= 1) {
-    state = selectDirection(state, "managed-to-self-hosted");
-  }
-  if (targetIdx >= 2) {
-    state = setBundleUploaded(state);
-  }
-  if (targetIdx >= 3) {
-    state = {
-      ...state,
-      steps: { ...state.steps, validate: { status: "success" } },
-      validateResult: makeValidateSuccess(),
-      currentStep: "preflight-review",
-    };
-  }
-  if (targetIdx >= 4) {
-    state = {
-      ...state,
-      steps: { ...state.steps, "preflight-review": { status: "success" } },
-      preflightResult: makePreflightSuccess(),
-      currentStep: "transfer",
-    };
-  }
-  if (targetIdx >= 5) {
-    state = {
-      ...state,
-      steps: { ...state.steps, transfer: { status: "success" } },
-      importResult: makeImportSuccess(),
-      currentStep: "rebind-secrets",
-    };
-  }
-  if (targetIdx >= 6) {
-    state = completeRebindSecrets(state);
-  }
-
-  return state;
-}
-
-/** Mark all required tasks as complete. */
-function completeAllRequired(
-  state: RebindTaskCompletionState,
-): RebindTaskCompletionState {
-  let current = state;
-  const taskIds = getTaskIds();
-  for (const id of taskIds) {
-    // We need to know which are required -- use the screen to check
-    // For simplicity, mark all tasks complete
-    current = markTaskComplete(current, id);
-  }
-  return current;
-}
-
-/** Mark only the required tasks as complete (re-enter-secrets, rebind-channels, reconfigure-auth). */
-function completeOnlyRequired(
-  state: RebindTaskCompletionState,
-): RebindTaskCompletionState {
-  let current = state;
-  current = markTaskComplete(current, "re-enter-secrets");
-  current = markTaskComplete(current, "rebind-channels");
-  current = markTaskComplete(current, "reconfigure-auth");
-  return current;
-}
-
-// ---------------------------------------------------------------------------
-// Disabled state
-// ---------------------------------------------------------------------------
-
-describe("deriveRebindSecretsScreenState -- disabled", () => {
-  test("returns disabled when on select-direction step", () => {
-    const state = createWizardState();
-    const completion = createTaskCompletionState();
-    const screen = deriveRebindSecretsScreenState(state, completion);
-    expect(screen.phase).toBe("disabled");
-  });
-
-  test("returns disabled when on upload-bundle step", () => {
-    const state = advanceTo("upload-bundle");
-    const completion = createTaskCompletionState();
-    const screen = deriveRebindSecretsScreenState(state, completion);
-    expect(screen.phase).toBe("disabled");
-  });
-
-  test("returns disabled when on validate step", () => {
-    const state = advanceTo("validate");
-    const completion = createTaskCompletionState();
-    const screen = deriveRebindSecretsScreenState(state, completion);
-    expect(screen.phase).toBe("disabled");
-  });
-
-  test("returns disabled when on preflight-review step", () => {
-    const state = advanceTo("preflight-review");
-    const completion = createTaskCompletionState();
-    const screen = deriveRebindSecretsScreenState(state, completion);
-    expect(screen.phase).toBe("disabled");
-  });
-
-  test("returns disabled when on transfer step (not yet completed)", () => {
-    const state = advanceTo("transfer");
-    const completion = createTaskCompletionState();
-    const screen = deriveRebindSecretsScreenState(state, completion);
-    expect(screen.phase).toBe("disabled");
-  });
-
-  test("isRebindSecretsScreenAccessible returns false for early steps", () => {
-    expect(isRebindSecretsScreenAccessible(createWizardState())).toBe(false);
-  });
-
-  test("isRebindSecretsScreenAccessible returns false for transfer step", () => {
-    const state = advanceTo("transfer");
-    expect(isRebindSecretsScreenAccessible(state)).toBe(false);
-  });
-
-  test("isRebindSecretsScreenAccessible returns true for rebind-secrets step", () => {
-    const state = advanceTo("rebind-secrets");
-    expect(isRebindSecretsScreenAccessible(state)).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Active state
-// ---------------------------------------------------------------------------
-
-describe("deriveRebindSecretsScreenState -- active", () => {
-  test("shows active with all tasks pending when first entering step", () => {
-    const state = advanceTo("rebind-secrets");
-    const completion = createTaskCompletionState();
-    const screen = deriveRebindSecretsScreenState(state, completion);
-    expect(screen.phase).toBe("active");
-    if (screen.phase === "active") {
-      expect(screen.tasks).toHaveLength(4);
-      expect(screen.completedCount).toBe(0);
-      expect(screen.totalCount).toBe(4);
-      expect(screen.allRequiredComplete).toBe(false);
-    }
-  });
-
-  test("tracks required task counts correctly", () => {
-    const state = advanceTo("rebind-secrets");
-    const completion = createTaskCompletionState();
-    const screen = deriveRebindSecretsScreenState(state, completion);
-    if (screen.phase === "active") {
-      expect(screen.requiredCount).toBe(3);
-      expect(screen.requiredCompletedCount).toBe(0);
-    }
-  });
-
-  test("updates progress when tasks are completed", () => {
-    const state = advanceTo("rebind-secrets");
-    let completion = createTaskCompletionState();
-    completion = markTaskComplete(completion, "re-enter-secrets");
-    completion = markTaskComplete(completion, "rebind-channels");
-
-    const screen = deriveRebindSecretsScreenState(state, completion);
-    if (screen.phase === "active") {
-      expect(screen.completedCount).toBe(2);
-      expect(screen.requiredCompletedCount).toBe(2);
-      expect(screen.allRequiredComplete).toBe(false);
-    }
-  });
-
-  test("allRequiredComplete is true when all required tasks are done", () => {
-    const state = advanceTo("rebind-secrets");
-    const completion = completeOnlyRequired(createTaskCompletionState());
-
-    const screen = deriveRebindSecretsScreenState(state, completion);
-    if (screen.phase === "active") {
-      expect(screen.allRequiredComplete).toBe(true);
-      expect(screen.requiredCompletedCount).toBe(3);
-      // Optional task (verify-webhooks) is still pending
-      expect(screen.completedCount).toBe(3);
-    }
-  });
-
-  test("allRequiredComplete is true even when optional tasks are pending", () => {
-    const state = advanceTo("rebind-secrets");
-    const completion = completeOnlyRequired(createTaskCompletionState());
-
-    const screen = deriveRebindSecretsScreenState(state, completion);
-    if (screen.phase === "active") {
-      expect(screen.allRequiredComplete).toBe(true);
-      // verify-webhooks is optional and still pending
-      const webhookTask = screen.tasks.find((t) => t.id === "verify-webhooks");
-      expect(webhookTask?.status).toBe("pending");
-      expect(webhookTask?.required).toBe(false);
-    }
-  });
-
-  test("each task has correct metadata", () => {
-    const state = advanceTo("rebind-secrets");
-    const completion = createTaskCompletionState();
-    const screen = deriveRebindSecretsScreenState(state, completion);
-    if (screen.phase === "active") {
-      const secretsTask = screen.tasks.find((t) => t.id === "re-enter-secrets");
-      expect(secretsTask).toBeDefined();
-      expect(secretsTask!.title).toContain("API keys");
-      expect(secretsTask!.description).toContain("redacted");
-      expect(secretsTask!.required).toBe(true);
-      expect(secretsTask!.helpText).toBeDefined();
-
-      const channelsTask = screen.tasks.find((t) => t.id === "rebind-channels");
-      expect(channelsTask).toBeDefined();
-      expect(channelsTask!.title).toContain("communication channels");
-      expect(channelsTask!.required).toBe(true);
-
-      const authTask = screen.tasks.find((t) => t.id === "reconfigure-auth");
-      expect(authTask).toBeDefined();
-      expect(authTask!.title).toContain("identity");
-      expect(authTask!.required).toBe(true);
-
-      const webhookTask = screen.tasks.find((t) => t.id === "verify-webhooks");
-      expect(webhookTask).toBeDefined();
-      expect(webhookTask!.title).toContain("webhook");
-      expect(webhookTask!.required).toBe(false);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Complete state
-// ---------------------------------------------------------------------------
-
-describe("deriveRebindSecretsScreenState -- complete", () => {
-  test("shows complete after wizard rebind-secrets step succeeds", () => {
-    const state = advanceTo("complete");
-    const completion = completeAllRequired(createTaskCompletionState());
-    const screen = deriveRebindSecretsScreenState(state, completion);
-    expect(screen.phase).toBe("complete");
-    if (screen.phase === "complete") {
-      expect(screen.tasks).toHaveLength(4);
-    }
-  });
-
-  test("complete state includes task statuses from completion state", () => {
-    const state = advanceTo("complete");
-    const completion = completeAllRequired(createTaskCompletionState());
-    const screen = deriveRebindSecretsScreenState(state, completion);
-    if (screen.phase === "complete") {
-      const allComplete = screen.tasks.every((t) => t.status === "complete");
-      expect(allComplete).toBe(true);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Task completion state management
-// ---------------------------------------------------------------------------
-
-describe("createTaskCompletionState", () => {
-  test("creates state with all tasks pending", () => {
-    const state = createTaskCompletionState();
-    expect(state["re-enter-secrets"]).toBe(false);
-    expect(state["rebind-channels"]).toBe(false);
-    expect(state["reconfigure-auth"]).toBe(false);
-    expect(state["verify-webhooks"]).toBe(false);
-  });
-});
-
-describe("toggleTaskCompletion", () => {
-  test("toggles a pending task to complete", () => {
-    const state = createTaskCompletionState();
-    const updated = toggleTaskCompletion(state, "re-enter-secrets");
-    expect(updated["re-enter-secrets"]).toBe(true);
-    // Other tasks unchanged
-    expect(updated["rebind-channels"]).toBe(false);
-  });
-
-  test("toggles a complete task back to pending", () => {
-    let state = createTaskCompletionState();
-    state = markTaskComplete(state, "re-enter-secrets");
-    const updated = toggleTaskCompletion(state, "re-enter-secrets");
-    expect(updated["re-enter-secrets"]).toBe(false);
-  });
-
-  test("returns a new object (immutable)", () => {
-    const state = createTaskCompletionState();
-    const updated = toggleTaskCompletion(state, "re-enter-secrets");
-    expect(updated).not.toBe(state);
-    expect(state["re-enter-secrets"]).toBe(false);
-  });
-});
-
-describe("markTaskComplete", () => {
-  test("marks a task as complete", () => {
-    const state = createTaskCompletionState();
-    const updated = markTaskComplete(state, "rebind-channels");
-    expect(updated["rebind-channels"]).toBe(true);
-  });
-
-  test("is idempotent for already-complete tasks", () => {
-    let state = createTaskCompletionState();
-    state = markTaskComplete(state, "rebind-channels");
-    const updated = markTaskComplete(state, "rebind-channels");
-    expect(updated["rebind-channels"]).toBe(true);
-  });
-});
-
-describe("markTaskPending", () => {
-  test("marks a complete task as pending", () => {
-    let state = createTaskCompletionState();
-    state = markTaskComplete(state, "reconfigure-auth");
-    const updated = markTaskPending(state, "reconfigure-auth");
-    expect(updated["reconfigure-auth"]).toBe(false);
-  });
-
-  test("is idempotent for already-pending tasks", () => {
-    const state = createTaskCompletionState();
-    const updated = markTaskPending(state, "reconfigure-auth");
-    expect(updated["reconfigure-auth"]).toBe(false);
-  });
-});
-
-describe("areAllRequiredTasksComplete", () => {
-  test("returns false when no tasks are complete", () => {
-    const state = createTaskCompletionState();
-    expect(areAllRequiredTasksComplete(state)).toBe(false);
-  });
-
-  test("returns false when only some required tasks are complete", () => {
-    let state = createTaskCompletionState();
-    state = markTaskComplete(state, "re-enter-secrets");
-    state = markTaskComplete(state, "rebind-channels");
-    expect(areAllRequiredTasksComplete(state)).toBe(false);
-  });
-
-  test("returns true when all required tasks are complete", () => {
-    const state = completeOnlyRequired(createTaskCompletionState());
-    expect(areAllRequiredTasksComplete(state)).toBe(true);
-  });
-
-  test("returns true when all tasks (including optional) are complete", () => {
-    const state = completeAllRequired(createTaskCompletionState());
-    expect(areAllRequiredTasksComplete(state)).toBe(true);
-  });
-
-  test("ignores optional tasks when checking required completion", () => {
-    let state = createTaskCompletionState();
-    // Complete only the optional task
-    state = markTaskComplete(state, "verify-webhooks");
-    expect(areAllRequiredTasksComplete(state)).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Complete migration action
-// ---------------------------------------------------------------------------
-
-describe("completeMigration", () => {
-  test("advances wizard to complete when all required tasks are done", () => {
-    const wizardState = advanceTo("rebind-secrets");
-    const completion = completeOnlyRequired(createTaskCompletionState());
-
-    const result = completeMigration(wizardState, completion);
-    expect(result.currentStep).toBe("complete");
-    expect(result.steps["rebind-secrets"].status).toBe("success");
-    expect(result.steps["complete"].status).toBe("success");
-    expect(isWizardComplete(result)).toBe(true);
-  });
-
-  test("throws when required tasks are incomplete", () => {
-    const wizardState = advanceTo("rebind-secrets");
-    const completion = createTaskCompletionState();
-
-    expect(() => completeMigration(wizardState, completion)).toThrow(
-      "not all required tasks are done",
-    );
-  });
-
-  test("throws when only optional tasks are complete", () => {
-    const wizardState = advanceTo("rebind-secrets");
-    let completion = createTaskCompletionState();
-    completion = markTaskComplete(completion, "verify-webhooks");
-
-    expect(() => completeMigration(wizardState, completion)).toThrow(
-      "not all required tasks are done",
-    );
-  });
-
-  test("throws when called from wrong wizard step", () => {
-    const wizardState = advanceTo("transfer");
-    const completion = completeAllRequired(createTaskCompletionState());
-
-    expect(() => completeMigration(wizardState, completion)).toThrow(
-      "wrong step",
-    );
-  });
-
-  test("succeeds with all tasks complete (including optional)", () => {
-    const wizardState = advanceTo("rebind-secrets");
-    const completion = completeAllRequired(createTaskCompletionState());
-
-    const result = completeMigration(wizardState, completion);
-    expect(result.currentStep).toBe("complete");
-    expect(isWizardComplete(result)).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Back navigation
-// ---------------------------------------------------------------------------
-
-describe("goBackToTransfer", () => {
-  test("navigates back to transfer from rebind-secrets", () => {
-    const state = advanceTo("rebind-secrets");
-    const { wizardState } = goBackToTransfer(state);
-    expect(wizardState.currentStep).toBe("transfer");
-    expect(wizardState.steps["rebind-secrets"].status).toBe("idle");
-  });
-
-  test("clears export and import results when going back to transfer", () => {
-    let state = advanceTo("rebind-secrets");
-    state = {
-      ...state,
-      exportResult: {
-        ok: true,
-        filename: "export.vbundle",
-        schemaVersion: 1,
-        checksum: "abc",
-      },
-      importResult: makeImportSuccess(),
-    };
-    const { wizardState } = goBackToTransfer(state);
-    expect(wizardState.exportResult).toBeUndefined();
-    expect(wizardState.importResult).toBeUndefined();
-  });
-
-  test("preserves validation and preflight results when going back to transfer", () => {
-    let state = advanceTo("rebind-secrets");
-    state = {
-      ...state,
-      validateResult: makeValidateSuccess(),
-      preflightResult: makePreflightSuccess(),
-    };
-    const { wizardState } = goBackToTransfer(state);
-    expect(wizardState.validateResult).toBeDefined();
-    expect(wizardState.preflightResult).toBeDefined();
-  });
-
-  test("resets task completion state when going back to transfer", () => {
-    const state = advanceTo("rebind-secrets");
-    const { completionState } = goBackToTransfer(state);
-    const taskIds = getTaskIds();
-    for (const id of taskIds) {
-      expect(completionState[id]).toBe(false);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Non-skippable task enforcement
-// ---------------------------------------------------------------------------
-
-describe("non-skippable required tasks", () => {
-  test("cannot complete migration with re-enter-secrets pending", () => {
-    const wizardState = advanceTo("rebind-secrets");
-    let completion = createTaskCompletionState();
-    completion = markTaskComplete(completion, "rebind-channels");
-    completion = markTaskComplete(completion, "reconfigure-auth");
-    // re-enter-secrets is still pending
-
-    expect(() => completeMigration(wizardState, completion)).toThrow(
-      "not all required tasks are done",
-    );
-  });
-
-  test("cannot complete migration with rebind-channels pending", () => {
-    const wizardState = advanceTo("rebind-secrets");
-    let completion = createTaskCompletionState();
-    completion = markTaskComplete(completion, "re-enter-secrets");
-    completion = markTaskComplete(completion, "reconfigure-auth");
-    // rebind-channels is still pending
-
-    expect(() => completeMigration(wizardState, completion)).toThrow(
-      "not all required tasks are done",
-    );
-  });
-
-  test("cannot complete migration with reconfigure-auth pending", () => {
-    const wizardState = advanceTo("rebind-secrets");
-    let completion = createTaskCompletionState();
-    completion = markTaskComplete(completion, "re-enter-secrets");
-    completion = markTaskComplete(completion, "rebind-channels");
-    // reconfigure-auth is still pending
-
-    expect(() => completeMigration(wizardState, completion)).toThrow(
-      "not all required tasks are done",
-    );
-  });
-
-  test("can complete migration with verify-webhooks (optional) pending", () => {
-    const wizardState = advanceTo("rebind-secrets");
-    const completion = completeOnlyRequired(createTaskCompletionState());
-    // verify-webhooks is still pending, but it's optional
-
-    const result = completeMigration(wizardState, completion);
-    expect(result.currentStep).toBe("complete");
-  });
-
-  test("allRequiredComplete in screen state correctly gates completion", () => {
-    const wizardState = advanceTo("rebind-secrets");
-
-    // No tasks complete
-    const screen1 = deriveRebindSecretsScreenState(
-      wizardState,
-      createTaskCompletionState(),
-    );
-    if (screen1.phase === "active") {
-      expect(screen1.allRequiredComplete).toBe(false);
-    }
-
-    // Some required tasks complete
-    let partial = createTaskCompletionState();
-    partial = markTaskComplete(partial, "re-enter-secrets");
-    const screen2 = deriveRebindSecretsScreenState(wizardState, partial);
-    if (screen2.phase === "active") {
-      expect(screen2.allRequiredComplete).toBe(false);
-    }
-
-    // All required complete
-    const allReq = completeOnlyRequired(createTaskCompletionState());
-    const screen3 = deriveRebindSecretsScreenState(wizardState, allReq);
-    if (screen3.phase === "active") {
-      expect(screen3.allRequiredComplete).toBe(true);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Query helpers
-// ---------------------------------------------------------------------------
-
-describe("query helpers", () => {
-  test("getTaskIds returns all task IDs in order", () => {
-    const ids = getTaskIds();
-    expect(ids).toEqual([
-      "re-enter-secrets",
-      "rebind-channels",
-      "reconfigure-auth",
-      "verify-webhooks",
-    ]);
-  });
-
-  test("getRequiredTaskCount returns count of required tasks", () => {
-    expect(getRequiredTaskCount()).toBe(3);
-  });
-
-  test("getTotalTaskCount returns total task count", () => {
-    expect(getTotalTaskCount()).toBe(4);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// State persistence and resume
-// ---------------------------------------------------------------------------
-
-describe("rebind secrets screen state persistence/resume", () => {
-  test("derives correct state after serialize + deserialize at rebind-secrets step", () => {
-    const state = advanceTo("rebind-secrets");
-    const json = serializeWizardState(state);
-    const restored = deserializeWizardState(json);
-    expect(restored).toBeDefined();
-
-    const completion = createTaskCompletionState();
-    const screen = deriveRebindSecretsScreenState(restored!, completion);
-    expect(screen.phase).toBe("active");
-    if (screen.phase === "active") {
-      expect(screen.tasks).toHaveLength(4);
-      expect(screen.completedCount).toBe(0);
-    }
-  });
-
-  test("derives correct state after resume at rebind-secrets step", () => {
-    const state = advanceTo("rebind-secrets");
-    const json = serializeWizardState(state);
-    const restored = deserializeWizardState(json);
-    expect(restored).toBeDefined();
-
-    // prepareForResume does not redirect rebind-secrets (no bundle data needed)
-    const resumed = prepareForResume(restored!);
-    expect(resumed.currentStep).toBe("rebind-secrets");
-
-    const completion = createTaskCompletionState();
-    const screen = deriveRebindSecretsScreenState(resumed, completion);
-    expect(screen.phase).toBe("active");
-  });
-
-  test("complete state persists across serialize/deserialize", () => {
-    const state = advanceTo("complete");
-    const json = serializeWizardState(state);
-    const restored = deserializeWizardState(json);
-    expect(restored).toBeDefined();
-
-    const completion = completeAllRequired(createTaskCompletionState());
-    const screen = deriveRebindSecretsScreenState(restored!, completion);
-    expect(screen.phase).toBe("complete");
-  });
-
-  test("task completion state is independently serializable", () => {
-    let completion = createTaskCompletionState();
-    completion = markTaskComplete(completion, "re-enter-secrets");
-    completion = markTaskComplete(completion, "rebind-channels");
-
-    const json = JSON.stringify(completion);
-    const restored = JSON.parse(json) as RebindTaskCompletionState;
-
-    expect(restored["re-enter-secrets"]).toBe(true);
-    expect(restored["rebind-channels"]).toBe(true);
-    expect(restored["reconfigure-auth"]).toBe(false);
-    expect(restored["verify-webhooks"]).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Edge cases
-// ---------------------------------------------------------------------------
-
-describe("rebind secrets screen edge cases", () => {
-  test("handles rebind-secrets step at complete state -- complete visible", () => {
-    const state = advanceTo("complete");
-    const completion = completeAllRequired(createTaskCompletionState());
-    const screen = deriveRebindSecretsScreenState(state, completion);
-    expect(screen.phase).toBe("complete");
-  });
-
-  test("returns disabled when transfer step has error", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        transfer: {
-          status: "error",
-          error: { message: "Transfer failed", retryable: true },
-        },
-      },
-    };
-    const completion = createTaskCompletionState();
-    const screen = deriveRebindSecretsScreenState(state, completion);
-    expect(screen.phase).toBe("disabled");
-  });
-
-  test("toggling tasks does not modify original state", () => {
-    const original = createTaskCompletionState();
-    const modified = toggleTaskCompletion(original, "re-enter-secrets");
-
-    expect(original["re-enter-secrets"]).toBe(false);
-    expect(modified["re-enter-secrets"]).toBe(true);
-  });
-
-  test("screen reflects toggled task status correctly", () => {
-    const wizardState = advanceTo("rebind-secrets");
-    let completion = createTaskCompletionState();
-
-    // Toggle re-enter-secrets on
-    completion = toggleTaskCompletion(completion, "re-enter-secrets");
-    let screen = deriveRebindSecretsScreenState(wizardState, completion);
-    if (screen.phase === "active") {
-      const task = screen.tasks.find((t) => t.id === "re-enter-secrets");
-      expect(task?.status).toBe("complete");
-    }
-
-    // Toggle re-enter-secrets off
-    completion = toggleTaskCompletion(completion, "re-enter-secrets");
-    screen = deriveRebindSecretsScreenState(wizardState, completion);
-    if (screen.phase === "active") {
-      const task = screen.tasks.find((t) => t.id === "re-enter-secrets");
-      expect(task?.status).toBe("pending");
-    }
-  });
-
-  test("all tasks have non-empty title and description", () => {
-    const wizardState = advanceTo("rebind-secrets");
-    const completion = createTaskCompletionState();
-    const screen = deriveRebindSecretsScreenState(wizardState, completion);
-    if (screen.phase === "active") {
-      for (const task of screen.tasks) {
-        expect(task.title.length).toBeGreaterThan(0);
-        expect(task.description.length).toBeGreaterThan(0);
-      }
-    }
-  });
-
-  test("all tasks have help text", () => {
-    const wizardState = advanceTo("rebind-secrets");
-    const completion = createTaskCompletionState();
-    const screen = deriveRebindSecretsScreenState(wizardState, completion);
-    if (screen.phase === "active") {
-      for (const task of screen.tasks) {
-        expect(task.helpText).toBeDefined();
-        expect(task.helpText!.length).toBeGreaterThan(0);
-      }
-    }
-  });
-});