From 82b158c1709666afd4b611e4d588dab6c04dd288 Mon Sep 17 00:00:00 2001
From: Albrecht Degering <albrecht@degering.name>
Date: Tue, 21 Jul 2026 21:17:26 +0200
Subject: [PATCH] feat(scheduling-webui): build two-pane request workspace

---
 .../test-scheduling-page-structure.mjs        |  114 +-
 webui/src/api/scheduling.ts                   |  159 +-
 .../features/scheduling/SchedulingPage.tsx    | 1510 ++++++++++++-----
 .../scheduling/schedulingViewModel.ts         |   45 +-
 webui/src/i18n/generatedTranslations.ts       |   68 +-
 webui/src/styles/scheduling.css               |  227 ++-
 webui/tests/scheduling-view-model.test.ts     |   63 +
 7 files changed, 1559 insertions(+), 627 deletions(-)

diff --git a/webui/scripts/test-scheduling-page-structure.mjs b/webui/scripts/test-scheduling-page-structure.mjs
index 6a55a6d..6b7e28f 100644
--- a/webui/scripts/test-scheduling-page-structure.mjs
+++ b/webui/scripts/test-scheduling-page-structure.mjs
@@ -11,42 +11,60 @@ assert.match(page, /usePlatformUiCapability<CalendarPickerUiCapability>\("calend
 assert.match(page, /hasScope\(auth, "calendar:calendar:read"\)/);
 assert.match(page, /Boolean\(calendarPickerCapability\) && canReadCalendars && canReadAvailability && canWriteCalendarEvent/);
 assert.doesNotMatch(page, /@govoplan\/calendar-webui|govoplan-calendar\/webui/);
-assert.match(page, /Card,[\s\S]*DataGrid,[\s\S]*DataGridEmptyAction,[\s\S]*DataGridRowActions,[\s\S]*ModuleSubnav,[\s\S]*ToggleSwitch,[\s\S]*from "@govoplan\/core-webui"/);
-assert.match(page, /SelectionList,[\s\S]*SelectionListItem,[\s\S]*from "@govoplan\/core-webui"/);
+assert.match(page, /Card,[\s\S]*DataGrid,[\s\S]*DataGridEmptyAction,[\s\S]*DataGridRowActions,[\s\S]*FormField,[\s\S]*MetricCard,[\s\S]*PasswordField,[\s\S]*SelectionList,[\s\S]*ToggleSwitch,[\s\S]*from "@govoplan\/core-webui"/);
 assert.doesNotMatch(page, /@govoplan\/core-webui\/src\//);
-assert.match(page, /className="scheduling-full-editor"/);
-assert.match(page, /className="scheduling-page-actions"/);
 
-const editorActions = page.slice(
-  page.indexOf('<div className="scheduling-page-actions">'),
-  page.indexOf('</div>', page.indexOf('<div className="scheduling-page-actions">'))
-);
-assert.ok(editorActions.indexOf("I18N.discard") < editorActions.indexOf("I18N.save"));
-assert.match(editorActions, /form="scheduling-create-form"/);
-
-const createBranchStart = page.indexOf("  if (creating) {");
-const createReturnStart = page.indexOf("\n    return (", createBranchStart);
-const browseBranchStart = page.indexOf("\n  return (", createReturnStart + 1);
-const createBranch = page.slice(createBranchStart, browseBranchStart);
-const browseBranch = page.slice(browseBranchStart);
-assert.match(createBranch, /<ModuleSubnav/);
-assert.match(createBranch, /className="scheduling-create-subnav"/);
-assert.doesNotMatch(browseBranch, /scheduling-sidebar|<aside/);
-
-assert.match(browseBranch, /<h1>\{I18N\.requests\}<\/h1>/);
-assert.match(browseBranch, /<Plus aria-hidden="true" size=\{16\} \/> \{I18N\.add\}/);
+assert.match(page, /className="scheduling-workspace-layout"/);
+assert.match(page, /<aside className="scheduling-request-sidebar">/);
+assert.match(page, /<section className="scheduling-main-panel">/);
+assert.match(page, /title=\{I18N\.requests\}[\s\S]*<Plus aria-hidden="true" size=\{16\} \/> \{I18N\.add\}/);
 assert.match(page, /title=\{I18N\.myRequests\}/);
 assert.match(page, /title=\{I18N\.invitedRequests\}/);
+assert.ok(page.indexOf("title={I18N.myRequests}") < page.indexOf("title={I18N.invitedRequests}"));
 assert.match(page, /<SelectionList label=\{title\} className="scheduling-request-list">/);
 assert.match(page, /<SelectionListItem[\s\S]*selected=\{selectedId === request\.id\}[\s\S]*className="scheduling-list-item"/);
-assert.doesNotMatch(page, /<button[\s\S]{0,160}scheduling-list-item/);
-assert.match(createBranch, /<Card title=\{I18N\.basicInformation\}>/);
-assert.match(createBranch, /<Card title=\{I18N\.calendarIntegration\}>/);
+
+assert.match(page, /editorMode \? \(/);
+assert.match(page, /id="scheduling-editor-form"/);
+assert.doesNotMatch(page, /ModuleSubnav|scheduling-create-subnav|scheduling-full-editor/);
+const editorStart = page.indexOf('<div className="scheduling-editor-surface">');
+const editorEnd = page.indexOf('</form>', editorStart);
+const editor = page.slice(editorStart, editorEnd);
+assert.ok(editor.indexOf("I18N.discard") < editor.indexOf("I18N.save"));
+assert.match(editor, /form="scheduling-editor-form"/);
+assert.match(editor, /<Card title=\{I18N\.basicInformation\}>/);
+assert.match(editor, /<Card title=\{I18N\.calendarIntegration\}>/);
 assert.match(page, /<Card title=\{I18N\.candidateSlots\}>/);
 assert.match(page, /<Card title=\{I18N\.participants\}>/);
-assert.match(createBranch, /<ToggleSwitch[\s\S]*checked=\{calendarEnabled\}/);
-assert.match(page, /<ToggleSwitch[\s\S]*checked=\{participantRosterVisible\}/);
-assert.match(page, /participant_visibility: participantRosterVisible \? "names_and_statuses" : "aggregates_only"/);
+assert.match(page, /<Card title=\{I18N\.generalSettings\}>/);
+assert.match(page, /<Card title=\{I18N\.participantPrivacy\}>/);
+assert.match(editor, /<FormField label=\{I18N\.title\}>/);
+assert.match(page, /useUnsavedDraftGuard\(/);
+assert.match(page, /requestDiscard\(exitEditor\)/);
+assert.match(page, /dirty: responseDirty,[\s\S]*onSave: persistAvailability,[\s\S]*onDiscard: resetResponseDraft/);
+assert.doesNotMatch(page, /window\.(?:alert|confirm)\(/);
+
+for (const setting of [
+  "participantRosterVisible",
+  "notifyOnAnswers",
+  "singleChoice",
+  "participantLimitEnabled",
+  "allowMaybe",
+  "allowComments",
+  "participantEmailRequired",
+  "anonymousPasswordProtectionEnabled"
+]) {
+  assert.match(page, new RegExp(`checked=\\{${setting}\\}`));
+}
+assert.match(page, /<PasswordField[\s\S]*minLength=\{8\}/);
+assert.match(page, /type="number"[\s\S]*min=\{1\}/);
+assert.match(page, /min=\{addLocalMinutes\(slot\.start_at, 1\)\}/);
+assert.match(page, /create_participant_invitations: true/);
+assert.doesNotMatch(page, /usesGatewayPolicy|updateSchedulingCandidateSlot/);
+assert.match(page, /public_participation_policy_enforcement_available/);
+assert.match(page, /const canCreateOrWrite = canWrite \|\| canAdminister/);
+assert.match(page, /policyLocked=\{participationPolicyLocked\}/);
+
 assert.match(page, /id="scheduling-create-candidate-slots-grid"/);
 assert.match(page, /id="scheduling-create-participants-grid"/);
 assert.match(page, /id="scheduling-candidate-slots-grid"/);
@@ -55,21 +73,43 @@ assert.match(page, /<DataGridRowActions/);
 assert.match(page, /<DataGridEmptyAction/);
 assert.doesNotMatch(page, /EmailAddressInput|MailboxAddress|addressSuggestions|addressLookupQuery/);
 assert.match(page, /type="email"[\s\S]*aria-label=\{I18N\.participantEmail\}/);
-assert.doesNotMatch(page, /header: I18N\.required|<table|scheduling-table|scheduling-card(?:\s|"|`)/);
-assert.match(page, /<TableActionGroup[\s\S]*label: i18nMessage\("i18n:govoplan-scheduling\.decide_on_value/);
+assert.doesNotMatch(page, /<table|scheduling-table|scheduling-card(?:\s|"|`)/);
+assert.match(page, /<TableActionGroup[\s\S]*disabled: saving \|\| !decisionEnabled/);
+assert.match(page, /showDecisionAction=\{canManageSelected\}/);
+assert.match(page, /<IconButton[\s\S]*label=\{I18N\.refresh\}/);
+assert.doesNotMatch(page, /AdminIconButton/);
+
 assert.match(page, /submitSchedulingAvailability\(settings, selected\.id/);
 assert.match(page, /option_revision: slot\.revision/);
 assert.match(page, /getSchedulingAvailabilityResponse\(settings, selected\.id\)/);
-assert.match(page, /setAvailability\(Object\.fromEntries\(response\.answers\.map/);
-assert.match(page, /selected\.participant_aggregate\.total/);
+assert.match(page, /const answers = Object\.fromEntries\(response\.answers\.map/);
+assert.match(page, /setSavedAvailability\(answers\)/);
+assert.match(page, /const comment = response\.comment \?\? ""/);
+assert.match(page, /setSavedAvailabilityComment\(comment\)/);
+assert.match(page, /<ParticipationStats/);
 assert.match(page, /selected\.effective_participant_visibility === "names_and_statuses"/);
-assert.match(api, /participant_visibility: SchedulingParticipantVisibility/);
-assert.match(api, /participant_aggregate: SchedulingParticipantAggregate/);
 assert.doesNotMatch(page, /<p>\{selected\.calendar_id\}<\/p>/);
 assert.match(page, /className="scheduling-selected-calendar"/);
-assert.match(page, /showPlanningCalendarActions/);
-assert.match(page, /title=\{!canReadAvailability \? I18N\.requiresAvailabilityRead/);
+
+for (const field of [
+  "notify_on_answers",
+  "single_choice",
+  "max_participants_per_option",
+  "allow_maybe",
+  "allow_comments",
+  "participant_email_required",
+  "anonymous_password_protection_enabled",
+  "public_participation_policy_enforcement_available"
+]) {
+  assert.match(api, new RegExp(`${field}:`));
+}
+assert.match(api, /method: "PATCH"/);
+assert.match(page, /slots: slots\.map\(\(slot\) => \(\{/);
+assert.match(page, /participants: participants[\s\S]*create_participant_invitations: true/);
 assert.match(api, /\/api\/v1\/scheduling\/requests\/\$\{requestId\}\/responses/);
 assert.match(api, /\/api\/v1\/scheduling\/requests\/\$\{requestId\}\/responses\/me/);
+assert.match(api, /\/api\/v1\/scheduling\/public\/\$\{encodeURIComponent\(requestId\)\}\/\$\{encodeURIComponent\(token\)\}/);
+assert.match(page, /useSearchParams\(\)/);
+assert.match(page, /Promise\.allSettled/);
 
-console.log("Scheduling page structure satisfies the focused list/create/respond contract.");
+console.log("Scheduling page structure satisfies the two-pane editor, response, and policy contract.");
diff --git a/webui/src/api/scheduling.ts b/webui/src/api/scheduling.ts
index ba33336..50b31a1 100644
--- a/webui/src/api/scheduling.ts
+++ b/webui/src/api/scheduling.ts
@@ -23,11 +23,12 @@ export type SchedulingCandidateSlot = {
 
 export type SchedulingParticipant = {
   id: string;
+  is_current_participant: boolean;
   respondent_id?: string | null;
   display_name?: string | null;
   email?: string | null;
-  participant_type: string;
-  required: boolean;
+  participant_type: string | null;
+  required: boolean | null;
   status: string;
   poll_invitation_id?: string | null;
   invitation_token?: string | null;
@@ -52,7 +53,7 @@ export type SchedulingParticipantVisibilityDecision = {
 
 export type SchedulingRequest = {
   id: string;
-  tenant_id: string;
+  tenant_id: string | null;
   title: string;
   description?: string | null;
   location?: string | null;
@@ -69,11 +70,20 @@ export type SchedulingRequest = {
   effective_participant_visibility: SchedulingParticipantVisibility;
   participant_aggregate: SchedulingParticipantAggregate;
   participant_visibility_decision: SchedulingParticipantVisibilityDecision;
-  calendar_integration_enabled: boolean;
+  notify_on_answers: boolean;
+  single_choice: boolean;
+  max_participants_per_option: number | null;
+  allow_maybe: boolean;
+  allow_comments: boolean;
+  participant_email_required: boolean;
+  anonymous_password_protection_enabled: boolean;
+  public_participation_policy_enforcement_available: boolean | null;
+  public_participation_policy_enforcement_reason?: string | null;
+  calendar_integration_enabled: boolean | null;
   calendar_id?: string | null;
-  calendar_freebusy_enabled: boolean;
-  calendar_hold_enabled: boolean;
-  create_calendar_event_on_decision: boolean;
+  calendar_freebusy_enabled: boolean | null;
+  calendar_hold_enabled: boolean | null;
+  create_calendar_event_on_decision: boolean | null;
   calendar_event_id?: string | null;
   handed_off_at?: string | null;
   cancelled_at?: string | null;
@@ -117,6 +127,14 @@ export type SchedulingRequestCreatePayload = {
   allow_participant_updates?: boolean;
   result_visibility?: "organizer" | "after_response" | "after_close" | "public";
   participant_visibility?: SchedulingParticipantVisibility;
+  notify_on_answers?: boolean;
+  single_choice?: boolean;
+  max_participants_per_option?: number | null;
+  allow_maybe?: boolean;
+  allow_comments?: boolean;
+  participant_email_required?: boolean;
+  anonymous_password_protection_enabled?: boolean;
+  anonymous_password?: string;
   calendar?: {
     enabled?: boolean;
     calendar_id?: string | null;
@@ -130,6 +148,33 @@ export type SchedulingRequestCreatePayload = {
   metadata?: Record<string, unknown>;
 };
 
+export type SchedulingRequestUpdatePayload = Omit<
+  SchedulingRequestCreatePayload,
+  "timezone" | "status" | "slots" | "participants"
+> & {
+  slots?: SchedulingCandidateSlotReconcilePayload[];
+  participants?: SchedulingParticipantReconcilePayload[];
+};
+
+export type SchedulingCandidateSlotReconcilePayload = SchedulingCandidateSlotPayload & {
+  id?: string;
+  revision?: string;
+};
+
+export type SchedulingParticipantReconcilePayload = SchedulingParticipantPayload & {
+  id?: string;
+};
+
+export type SchedulingCandidateSlotUpdatePayload = {
+  label?: string | null;
+  description?: string | null;
+  start_at?: string | null;
+  end_at?: string | null;
+  timezone?: string | null;
+  location?: string | null;
+  metadata?: Record<string, unknown> | null;
+};
+
 export type SchedulingDecisionPayload = {
   slot_id?: string | null;
   poll_option_id?: string | null;
@@ -144,6 +189,7 @@ export type SchedulingAvailabilityPayload = {
     value: SchedulingAvailabilityValue;
     option_revision: string;
   }>;
+  comment?: string | null;
 };
 
 export type SchedulingAvailabilityResponse = {
@@ -151,12 +197,62 @@ export type SchedulingAvailabilityResponse = {
   participant_id: string;
   has_response: boolean;
   submitted_at?: string | null;
+  comment?: string | null;
   answers: Array<{
     slot_id: string;
     value: SchedulingAvailabilityValue;
   }>;
 };
 
+export type SchedulingPublicCandidateSlot = {
+  id: string;
+  label: string;
+  description?: string | null;
+  start_at: string;
+  end_at: string;
+  timezone: string;
+  location?: string | null;
+  position: number;
+  revision: string;
+};
+
+export type SchedulingPublicParticipationResponse = {
+  request_id: string;
+  title: string;
+  description?: string | null;
+  location?: string | null;
+  timezone: string;
+  status: SchedulingStatus;
+  deadline_at?: string | null;
+  participant_email_required: boolean;
+  anonymous_password_required: boolean;
+  single_choice: boolean;
+  max_participants_per_option: number | null;
+  allow_maybe: boolean;
+  allow_comments: boolean;
+  allow_participant_updates: boolean;
+  has_response: boolean;
+  submitted_at?: string | null;
+  answers: Array<{
+    slot_id: string;
+    value: SchedulingAvailabilityValue;
+  }>;
+  comment?: string | null;
+  replayed: boolean;
+  slots: SchedulingPublicCandidateSlot[];
+};
+
+export type SchedulingPublicParticipationAccessPayload = {
+  participant_email?: string | null;
+  password?: string | null;
+};
+
+export type SchedulingPublicParticipationSubmitPayload = SchedulingPublicParticipationAccessPayload & {
+  answers: SchedulingAvailabilityPayload["answers"];
+  comment?: string | null;
+  idempotency_key?: string;
+};
+
 export type SchedulingCalendarActionResponse = {
   request: SchedulingRequest;
   created_event_ids: string[];
@@ -239,6 +335,29 @@ export function createSchedulingRequest(settings: ApiSettings, payload: Scheduli
   return apiFetch<SchedulingRequest>(settings, "/api/v1/scheduling/requests", json(payload));
 }
 
+export function updateSchedulingRequest(
+  settings: ApiSettings,
+  requestId: string,
+  payload: SchedulingRequestUpdatePayload
+): Promise<SchedulingRequest> {
+  return apiFetch<SchedulingRequest>(settings, `/api/v1/scheduling/requests/${requestId}`, {
+    method: "PATCH",
+    body: JSON.stringify(payload)
+  });
+}
+
+export function updateSchedulingCandidateSlot(
+  settings: ApiSettings,
+  requestId: string,
+  slotId: string,
+  payload: SchedulingCandidateSlotUpdatePayload
+): Promise<SchedulingRequest> {
+  return apiFetch<SchedulingRequest>(settings, `/api/v1/scheduling/requests/${requestId}/slots/${slotId}`, {
+    method: "PATCH",
+    body: JSON.stringify(payload)
+  });
+}
+
 export function submitSchedulingAvailability(
   settings: ApiSettings,
   requestId: string,
@@ -261,6 +380,32 @@ export function getSchedulingAvailabilityResponse(
   );
 }
 
+export function getPublicSchedulingParticipation(
+  settings: ApiSettings,
+  requestId: string,
+  token: string,
+  payload: SchedulingPublicParticipationAccessPayload
+): Promise<SchedulingPublicParticipationResponse> {
+  return apiFetch<SchedulingPublicParticipationResponse>(
+    settings,
+    `/api/v1/scheduling/public/${encodeURIComponent(requestId)}/${encodeURIComponent(token)}`,
+    json(payload)
+  );
+}
+
+export function submitPublicSchedulingParticipation(
+  settings: ApiSettings,
+  requestId: string,
+  token: string,
+  payload: SchedulingPublicParticipationSubmitPayload
+): Promise<SchedulingPublicParticipationResponse> {
+  return apiFetch<SchedulingPublicParticipationResponse>(
+    settings,
+    `/api/v1/scheduling/public/${encodeURIComponent(requestId)}/${encodeURIComponent(token)}/responses`,
+    json(payload)
+  );
+}
+
 export function openSchedulingRequest(settings: ApiSettings, requestId: string): Promise<SchedulingStatusResponse> {
   return apiFetch<SchedulingStatusResponse>(settings, `/api/v1/scheduling/requests/${requestId}/open`, json({}));
 }
diff --git a/webui/src/features/scheduling/SchedulingPage.tsx b/webui/src/features/scheduling/SchedulingPage.tsx
index 7f64bbd..4111c54 100644
--- a/webui/src/features/scheduling/SchedulingPage.tsx
+++ b/webui/src/features/scheduling/SchedulingPage.tsx
@@ -1,9 +1,11 @@
-import { useEffect, useMemo, useState, type FormEvent } from "react";
+import { useEffect, useMemo, useRef, useState, type FormEvent } from "react";
+import { useSearchParams } from "react-router-dom";
 import {
   Bell,
   CalendarCheck,
   Check,
   Clock,
+  Pencil,
   Plus,
   RefreshCw,
   Save,
@@ -11,29 +13,35 @@ import {
   XCircle
 } from "lucide-react";
 import {
-  AdminIconButton,
   Button,
   Card,
   DataGrid,
   DataGridEmptyAction,
   DataGridRowActions,
   DateTimeField,
+  DismissibleAlert,
+  FormField,
+  MetricCard,
+  IconButton,
+  PageTitle,
+  PasswordField,
   formatDateTime,
-  ModuleSubnav,
   SelectionList,
   SelectionListItem,
   TableActionGroup,
   ToggleSwitch,
+  StatusBadge,
   hasScope,
   i18nMessage,
   usePlatformLanguage,
   usePlatformUiCapability,
+  useUnsavedChanges,
+  useUnsavedDraftGuard,
   type ApiSettings,
   type AuthInfo,
   type CalendarPickerUiCapability,
   type DataGridColumn,
-  type FormatDateTimeOptions,
-  type ModuleSubnavGroup
+  type FormatDateTimeOptions
 } from "@govoplan/core-webui";
 import {
   closeSchedulingRequest,
@@ -49,6 +57,7 @@ import {
   openSchedulingRequest,
   schedulingSummary,
   submitSchedulingAvailability,
+  updateSchedulingRequest,
   type SchedulingCandidateSlot,
   type SchedulingAvailabilityValue,
   type SchedulingNotification,
@@ -58,6 +67,7 @@ import {
   type SchedulingSummaryResponse
 } from "../../api/scheduling";
 import {
+  applySchedulingAvailabilityChoice,
   groupSchedulingRequests,
   schedulingParticipantForActor,
   schedulingRelevantTimestamp,
@@ -67,13 +77,34 @@ import {
   type SchedulingRequestGroups
 } from "./schedulingViewModel";
 
-type CreateSection = "basic" | "calendar" | "slots" | "participants";
-type SlotDraft = { draftId: string; label: string; start_at: string; end_at: string };
-type ParticipantDraft = { draftId: string; display_name: string; email: string; required: boolean };
+type EditorMode = "create" | "edit" | null;
+type SlotDraft = {
+  draftId: string;
+  sourceId?: string;
+  revision?: string;
+  label: string;
+  description?: string | null;
+  start_at: string;
+  end_at: string;
+  timezone: string;
+  metadata?: Record<string, unknown>;
+};
+type ParticipantDraft = {
+  draftId: string;
+  sourceId?: string;
+  respondent_id?: string | null;
+  display_name: string;
+  email: string;
+  participant_type: "internal" | "external" | "resource";
+  required: boolean;
+  metadata?: Record<string, unknown>;
+  identityLocked?: boolean;
+};
 
 const I18N = {
   actions: "i18n:govoplan-core.actions.c3cd636a",
   add: "i18n:govoplan-core.add.61cc55aa",
+  addRequest: "i18n:govoplan-scheduling.add_scheduling_request.3c71be15",
   addParticipant: "i18n:govoplan-scheduling.add_participant.6cff957d",
   addSlot: "i18n:govoplan-scheduling.add_slot.9fcff3ed",
   answered: "i18n:govoplan-scheduling.answered.e0aafffa",
@@ -94,48 +125,80 @@ const I18N = {
   chooseAvailability: "i18n:govoplan-scheduling.choose_availability.ac95b8f6",
   closePoll: "i18n:govoplan-scheduling.close_poll.a6a18916",
   closed: "i18n:govoplan-scheduling.closed.88d86b77",
-  createAndOpen: "i18n:govoplan-scheduling.create_and_open_scheduling_request.1dbc9345",
   description: "i18n:govoplan-scheduling.description.55f8ebc8",
   determined: "i18n:govoplan-scheduling.determined.9f23293d",
+  decideUnavailable: "i18n:govoplan-scheduling.a_slot_can_be_selected_after_the_request_is_closed.f91ec02d",
   discard: "i18n:govoplan-scheduling.discard.36fff63c",
   discardConfirm: "i18n:govoplan-scheduling.discard_this_unsaved_scheduling_request.4a956be2",
+  edit: "i18n:govoplan-scheduling.edit_scheduling_request.7e749c19",
+  invitedIdentityLocked: "i18n:govoplan-scheduling.invited_participant_identity_is_locked_remove_and_add_the_participant_to_change_it.34e1201a",
   end: "i18n:govoplan-scheduling.end.a2bb9d34",
+  generalSettings: "i18n:govoplan-scheduling.participation_settings.8dc6f62c",
   free: "i18n:govoplan-scheduling.free.75f52718",
   holds: "i18n:govoplan-scheduling.create_tentative_holds.51c4744e",
   invitedRequests: "i18n:govoplan-scheduling.scheduling_requests_for_me.1d521aba",
   loading: "i18n:govoplan-scheduling.loading_scheduling_requests.f42be95d",
   location: "i18n:govoplan-scheduling.location.d219c681",
+  allowComments: "i18n:govoplan-scheduling.allow_comments.d63202a6",
+  allowCommentsHelp: "i18n:govoplan-scheduling.let_participants_add_a_comment_to_their_response.9dce8d17",
+  allowMaybe: "i18n:govoplan-scheduling.provide_a_maybe_option.e39da57a",
+  allowMaybeHelp: "i18n:govoplan-scheduling.add_maybe_between_yes_and_no_for_each_candidate_slot.74dc9db6",
+  anonymousEmailRequired: "i18n:govoplan-scheduling.require_an_email_address_from_guests.c2289a58",
+  anonymousEmailRequiredHelp: "i18n:govoplan-scheduling.people_responding_without_an_account_must_provide_an_email.19fd3dc8",
+  anonymousPassword: "i18n:govoplan-scheduling.guest_password.94545e82",
+  anonymousPasswordHelp: "i18n:govoplan-scheduling.use_at_least_8_characters_the_password_is_never_displayed.035708a2",
+  anonymousPasswordProtection: "i18n:govoplan-scheduling.password_protect_guest_access.13d7f08b",
+  anonymousPasswordProtectionHelp: "i18n:govoplan-scheduling.people_who_are_not_signed_in_must_enter_this_password.82bcc4ce",
+  comment: "i18n:govoplan-scheduling.comment.d03495b1",
+  maxParticipants: "i18n:govoplan-scheduling.limit_participants_per_option.1e9aa51d",
+  maxParticipantsCount: "i18n:govoplan-scheduling.maximum_participants_per_option.5abdfb27",
+  maxParticipantsHelp: "i18n:govoplan-scheduling.stop_accepting_yes_responses_for_an_option_when_its_limit.79af21db",
   managedRequests: "i18n:govoplan-scheduling.managed_scheduling_requests.7a45972f",
   maybe: "i18n:govoplan-scheduling.maybe.56dd8d0b",
   myRequests: "i18n:govoplan-scheduling.my_scheduling_requests.d28ef235",
   name: "i18n:govoplan-scheduling.name.709a2322",
   newRequest: "i18n:govoplan-scheduling.new_scheduling_request.2080f675",
   noNotifications: "i18n:govoplan-scheduling.no_notifications_have_been_created.c8d43ca3",
+  notificationsUnavailable: "i18n:govoplan-scheduling.notifications_could_not_be_loaded.f0e1b2c3",
   noParticipants: "i18n:govoplan-scheduling.no_participants.73a89101",
   noRequest: "i18n:govoplan-scheduling.no_scheduling_request_selected.ac940664",
   noRequestsInGroup: "i18n:govoplan-scheduling.no_requests_in_this_group.a63c1b40",
   notifications: "i18n:govoplan-scheduling.notifications.753a22b2",
+  notifyOnAnswers: "i18n:govoplan-scheduling.notify_me_about_each_answer.505749d6",
+  notifyOnAnswersHelp: "i18n:govoplan-scheduling.create_an_organizer_notification_whenever_a_response_is.253ddca8",
   open: "i18n:govoplan-scheduling.open.cf9b7706",
   openPoll: "i18n:govoplan-scheduling.open_poll.2beac9a7",
   participantEmail: "i18n:govoplan-scheduling.participant_email.2cadfd9e",
   participantRosterHidden: "i18n:govoplan-scheduling.participant_names_and_statuses_are_hidden_aggregate_counts_r.d811a69a",
+  participantPrivacy: "i18n:govoplan-scheduling.participant_privacy.108c470f",
   participantRosterVisibility: "i18n:govoplan-scheduling.share_participant_names_and_response_statuses.df0bf9e0",
   participantRosterVisibilityHelp: "i18n:govoplan-scheduling.when_enabled_participants_can_see_other_participants_names.3ac78361",
   participants: "i18n:govoplan-scheduling.participants.cd56e083",
+  participation: "i18n:govoplan-scheduling.participation.9ad70cc4",
+  participationRate: "i18n:govoplan-scheduling.participation_rate.46bc5504",
+  responses: "i18n:govoplan-scheduling.responses.3427e3ab",
+  awaiting: "i18n:govoplan-scheduling.awaiting.42aa82e0",
+  capacity: "i18n:govoplan-scheduling.capacity.d3c375f8",
   past: "i18n:govoplan-scheduling.past.405c12fb",
   refresh: "i18n:govoplan-scheduling.refresh_requests.0a3ed7a1",
   reminder: "i18n:govoplan-scheduling.send_reminder.cf5eb3bf",
   requestFailed: "i18n:govoplan-scheduling.request_failed.9fcda32c",
+  publicPolicyUnavailable: "i18n:govoplan-scheduling.guest_links_are_not_issued_while_the_configured_participation.0794ebf0",
+  policyLocked: "i18n:govoplan-scheduling.participation_controls_are_locked_after_invitation_links_are_issued.66f5a740",
   requests: "i18n:govoplan-scheduling.scheduling_requests.b3c12f4d",
   requiresAvailabilityRead: "i18n:govoplan-scheduling.requires_calendar_availability_read_access.b48ed91b",
   requiresEventWrite: "i18n:govoplan-scheduling.requires_calendar_event_write_access.887b0763",
   responseRecorded: "i18n:govoplan-scheduling.your_response_has_been_recorded.b855088d",
   responseReplace: "i18n:govoplan-scheduling.the_response_replaces_your_previous_availability_choices.74c16d53",
+  resultsUnavailable: "i18n:govoplan-scheduling.response_results_are_not_available_for_this_view.1e82db18",
   invitationHelp: "i18n:govoplan-scheduling.you_can_respond_here_or_use_the_invitation_link_you_rece.1a25fd53",
   save: "i18n:govoplan-scheduling.save.efc007a3",
   saving: "i18n:govoplan-scheduling.saving.56a2285c",
   selectCalendar: "i18n:govoplan-scheduling.select_a_calendar.f6af95bb",
   selectResponse: "i18n:govoplan-scheduling.choose_availability_for_at_least_one_candidate_slot.28d2111f",
+  unsavedResponse: "i18n:govoplan-scheduling.save_or_discard_your_unsent_availability_changes_before_leaving.97e10df1",
+  singleChoice: "i18n:govoplan-scheduling.participants_can_choose_only_one_option.4311f51c",
+  singleChoiceHelp: "i18n:govoplan-scheduling.each_participant_can_answer_yes_to_at_most_one_candidate.5313a465",
   sendResponse: "i18n:govoplan-scheduling.submit_response.a5f0c053",
   start: "i18n:govoplan-scheduling.start.952f3754",
   statusLabel: "i18n:govoplan-scheduling.status.bae7d5be",
@@ -148,29 +211,17 @@ const I18N = {
   whatActionsDo: "i18n:govoplan-scheduling.what_do_these_actions_do.9a9aee0e"
 } as const;
 
-const CREATE_NAVIGATION: ModuleSubnavGroup<CreateSection>[] = [{
-  items: [
-    { id: "basic", label: I18N.basicInformation },
-    { id: "calendar", label: I18N.calendarIntegration },
-    { id: "slots", label: I18N.candidateSlots },
-    { id: "participants", label: I18N.participants }
-  ]
-}];
-
-const CREATE_SECTION_IDS: Record<CreateSection, string> = {
-  basic: "scheduling-create-basic",
-  calendar: "scheduling-create-calendar",
-  slots: "scheduling-create-slots",
-  participants: "scheduling-create-participants"
-};
-
 export default function SchedulingPage({ settings, auth }: { settings: ApiSettings; auth: AuthInfo }) {
   const { translateText } = usePlatformLanguage();
+  const { requestDiscard, requestNavigation } = useUnsavedChanges();
+  const [searchParams, setSearchParams] = useSearchParams();
+  const requestedId = searchParams.get("request_id") ?? "";
   const calendarPickerCapability = usePlatformUiCapability<CalendarPickerUiCapability>("calendar.picker");
   const CalendarPicker = calendarPickerCapability?.CalendarPicker;
   const [requests, setRequests] = useState<SchedulingRequest[]>([]);
   const [selectedId, setSelectedId] = useState("");
-  const [creating, setCreating] = useState(false);
+  const [editorMode, setEditorMode] = useState<EditorMode>(null);
+  const [editingRequestId, setEditingRequestId] = useState("");
   const [summary, setSummary] = useState<SchedulingSummaryResponse | null>(null);
   const [notifications, setNotifications] = useState<SchedulingNotification[]>([]);
   const [loading, setLoading] = useState(true);
@@ -178,7 +229,6 @@ export default function SchedulingPage({ settings, auth }: { settings: ApiSettin
   const [error, setError] = useState("");
   const [success, setSuccess] = useState("");
   const [draftDirty, setDraftDirty] = useState(false);
-  const [createSection, setCreateSection] = useState<CreateSection>("basic");
   const [title, setTitle] = useState("");
   const [description, setDescription] = useState("");
   const [location, setLocation] = useState("");
@@ -187,10 +237,28 @@ export default function SchedulingPage({ settings, auth }: { settings: ApiSettin
   const [slots, setSlots] = useState<SlotDraft[]>(() => initialSlots(translateText));
   const [participants, setParticipants] = useState<ParticipantDraft[]>(() => [emptyParticipant()]);
   const [participantRosterVisible, setParticipantRosterVisible] = useState(false);
+  const [notifyOnAnswers, setNotifyOnAnswers] = useState(true);
+  const [singleChoice, setSingleChoice] = useState(false);
+  const [participantLimitEnabled, setParticipantLimitEnabled] = useState(false);
+  const [maxParticipantsPerOption, setMaxParticipantsPerOption] = useState(1);
+  const [allowMaybe, setAllowMaybe] = useState(true);
+  const [allowComments, setAllowComments] = useState(false);
+  const [participantEmailRequired, setParticipantEmailRequired] = useState(false);
+  const [anonymousPasswordProtectionEnabled, setAnonymousPasswordProtectionEnabled] = useState(false);
+  const [anonymousPassword, setAnonymousPassword] = useState("");
   const [availability, setAvailability] = useState<Record<string, SchedulingAvailabilityValue | "">>({});
+  const [savedAvailability, setSavedAvailability] = useState<Record<string, SchedulingAvailabilityValue | "">>({});
+  const [availabilityComment, setAvailabilityComment] = useState("");
+  const [savedAvailabilityComment, setSavedAvailabilityComment] = useState("");
   const [availabilityLoading, setAvailabilityLoading] = useState(false);
+  const [summaryUnavailable, setSummaryUnavailable] = useState(false);
+  const [notificationsUnavailable, setNotificationsUnavailable] = useState(false);
+  const [detailsLoading, setDetailsLoading] = useState(false);
+  const detailLoadSequence = useRef(0);
 
   const canWrite = hasScope(auth, "scheduling:schedule:write");
+  const canAdminister = hasScope(auth, "scheduling:schedule:admin");
+  const canCreateOrWrite = canWrite || canAdminister;
   const canRespond = hasScope(auth, "scheduling:availability:write");
   const canReadCalendars = hasScope(auth, "calendar:calendar:read");
   const canReadAvailability = hasScope(auth, "calendar:availability:read");
@@ -205,14 +273,19 @@ export default function SchedulingPage({ settings, auth }: { settings: ApiSettin
   }), [auth.principal, auth.user.account_id, auth.user.email, auth.user.id]);
   const groups = useMemo(() => groupSchedulingRequests(requests, actor), [actor, requests]);
   const selected = useMemo(
-    () => requests.find((item) => item.id === selectedId) ?? firstRequest(groups),
-    [groups, requests, selectedId]
+    () => requests.find((item) => item.id === selectedId) ?? firstRequest(groups, canAdminister),
+    [canAdminister, groups, requests, selectedId]
   );
   const selectedParticipant = useMemo(
     () => selected ? schedulingParticipantForActor(selected, actor) : null,
     [actor, selected]
   );
-  const canManageSelected = Boolean(selected && canWrite);
+  const canManageSelected = Boolean(
+    selected && (canAdminister || (canWrite && schedulingRequestIsOwned(selected, actor)))
+  );
+  const canEditSelected = Boolean(
+    selected && canManageSelected && !["decided", "handed_off", "cancelled", "archived"].includes(selected.status)
+  );
   const selectedPhase = selected ? schedulingSortPhase(selected, actor) : null;
   const showPlanningCalendarActions = Boolean(
     selected &&
@@ -234,27 +307,52 @@ export default function SchedulingPage({ settings, auth }: { settings: ApiSettin
   );
   const optionResultById = useMemo(() => {
     const map = new Map<string, SchedulingSummaryResponse["poll_summary"]["option_results"][number]>();
-    for (const result of summary?.poll_summary.option_results ?? []) map.set(result.option_id, result);
+    for (const result of summary?.poll_summary.option_results ?? []) {
+      map.set(result.option_id, result);
+      map.set(result.option_key, result);
+    }
     return map;
   }, [summary]);
+  const responseDirty = useMemo(
+    () => availabilityComment !== savedAvailabilityComment || !availabilityValuesEqual(availability, savedAvailability),
+    [availability, availabilityComment, savedAvailability, savedAvailabilityComment]
+  );
+  const editorOriginal = editorMode === "edit"
+    ? requests.find((request) => request.id === editingRequestId) ?? null
+    : null;
+  const participationPolicyLocked = Boolean(
+    editorOriginal?.participants.some((participant) => participant.poll_invitation_id)
+  );
 
   useEffect(() => {
     void loadRequests();
   }, [settings.apiBaseUrl, settings.apiKey, settings.accessToken]);
 
   useEffect(() => {
-    if (!selected?.id || creating) {
+    if (!requestedId || requestedId === selectedId) return;
+    if (requests.some((request) => request.id === requestedId)) setSelectedId(requestedId);
+  }, [requestedId, requests, selectedId]);
+
+  useEffect(() => {
+    if (!selected?.id || editorMode) {
+      detailLoadSequence.current += 1;
       setSummary(null);
       setNotifications([]);
+      setSummaryUnavailable(false);
+      setNotificationsUnavailable(false);
+      setDetailsLoading(false);
       return;
     }
     setAvailability({});
+    setSavedAvailability({});
+    setAvailabilityComment("");
+    setSavedAvailabilityComment("");
     setSuccess("");
     void loadDetails(selected.id);
-  }, [creating, selected?.id]);
+  }, [editorMode, selected?.id]);
 
   useEffect(() => {
-    if (!selected?.id || !selectedParticipant || !canRespond || creating || selected.status !== "collecting") {
+    if (!selected?.id || !selectedParticipant || !canRespond || editorMode || selected.status !== "collecting") {
       setAvailabilityLoading(false);
       return undefined;
     }
@@ -263,7 +361,12 @@ export default function SchedulingPage({ settings, auth }: { settings: ApiSettin
     void getSchedulingAvailabilityResponse(settings, selected.id)
       .then((response) => {
         if (cancelled) return;
-        setAvailability(Object.fromEntries(response.answers.map((answer) => [answer.slot_id, answer.value])));
+        const answers = Object.fromEntries(response.answers.map((answer) => [answer.slot_id, answer.value]));
+        const comment = response.comment ?? "";
+        setAvailability(answers);
+        setSavedAvailability(answers);
+        setAvailabilityComment(comment);
+        setSavedAvailabilityComment(comment);
       })
       .catch((err) => {
         if (!cancelled) setError(errorMessage(err, translateText(I18N.requestFailed)));
@@ -276,7 +379,7 @@ export default function SchedulingPage({ settings, auth }: { settings: ApiSettin
     };
   }, [
     canRespond,
-    creating,
+    editorMode,
     selected?.id,
     selected?.status,
     selectedParticipant?.id,
@@ -286,22 +389,36 @@ export default function SchedulingPage({ settings, auth }: { settings: ApiSettin
     translateText
   ]);
 
-  useEffect(() => {
-    if (!creating || !draftDirty) return undefined;
-    const preventUnsavedExit = (event: BeforeUnloadEvent) => event.preventDefault();
-    window.addEventListener("beforeunload", preventUnsavedExit);
-    return () => window.removeEventListener("beforeunload", preventUnsavedExit);
-  }, [creating, draftDirty]);
+  useUnsavedDraftGuard({
+    dirty: Boolean(editorMode && draftDirty),
+    message: I18N.discardConfirm,
+    onSave: persistDraft,
+    onDiscard: resetDraft,
+    enabled: Boolean(editorMode)
+  });
 
-  async function loadRequests() {
+  useUnsavedDraftGuard({
+    dirty: responseDirty,
+    message: I18N.unsavedResponse,
+    onSave: persistAvailability,
+    onDiscard: resetResponseDraft,
+    enabled: Boolean(!editorMode && selectedParticipant && selected?.status === "collecting")
+  });
+
+  async function loadRequests(preferredId?: string) {
     setLoading(true);
     setError("");
     try {
       const response = await listSchedulingRequests(settings);
       setRequests(response.requests);
-      setSelectedId((current) => response.requests.some((item) => item.id === current)
-        ? current
-        : "");
+      setSelectedId((current) => {
+        if (preferredId && response.requests.some((item) => item.id === preferredId)) return preferredId;
+        if (response.requests.some((item) => item.id === current)) return current;
+        const requested = response.requests.find((item) => item.id === requestedId);
+        if (requested) return requested.id;
+        const nextGroups = groupSchedulingRequests(response.requests, actor);
+        return firstRequest(nextGroups, canAdminister)?.id ?? "";
+      });
     } catch (err) {
       setError(errorMessage(err, translateText(I18N.requestFailed)));
     } finally {
@@ -310,84 +427,221 @@ export default function SchedulingPage({ settings, auth }: { settings: ApiSettin
   }
 
   async function loadDetails(requestId: string) {
-    const [summaryResponse, notificationResponse] = await Promise.all([
-      schedulingSummary(settings, requestId).catch(() => null),
-      listSchedulingNotifications(settings, requestId).catch(() => ({ notifications: [] }))
+    const sequence = detailLoadSequence.current + 1;
+    detailLoadSequence.current = sequence;
+    setDetailsLoading(true);
+    const [summaryResult, notificationResult] = await Promise.allSettled([
+      schedulingSummary(settings, requestId),
+      listSchedulingNotifications(settings, requestId)
     ]);
-    setSummary(summaryResponse);
-    setNotifications(notificationResponse.notifications);
+    if (detailLoadSequence.current !== sequence) return;
+    if (summaryResult.status === "fulfilled") {
+      setSummary(summaryResult.value);
+      setSummaryUnavailable(false);
+    } else {
+      setSummary(null);
+      setSummaryUnavailable(true);
+    }
+    if (notificationResult.status === "fulfilled") {
+      setNotifications(notificationResult.value.notifications);
+      setNotificationsUnavailable(false);
+    } else {
+      setNotifications([]);
+      setNotificationsUnavailable(true);
+    }
+    setDetailsLoading(false);
   }
 
   function beginCreate() {
+    requestNavigation(startCreate);
+  }
+
+  function startCreate() {
     resetDraft();
     setError("");
     setSuccess("");
-    setCreateSection("basic");
-    setCreating(true);
+    setEditingRequestId("");
+    setEditorMode("create");
   }
 
-  function discardCreate() {
+  function beginEdit(request: SchedulingRequest) {
+    requestNavigation(() => {
+      setTitle(request.title);
+      setDescription(request.description ?? "");
+      setLocation(request.location ?? "");
+      setCalendarId(request.calendar_id ?? "");
+      setCalendarEnabled(Boolean(request.calendar_integration_enabled));
+      setSlots(request.slots.map((slot) => ({
+        draftId: nextDraftId("slot"),
+        sourceId: slot.id,
+        revision: slot.revision,
+        label: slot.label,
+        description: slot.description,
+        start_at: localValue(new Date(slot.start_at)),
+        end_at: localValue(new Date(slot.end_at)),
+        timezone: slot.timezone,
+        metadata: slot.metadata
+      })));
+      setParticipants(request.participants.map((participant) => ({
+        draftId: nextDraftId("participant"),
+        sourceId: participant.id,
+        respondent_id: participant.respondent_id,
+        display_name: participant.display_name ?? "",
+        email: participant.email ?? "",
+        participant_type: normalizeParticipantType(participant.participant_type),
+        required: participant.required ?? true,
+        metadata: participant.metadata,
+        identityLocked: Boolean(participant.poll_invitation_id)
+      })));
+      setParticipantRosterVisible(request.participant_visibility === "names_and_statuses");
+      setNotifyOnAnswers(request.notify_on_answers);
+      setSingleChoice(request.single_choice);
+      setParticipantLimitEnabled(request.max_participants_per_option !== null);
+      setMaxParticipantsPerOption(request.max_participants_per_option ?? 1);
+      setAllowMaybe(request.allow_maybe);
+      setAllowComments(request.allow_comments);
+      setParticipantEmailRequired(request.participant_email_required);
+      setAnonymousPasswordProtectionEnabled(request.anonymous_password_protection_enabled);
+      setAnonymousPassword("");
+      setError("");
+      setSuccess("");
+      setEditingRequestId(request.id);
+      setDraftDirty(false);
+      setEditorMode("edit");
+    });
+  }
+
+  function discardEditor() {
     if (saving) return;
-    if (draftDirty && !window.confirm(translateText(I18N.discardConfirm))) return;
-    resetDraft();
-    setCreating(false);
+    requestDiscard(exitEditor);
   }
 
-  async function createRequest(event: FormEvent<HTMLFormElement>) {
-    event.preventDefault();
-    if (!canWrite) return;
+  function exitEditor() {
+    resetDraft();
+    setEditingRequestId("");
+    setEditorMode(null);
+  }
+
+  async function persistDraft(): Promise<boolean> {
+    if (!canCreateOrWrite || !editorMode) return false;
     setError("");
     if (!title.trim()) {
       setError(I18N.titleRequired);
-      return;
+      return false;
     }
     if (calendarEnabled && !calendarId) {
       setError("i18n:govoplan-scheduling.select_a_calendar_or_turn_off_calendar_integration.cc3652a9");
-      return;
+      return false;
     }
     if (slots.some((slot) => !slot.start_at || !slot.end_at || new Date(slot.end_at) <= new Date(slot.start_at))) {
       setError("i18n:govoplan-scheduling.every_candidate_slot_must_end_after_it_starts.47836010");
-      return;
+      return false;
+    }
+    const original = editorMode === "edit"
+      ? requests.find((request) => request.id === editingRequestId)
+      : null;
+    if (
+      anonymousPasswordProtectionEnabled &&
+      anonymousPassword.length < 8 &&
+      !(original?.anonymous_password_protection_enabled && anonymousPassword.length === 0)
+    ) {
+      setError(I18N.anonymousPasswordHelp);
+      return false;
     }
     setSaving(true);
     try {
       const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
-      const request = await createSchedulingRequest(settings, {
+      const commonPayload = {
         title: title.trim(),
         description: description.trim() || null,
         location: location.trim() || null,
-        timezone,
-        status: "collecting",
         participant_visibility: participantRosterVisible ? "names_and_statuses" : "aggregates_only",
+        notify_on_answers: notifyOnAnswers,
+        single_choice: singleChoice,
+        max_participants_per_option: participantLimitEnabled ? maxParticipantsPerOption : null,
+        allow_maybe: allowMaybe,
+        allow_comments: allowComments,
+        participant_email_required: participantEmailRequired,
+        anonymous_password_protection_enabled: anonymousPasswordProtectionEnabled,
+        ...(anonymousPassword ? { anonymous_password: anonymousPassword } : {}),
         calendar: {
           enabled: calendarEnabled,
           calendar_id: calendarEnabled ? calendarId : null,
           freebusy_enabled: calendarEnabled,
           tentative_holds_enabled: calendarEnabled,
           create_event_on_decision: calendarEnabled
-        },
-        slots: slots.map((slot) => ({
-          label: slot.label.trim() || null,
-          start_at: isoFromLocal(slot.start_at),
-          end_at: isoFromLocal(slot.end_at),
+        }
+      } as const;
+      let request: SchedulingRequest;
+      if (editorMode === "create") {
+        request = await createSchedulingRequest(settings, {
+          ...commonPayload,
           timezone,
-          location: location.trim() || null
-        })),
-        participants: participants
-          .filter((participant) => participant.email.trim() || participant.display_name.trim())
-          .map((participant) => ({
-            display_name: participant.display_name.trim() || null,
-            email: participant.email.trim() || null,
-            required: participant.required,
-            participant_type: "external"
-          }))
-      });
-      setRequests((items) => [request, ...items]);
+          status: "draft",
+          slots: slots.map((slot) => ({
+            label: slot.label.trim() || null,
+            description: slot.description ?? null,
+            start_at: isoFromLocal(slot.start_at),
+            end_at: isoFromLocal(slot.end_at),
+            timezone: slot.timezone || timezone,
+            location: location.trim() || null,
+            metadata: slot.metadata ?? {}
+          })),
+          participants: participants
+            .filter((participant) => participant.email.trim() || participant.display_name.trim())
+            .map((participant) => ({
+              respondent_id: participant.respondent_id ?? null,
+              display_name: participant.display_name.trim() || null,
+              email: participant.email.trim() || null,
+              required: participant.required,
+              participant_type: participant.participant_type,
+              metadata: participant.metadata ?? {}
+            })),
+          create_participant_invitations: true
+        });
+        setRequests((items) => [request, ...items]);
+      } else {
+        if (!original) {
+          setError(I18N.requestFailed);
+          return false;
+        }
+        request = await updateSchedulingRequest(settings, original.id, {
+          ...commonPayload,
+          slots: slots.map((slot) => ({
+            ...(slot.sourceId ? { id: slot.sourceId, revision: slot.revision } : {}),
+            label: slot.label.trim(),
+            description: slot.description ?? null,
+            start_at: isoFromLocal(slot.start_at),
+            end_at: isoFromLocal(slot.end_at),
+            timezone: slot.timezone || timezone,
+            location: location.trim() || null,
+            metadata: slot.metadata ?? {}
+          })),
+          participants: participants
+            .filter((participant) => participant.sourceId || participant.email.trim() || participant.display_name.trim())
+            .map((participant) => ({
+              ...(participant.sourceId ? { id: participant.sourceId } : {}),
+              respondent_id: participant.respondent_id ?? null,
+              display_name: participant.display_name.trim() || null,
+              email: participant.email.trim() || null,
+              participant_type: participant.participant_type,
+              required: participant.required,
+              metadata: participant.metadata ?? {}
+            })),
+          create_participant_invitations: true
+        });
+        replaceRequest(request);
+      }
       setSelectedId(request.id);
+      setSelectedRequestSearchParam(request.id);
       setDraftDirty(false);
-      setCreating(false);
+      setEditingRequestId("");
+      setEditorMode(null);
+      await loadRequests(request.id);
+      return true;
     } catch (err) {
       setError(errorMessage(err, translateText(I18N.requestFailed)));
+      return false;
     } finally {
       setSaving(false);
     }
@@ -402,7 +656,7 @@ export default function SchedulingPage({ settings, auth }: { settings: ApiSettin
       const response = await action();
       const updated = isRequestEnvelope(response) ? response.request : null;
       if (updated) replaceRequest(updated);
-      await loadRequests();
+      await loadRequests(selected.id);
       await loadDetails(selected.id);
     } catch (err) {
       setError(errorMessage(err, translateText(I18N.requestFailed)));
@@ -413,7 +667,11 @@ export default function SchedulingPage({ settings, auth }: { settings: ApiSettin
 
   async function sendAvailability(event: FormEvent<HTMLFormElement>) {
     event.preventDefault();
-    if (!selected || !selectedParticipant || !canRespond || availabilityLoading) return;
+    await persistAvailability();
+  }
+
+  async function persistAvailability(): Promise<boolean> {
+    if (!selected || !selectedParticipant || !canRespond || availabilityLoading) return false;
     const answers = selected.slots
       .map((slot) => ({
         slot_id: slot.id,
@@ -427,349 +685,427 @@ export default function SchedulingPage({ settings, auth }: { settings: ApiSettin
       } => Boolean(answer.value));
     if (!answers.length) {
       setError(I18N.selectResponse);
-      return;
+      return false;
     }
     setSaving(true);
     setError("");
     setSuccess("");
     try {
-      const response = await submitSchedulingAvailability(settings, selected.id, { answers });
+      const response = await submitSchedulingAvailability(settings, selected.id, {
+        answers,
+        ...(selected.allow_comments ? { comment: availabilityComment.trim() || null } : {})
+      });
       replaceRequest(response.request);
+      const persistedAvailability = Object.fromEntries(answers.map((answer) => [answer.slot_id, answer.value]));
+      const persistedComment = selected.allow_comments ? availabilityComment.trim() : "";
+      setAvailability(persistedAvailability);
+      setSavedAvailability(persistedAvailability);
+      setAvailabilityComment(persistedComment);
+      setSavedAvailabilityComment(persistedComment);
       setSuccess(I18N.responseRecorded);
-      await loadRequests();
+      await loadRequests(selected.id);
+      return true;
     } catch (err) {
       setError(errorMessage(err, translateText(I18N.requestFailed)));
+      return false;
     } finally {
       setSaving(false);
     }
   }
 
-  if (creating) {
-    return (
-      <main className="scheduling-page scheduling-editor-page">
-        <div className="scheduling-full-editor">
-          <header className="scheduling-page-header">
-            <div className="scheduling-page-title">
-              <CalendarCheck aria-hidden="true" size={20} />
-              <div>
-                <h1>{I18N.newRequest}</h1>
-                <p>{I18N.createAndOpen}</p>
-              </div>
-            </div>
-            <div className="scheduling-page-actions">
-              <Button type="button" onClick={discardCreate} disabled={saving}>{I18N.discard}</Button>
-              <Button type="submit" form="scheduling-create-form" variant="primary" disabled={saving || !canWrite}>
-                <Save aria-hidden="true" size={16} /> {saving ? I18N.saving : I18N.save}
-              </Button>
-            </div>
-          </header>
-          {error ? <div className="scheduling-alert" role="alert">{error}</div> : null}
-          <div className="scheduling-editor-layout">
-            <ModuleSubnav
-              active={createSection}
-              groups={CREATE_NAVIGATION}
-              className="scheduling-create-subnav"
-              onSelect={(section) => {
-                setCreateSection(section);
-                document.getElementById(CREATE_SECTION_IDS[section])?.scrollIntoView({ behavior: "smooth", block: "start" });
-              }} />
-            <form id="scheduling-create-form" className="scheduling-editor-scroll" onSubmit={(event) => void createRequest(event)}>
-              <section id={CREATE_SECTION_IDS.basic} className="scheduling-create-section">
-                <Card title={I18N.basicInformation}>
-                  <div className="scheduling-form-grid">
-                    <label className="scheduling-field scheduling-field-wide">
-                      <span>{I18N.title}</span>
-                      <input required maxLength={500} value={title} onChange={(event) => changeDraft(setTitle, event.target.value)} />
-                    </label>
-                    <label className="scheduling-field scheduling-field-wide">
-                      <span>{I18N.description}</span>
-                      <textarea rows={4} value={description} onChange={(event) => changeDraft(setDescription, event.target.value)} />
-                    </label>
-                    <label className="scheduling-field scheduling-field-wide">
-                      <span>{I18N.location}</span>
-                      <input maxLength={500} value={location} onChange={(event) => changeDraft(setLocation, event.target.value)} />
-                    </label>
-                  </div>
-                </Card>
-              </section>
-
-              <section id={CREATE_SECTION_IDS.calendar} className="scheduling-create-section">
-                <Card title={I18N.calendarIntegration}>
-                  <ToggleSwitch
-                    label={I18N.calendar}
-                    help={I18N.calendarDescription}
-                    checked={calendarEnabled}
-                    disabled={!calendarIntegrationAvailable}
-                    onChange={(checked) => {
-                      setCalendarEnabled(checked);
-                      if (!checked) setCalendarId("");
-                      setDraftDirty(true);
-                    }} />
-                  {!calendarIntegrationAvailable ? <p className="scheduling-capability-note">{I18N.calendarUnavailable}</p> : null}
-                  {calendarEnabled && CalendarPicker ? (
-                    <CalendarPicker
-                      settings={settings}
-                      auth={auth}
-                      value={calendarId}
-                      onChange={(value) => {
-                        setCalendarId(value);
-                        setDraftDirty(true);
-                      }}
-                      label={I18N.calendar}
-                      emptyLabel={I18N.selectCalendar}
-                      required />
-                  ) : null}
-                </Card>
-              </section>
-
-              <section id={CREATE_SECTION_IDS.slots} className="scheduling-create-section">
-                <EditableSlots
-                  slots={slots}
-                  onAddBelow={(index) => {
-                    setSlots((items) => insertAfter(items, index, newSlot(items.length + 1, translateText)));
-                    setDraftDirty(true);
-                  }}
-                  onChange={(index, field, value) => {
-                    setSlots((items) => items.map((item, itemIndex) => itemIndex === index ? { ...item, [field]: value } : item));
-                    setDraftDirty(true);
-                  }}
-                  onMove={(from, to) => {
-                    setSlots((items) => moveItem(items, from, to));
-                    setDraftDirty(true);
-                  }}
-                  onRemove={(index) => {
-                    setSlots((items) => items.filter((_item, itemIndex) => itemIndex !== index));
-                    setDraftDirty(true);
-                  }} />
-              </section>
-
-              <section id={CREATE_SECTION_IDS.participants} className="scheduling-create-section">
-                <EditableParticipants
-                  participants={participants}
-                  participantRosterVisible={participantRosterVisible}
-                  disabled={!canWrite}
-                  onParticipantRosterVisibleChange={(checked) => {
-                    setParticipantRosterVisible(checked);
-                    setDraftDirty(true);
-                  }}
-                  onAddBelow={(index) => {
-                    setParticipants((items) => insertAfter(items, index, emptyParticipant()));
-                    setDraftDirty(true);
-                  }}
-                  onChange={(index, patch) => {
-                    setParticipants((items) => items.map((item, itemIndex) => itemIndex === index ? { ...item, ...patch } : item));
-                    setDraftDirty(true);
-                  }}
-                  onMove={(from, to) => {
-                    setParticipants((items) => moveItem(items, from, to));
-                    setDraftDirty(true);
-                  }}
-                  onRemove={(index) => {
-                    setParticipants((items) => items.filter((_item, itemIndex) => itemIndex !== index));
-                    setDraftDirty(true);
-                  }} />
-              </section>
-            </form>
-          </div>
-        </div>
-      </main>
-    );
-  }
-
   return (
     <main className="scheduling-page">
       <section className="scheduling-workspace">
-        <header className="scheduling-page-header">
-          <div className="scheduling-page-title">
-            <CalendarCheck aria-hidden="true" size={20} />
-            <h1>{I18N.requests}</h1>
-          </div>
-          <div className="scheduling-page-actions">
-            <AdminIconButton label={I18N.refresh} icon={<RefreshCw aria-hidden="true" size={16} />} onClick={() => void loadRequests()} disabled={loading} />
-            {canWrite ? (
-              <Button type="button" variant="primary" onClick={beginCreate}>
-                <Plus aria-hidden="true" size={16} /> {I18N.add}
-              </Button>
-            ) : null}
-          </div>
-        </header>
-
-        {error ? <div className="scheduling-alert" role="alert">{error}</div> : null}
-        {success ? <div className="scheduling-success" role="status">{success}</div> : null}
-
-        <div className="scheduling-detail">
-          {loading ? <div className="scheduling-note" role="status">{I18N.loading}</div> : null}
-          <div className="scheduling-request-groups">
-            <RequestGroup title={I18N.myRequests} requests={groups.owned} selectedId={selected?.id} actor={actor} onSelect={setSelectedId} />
-            <RequestGroup title={I18N.invitedRequests} requests={groups.invited} selectedId={selected?.id} actor={actor} onSelect={setSelectedId} />
-            {groups.other.length ? (
-              <RequestGroup title={I18N.managedRequests} requests={groups.other} selectedId={selected?.id} actor={actor} onSelect={setSelectedId} />
-            ) : null}
-          </div>
-
-          {selected ? (
-            <>
-              <Card
-                title={selected.title}
-                actions={canManageSelected ? (
-                  <LifecycleActions
-                    request={selected}
-                    saving={saving}
-                    onOpen={() => void runAction(() => openSchedulingRequest(settings, selected.id))}
-                    onClose={() => void runAction(() => closeSchedulingRequest(settings, selected.id))}
-                    onReminder={() => void runAction(() => createSchedulingNotifications(settings, selected.id, "reminder"))} />
-                ) : null}>
-                <div className="scheduling-status-row">
-                  <span className={`scheduling-status scheduling-status-${selected.status}`}>{requestStatusLabel(selected, actor)}</span>
-                  <span>{i18nMessage("i18n:govoplan-scheduling.value_participants.e776b092", { value0: selected.participant_aggregate.total })}</span>
-                  {summary ? <span>{i18nMessage("i18n:govoplan-scheduling.value_responses.ba17af9a", { value0: summary.poll_summary.response_count })}</span> : null}
-                </div>
-                {selected.description ? <p>{selected.description}</p> : null}
-                {selected.location ? <p><strong>{I18N.location}:</strong> {selected.location}</p> : null}
-              </Card>
-
-              {selectedParticipant && selected.status === "collecting" ? (
-                <Card
-                  title={I18N.candidateAvailability}
-                  actions={(
-                    <Button
-                      variant="primary"
-                      type="submit"
-                      form="scheduling-response-form"
-                      disabled={saving || availabilityLoading || !canRespond || (selectedParticipant.status === "responded" && !selected.allow_participant_updates)}>
-                      <Send aria-hidden="true" size={16} />
-                      {selectedParticipant.status === "responded" ? I18N.updateResponse : I18N.sendResponse}
+        <div className="scheduling-workspace-layout">
+          <aside className="scheduling-request-sidebar">
+            <Card
+              title={I18N.requests}
+              actions={(
+                <div className="scheduling-sidebar-actions">
+                  <IconButton
+                    label={I18N.refresh}
+                    icon={<RefreshCw aria-hidden="true" size={16} />}
+                    onClick={() => requestNavigation(() => void loadRequests(selected?.id))}
+                    disabled={loading} />
+                  {canCreateOrWrite ? (
+                    <Button type="button" variant="primary" onClick={beginCreate}>
+                      <Plus aria-hidden="true" size={16} /> {I18N.add}
                     </Button>
-                  )}>
-                  <form
-                    id="scheduling-response-form"
-                    className="scheduling-response-card"
-                    aria-busy={availabilityLoading}
-                    onSubmit={(event) => void sendAvailability(event)}>
-                    <p>{selectedParticipant.status === "responded"
-                      ? (selected.allow_participant_updates ? I18N.responseReplace : I18N.responseRecorded)
-                      : I18N.invitationHelp}</p>
-                    {selectedParticipant.status === "responded" && selected.allow_participant_updates ? (
-                      <p className="scheduling-capability-note">{I18N.updateResponseHelp}</p>
-                    ) : null}
-                    <div className="scheduling-response-grid">
-                      {selected.slots.map((slot) => (
-                        <label key={slot.id}>
-                          <span><strong>{slot.label}</strong><small>{formatRange(slot.start_at, slot.end_at)}</small></span>
-                          <select
-                            value={availability[slot.id] ?? ""}
-                            disabled={availabilityLoading || (selectedParticipant.status === "responded" && !selected.allow_participant_updates)}
-                            onChange={(event) => setAvailability((current) => ({
-                              ...current,
-                              [slot.id]: event.target.value as SchedulingAvailabilityValue | ""
-                            }))}>
-                            <option value="">{I18N.chooseAvailability}</option>
-                            <option value="available">{I18N.available}</option>
-                            <option value="maybe">{I18N.maybe}</option>
-                            <option value="unavailable">{I18N.unavailable}</option>
-                          </select>
-                        </label>
-                      ))}
-                    </div>
-                  </form>
-                </Card>
+                  ) : null}
+                </div>
+              )}>
+              {loading ? <p className="scheduling-note" role="status">{I18N.loading}</p> : null}
+              <RequestGroup
+                title={I18N.myRequests}
+                requests={groups.owned}
+                selectedId={editorMode ? undefined : selected?.id}
+                actor={actor}
+                onSelect={selectRequest} />
+              <RequestGroup
+                title={I18N.invitedRequests}
+                requests={groups.invited}
+                selectedId={editorMode ? undefined : selected?.id}
+                actor={actor}
+                onSelect={selectRequest} />
+              {canAdminister && groups.other.length ? (
+                <RequestGroup
+                  title={I18N.managedRequests}
+                  requests={groups.other}
+                  selectedId={editorMode ? undefined : selected?.id}
+                  actor={actor}
+                  onSelect={selectRequest} />
               ) : null}
+            </Card>
+          </aside>
 
-              <Card title={I18N.candidateSlots}>
-                <CandidateSlotsGrid
-                  slots={selected.slots}
-                  optionResultById={optionResultById}
-                  canDecide={canManageSelected && selected.status === "closed"}
-                  saving={saving}
-                  onDecide={(slot) => void runAction(() => decideSchedulingRequest(settings, selected.id, {
-                    slot_id: slot.id,
-                    handoff_to_calendar: selected.create_calendar_event_on_decision
-                  }))} />
-              </Card>
+          <section className="scheduling-main-panel">
+            {error ? <DismissibleAlert tone="danger" resetKey={error}>{error}</DismissibleAlert> : null}
+            {success ? <DismissibleAlert tone="success" resetKey={success}>{success}</DismissibleAlert> : null}
 
-              {selected.calendar_integration_enabled && canManageSelected && (showPlanningCalendarActions || showFinalCalendarAction || selected.calendar_event_id) ? (
-                <Card
-                  title={I18N.calendarCoordination}
-                  actions={(
-                    <div className="scheduling-card-actions">
-                      {showPlanningCalendarActions ? (
-                        <Button
-                          type="button"
-                          disabled={saving || !canReadAvailability}
-                          title={!canReadAvailability ? I18N.requiresAvailabilityRead : undefined}
-                          onClick={() => void runAction(() => evaluateSchedulingFreeBusy(settings, selected.id))}>
-                          <RefreshCw aria-hidden="true" size={16} /> {I18N.checkFreeBusy}
-                        </Button>
-                      ) : null}
-                      {showPlanningCalendarActions && selected.calendar_hold_enabled ? (
-                        <Button
-                          type="button"
-                          disabled={saving || !canWriteCalendarEvent}
-                          title={!canWriteCalendarEvent ? I18N.requiresEventWrite : undefined}
-                          onClick={() => void runAction(() => createSchedulingHolds(settings, selected.id))}>
-                          <Clock aria-hidden="true" size={16} /> {I18N.holds}
-                        </Button>
-                      ) : null}
-                      {showFinalCalendarAction ? (
-                        <Button
-                          type="button"
-                          disabled={saving || !canWriteCalendarEvent}
-                          title={!canWriteCalendarEvent ? I18N.requiresEventWrite : undefined}
-                          onClick={() => void runAction(() => createSchedulingCalendarEvent(settings, selected.id))}>
-                          <CalendarCheck aria-hidden="true" size={16} /> {I18N.finalEventLabel}
-                        </Button>
-                      ) : null}
+            {editorMode ? (
+              <div className="scheduling-editor-surface">
+                <header className="scheduling-page-header">
+                  <div className="scheduling-page-title">
+                    <CalendarCheck aria-hidden="true" size={20} />
+                    <div>
+                      <PageTitle>{editorMode === "create" ? I18N.newRequest : I18N.edit}</PageTitle>
+                      <p>{editorMode === "create" ? I18N.addRequest : title}</p>
                     </div>
-                  )}>
-                  {CalendarPicker && selected.calendar_id ? (
-                    <CalendarPicker
-                      className="scheduling-selected-calendar"
-                      settings={settings}
-                      auth={auth}
-                      value={selected.calendar_id}
-                      onChange={() => undefined}
-                      label={I18N.configuredCalendar}
-                      disabled />
-                  ) : <p>{I18N.configuredCalendar}</p>}
-                </Card>
-              ) : null}
-
-              <div className="scheduling-columns">
-                <Card title={I18N.participants}>
-                  <div className="scheduling-status-row">
-                    <span>{i18nMessage("i18n:govoplan-scheduling.value_participants.e776b092", { value0: selected.participant_aggregate.total })}</span>
-                    {Object.entries(selected.participant_aggregate.status_counts)
-                      .filter(([, count]) => count > 0)
-                      .map(([status, count]) => (
-                        <span key={status}><strong>{participantStatusLabel(status)}</strong> {count}</span>
-                      ))}
                   </div>
-                  {selected.effective_participant_visibility === "names_and_statuses" ? (
-                    <ParticipantsGrid participants={selected.participants} />
-                  ) : <p className="scheduling-capability-note">{I18N.participantRosterHidden}</p>}
-                </Card>
-                <Card title={I18N.notifications}>
-                  {notifications.length ? notifications.map((notification) => (
-                    <div className="scheduling-compact-row" key={notification.id}>
-                      <span>{notificationKindLabel(notification.event_kind)}</span>
-                      <small>{notificationStatusLabel(notification.status)}</small>
+                  <div className="scheduling-page-actions">
+                    <Button type="button" onClick={discardEditor} disabled={saving}>{I18N.discard}</Button>
+                    <Button type="submit" form="scheduling-editor-form" variant="primary" disabled={saving || !canCreateOrWrite}>
+                      <Save aria-hidden="true" size={16} /> {saving ? I18N.saving : I18N.save}
+                    </Button>
+                  </div>
+                </header>
+
+                <form
+                  id="scheduling-editor-form"
+                  className="scheduling-editor-scroll"
+                  onSubmit={(event) => {
+                    event.preventDefault();
+                    void persistDraft();
+                  }}>
+                  <Card title={I18N.basicInformation}>
+                    <div className="form-grid">
+                      <FormField label={I18N.title}>
+                        <input required maxLength={500} value={title} onChange={(event) => changeDraft(setTitle, event.target.value)} />
+                      </FormField>
+                      <FormField label={I18N.description}>
+                        <textarea rows={4} value={description} onChange={(event) => changeDraft(setDescription, event.target.value)} />
+                      </FormField>
+                      <FormField label={I18N.location}>
+                        <input maxLength={500} value={location} onChange={(event) => changeDraft(setLocation, event.target.value)} />
+                      </FormField>
                     </div>
-                  )) : <p className="scheduling-note">{I18N.noNotifications}</p>}
+                  </Card>
+
+                  <Card title={I18N.calendarIntegration}>
+                    <ToggleSwitch
+                      label={I18N.calendar}
+                      help={I18N.calendarDescription}
+                      checked={calendarEnabled}
+                      disabled={!calendarIntegrationAvailable}
+                      onChange={(checked) => {
+                        setCalendarEnabled(checked);
+                        if (!checked) setCalendarId("");
+                        setDraftDirty(true);
+                      }} />
+                    {!calendarIntegrationAvailable ? <p className="scheduling-capability-note">{I18N.calendarUnavailable}</p> : null}
+                    {calendarEnabled && CalendarPicker ? (
+                      <CalendarPicker
+                        settings={settings}
+                        auth={auth}
+                        value={calendarId}
+                        onChange={(value) => {
+                          setCalendarId(value);
+                          setDraftDirty(true);
+                        }}
+                        label={I18N.calendar}
+                        emptyLabel={I18N.selectCalendar}
+                        required />
+                    ) : null}
+                  </Card>
+
+                  <EditableSlots
+                    slots={slots}
+                    disabled={!canCreateOrWrite}
+                    reorderable={editorMode === "create"}
+                    onAddBelow={(index) => {
+                      setSlots((items) => editorMode === "edit"
+                        ? [...items, newSlot(items.length + 1, translateText)]
+                        : insertAfter(items, index, newSlot(items.length + 1, translateText)));
+                      setDraftDirty(true);
+                    }}
+                    onChange={changeSlotDraft}
+                    onMove={(from, to) => {
+                      setSlots((items) => moveItem(items, from, to));
+                      setDraftDirty(true);
+                    }}
+                    onRemove={(index) => {
+                      setSlots((items) => items.filter((_item, itemIndex) => itemIndex !== index));
+                      setDraftDirty(true);
+                    }} />
+
+                  <EditableParticipants
+                    participants={participants}
+                    disabled={!canCreateOrWrite}
+                    onAddBelow={(index) => {
+                      setParticipants((items) => insertAfter(items, index, emptyParticipant()));
+                      setDraftDirty(true);
+                    }}
+                    onChange={(index, patch) => {
+                      setParticipants((items) => items.map((item, itemIndex) => itemIndex === index ? { ...item, ...patch } : item));
+                      setDraftDirty(true);
+                    }}
+                    onRemove={(index) => {
+                      setParticipants((items) => items.filter((_item, itemIndex) => itemIndex !== index));
+                      setDraftDirty(true);
+                    }} />
+
+                  <SchedulingPrivacySettings
+                    disabled={!canCreateOrWrite}
+                    participantRosterVisible={participantRosterVisible}
+                    onChange={(value) => {
+                      setParticipantRosterVisible(value);
+                      setDraftDirty(true);
+                    }} />
+
+                  <SchedulingSettings
+                    disabled={!canCreateOrWrite}
+                    policyLocked={participationPolicyLocked}
+                    notifyOnAnswers={notifyOnAnswers}
+                    singleChoice={singleChoice}
+                    participantLimitEnabled={participantLimitEnabled}
+                    maxParticipantsPerOption={maxParticipantsPerOption}
+                    allowMaybe={allowMaybe}
+                    allowComments={allowComments}
+                    participantEmailRequired={participantEmailRequired}
+                    anonymousPasswordProtectionEnabled={anonymousPasswordProtectionEnabled}
+                    anonymousPassword={anonymousPassword}
+                    passwordRequired={anonymousPasswordProtectionEnabled && !(requests.find((request) => request.id === editingRequestId)?.anonymous_password_protection_enabled)}
+                    onChange={(field, value) => {
+                      setDraftDirty(true);
+                      if (field === "notifyOnAnswers") setNotifyOnAnswers(Boolean(value));
+                      if (field === "singleChoice") setSingleChoice(Boolean(value));
+                      if (field === "participantLimitEnabled") setParticipantLimitEnabled(Boolean(value));
+                      if (field === "maxParticipantsPerOption") setMaxParticipantsPerOption(Number(value));
+                      if (field === "allowMaybe") setAllowMaybe(Boolean(value));
+                      if (field === "allowComments") setAllowComments(Boolean(value));
+                      if (field === "participantEmailRequired") setParticipantEmailRequired(Boolean(value));
+                      if (field === "anonymousPasswordProtectionEnabled") {
+                        setAnonymousPasswordProtectionEnabled(Boolean(value));
+                        if (!value) setAnonymousPassword("");
+                      }
+                      if (field === "anonymousPassword") setAnonymousPassword(String(value));
+                    }} />
+
+                </form>
+              </div>
+            ) : selected ? (
+              <div className="scheduling-detail">
+                <Card
+                  title={selected.title}
+                  actions={(
+                    <div className="scheduling-actions">
+                      {canEditSelected ? (
+                        <Button type="button" onClick={() => beginEdit(selected)} disabled={saving}>
+                          <Pencil aria-hidden="true" size={16} /> {I18N.edit}
+                        </Button>
+                      ) : null}
+                      {canManageSelected ? (
+                        <LifecycleActions
+                          request={selected}
+                          saving={saving}
+                          onOpen={() => void runAction(() => openSchedulingRequest(settings, selected.id))}
+                          onClose={() => requestNavigation(() => void runAction(() => closeSchedulingRequest(settings, selected.id)))}
+                          onReminder={() => void runAction(() => createSchedulingNotifications(settings, selected.id, "reminder"))} />
+                      ) : null}
+                    </div>
+                  )}>
+                  <div className="scheduling-status-row">
+                    <StatusBadge status={selected.status} label={requestStatusLabel(selected, actor)} />
+                  </div>
+                  {selected.description ? <p>{selected.description}</p> : null}
+                  {selected.location ? <p><strong>{I18N.location}:</strong> {selected.location}</p> : null}
+                </Card>
+
+                <ParticipationStats
+                  request={selected}
+                  responseCount={summary?.poll_summary.response_count
+                    ?? selected.participant_aggregate.status_counts.responded
+                    ?? null}
+                  loading={detailsLoading} />
+
+                {summaryUnavailable ? (
+                  <DismissibleAlert tone="info" dismissible={false} compact>
+                    {I18N.resultsUnavailable}
+                  </DismissibleAlert>
+                ) : null}
+
+                {selected.public_participation_policy_enforcement_available === false ? (
+                  <DismissibleAlert tone="warning" dismissible={false} compact>
+                    {selected.public_participation_policy_enforcement_reason || I18N.publicPolicyUnavailable}
+                  </DismissibleAlert>
+                ) : null}
+
+                {selectedParticipant && selected.status === "collecting" ? (
+                  <Card
+                    title={I18N.candidateAvailability}
+                    actions={(
+                      <Button
+                        variant="primary"
+                        type="submit"
+                        form="scheduling-response-form"
+                        disabled={saving || availabilityLoading || !canRespond || (selectedParticipant.status === "responded" && !selected.allow_participant_updates)}>
+                        <Send aria-hidden="true" size={16} />
+                        {selectedParticipant.status === "responded" ? I18N.updateResponse : I18N.sendResponse}
+                      </Button>
+                    )}>
+                    <form
+                      id="scheduling-response-form"
+                      className="scheduling-response-card"
+                      aria-busy={availabilityLoading}
+                      onSubmit={(event) => void sendAvailability(event)}>
+                      <p>{selectedParticipant.status === "responded"
+                        ? (selected.allow_participant_updates ? I18N.responseReplace : I18N.responseRecorded)
+                        : I18N.invitationHelp}</p>
+                      {selectedParticipant.status === "responded" && selected.allow_participant_updates ? (
+                        <p className="scheduling-capability-note">{I18N.updateResponseHelp}</p>
+                      ) : null}
+                      <div className="scheduling-response-grid">
+                        {selected.slots.map((slot) => (
+                          <label key={slot.id}>
+                            <span><strong>{slot.label}</strong><small>{formatRange(slot.start_at, slot.end_at)}</small></span>
+                            <select
+                              value={availability[slot.id] ?? ""}
+                              disabled={availabilityLoading || (selectedParticipant.status === "responded" && !selected.allow_participant_updates)}
+                              onChange={(event) => changeAvailability(selected, slot.id, event.target.value as SchedulingAvailabilityValue | "")}>
+                              <option value="">{I18N.chooseAvailability}</option>
+                              <option value="available">{I18N.available}</option>
+                              {selected.allow_maybe ? <option value="maybe">{I18N.maybe}</option> : null}
+                              <option value="unavailable">{I18N.unavailable}</option>
+                            </select>
+                          </label>
+                        ))}
+                      </div>
+                      {selected.allow_comments ? (
+                        <FormField label={I18N.comment} help={I18N.allowCommentsHelp}>
+                          <textarea
+                            rows={3}
+                            maxLength={4000}
+                            value={availabilityComment}
+                            disabled={availabilityLoading || (selectedParticipant.status === "responded" && !selected.allow_participant_updates)}
+                            onChange={(event) => setAvailabilityComment(event.target.value)} />
+                        </FormField>
+                      ) : null}
+                    </form>
+                  </Card>
+                ) : null}
+
+                <Card title={I18N.candidateSlots}>
+                  <CandidateSlotsGrid
+                    slots={selected.slots}
+                    optionResultById={optionResultById}
+                    showDecisionAction={canManageSelected}
+                    decisionEnabled={selected.status === "closed"}
+                    resultsAvailable={!summaryUnavailable && !detailsLoading}
+                    saving={saving}
+                    allowMaybe={selected.allow_maybe}
+                    maxParticipantsPerOption={selected.max_participants_per_option}
+                    onDecide={(slot) => void runAction(() => decideSchedulingRequest(settings, selected.id, {
+                      slot_id: slot.id,
+                      handoff_to_calendar: selected.create_calendar_event_on_decision
+                    }))} />
+                </Card>
+
+                {selected.calendar_integration_enabled && canManageSelected && (showPlanningCalendarActions || showFinalCalendarAction || selected.calendar_event_id) ? (
+                  <Card
+                    title={I18N.calendarCoordination}
+                    actions={(
+                      <div className="scheduling-card-actions">
+                        {showPlanningCalendarActions ? (
+                          <Button
+                            type="button"
+                            disabled={saving || !canReadAvailability}
+                            disabledReason={!canReadAvailability ? I18N.requiresAvailabilityRead : undefined}
+                            onClick={() => void runAction(() => evaluateSchedulingFreeBusy(settings, selected.id))}>
+                            <RefreshCw aria-hidden="true" size={16} /> {I18N.checkFreeBusy}
+                          </Button>
+                        ) : null}
+                        {showPlanningCalendarActions && selected.calendar_hold_enabled ? (
+                          <Button
+                            type="button"
+                            disabled={saving || !canWriteCalendarEvent}
+                            disabledReason={!canWriteCalendarEvent ? I18N.requiresEventWrite : undefined}
+                            onClick={() => void runAction(() => createSchedulingHolds(settings, selected.id))}>
+                            <Clock aria-hidden="true" size={16} /> {I18N.holds}
+                          </Button>
+                        ) : null}
+                        {showFinalCalendarAction ? (
+                          <Button
+                            type="button"
+                            disabled={saving || !canWriteCalendarEvent}
+                            disabledReason={!canWriteCalendarEvent ? I18N.requiresEventWrite : undefined}
+                            onClick={() => void runAction(() => createSchedulingCalendarEvent(settings, selected.id))}>
+                            <CalendarCheck aria-hidden="true" size={16} /> {I18N.finalEventLabel}
+                          </Button>
+                        ) : null}
+                      </div>
+                    )}>
+                    {CalendarPicker && selected.calendar_id ? (
+                      <CalendarPicker
+                        className="scheduling-selected-calendar"
+                        settings={settings}
+                        auth={auth}
+                        value={selected.calendar_id}
+                        onChange={() => undefined}
+                        label={I18N.configuredCalendar}
+                        disabled />
+                    ) : <p>{I18N.configuredCalendar}</p>}
+                  </Card>
+                ) : null}
+
+                <div className="scheduling-columns">
+                  <Card title={I18N.participants}>
+                    <div className="scheduling-status-row">
+                      <span>{i18nMessage("i18n:govoplan-scheduling.value_participants.e776b092", { value0: selected.participant_aggregate.total })}</span>
+                      {Object.entries(selected.participant_aggregate.status_counts)
+                        .filter(([, count]) => count > 0)
+                        .map(([status, count]) => (
+                          <span key={status}><strong>{participantStatusLabel(status)}</strong> {count}</span>
+                        ))}
+                    </div>
+                    {selected.effective_participant_visibility === "names_and_statuses" ? (
+                      <ParticipantsGrid participants={selected.participants} />
+                    ) : <p className="scheduling-capability-note">{I18N.participantRosterHidden}</p>}
+                  </Card>
+                  <Card title={I18N.notifications}>
+                    {notificationsUnavailable ? (
+                      <p className="scheduling-note">{I18N.notificationsUnavailable}</p>
+                    ) : notifications.length ? notifications.map((notification) => (
+                      <div className="scheduling-compact-row" key={notification.id}>
+                        <span>{notificationKindLabel(notification.event_kind)}</span>
+                        <StatusBadge status={notification.status} label={notificationStatusLabel(notification.status)} />
+                      </div>
+                    )) : <p className="scheduling-note">{I18N.noNotifications}</p>}
+                  </Card>
+                </div>
+
+                <Card title={I18N.whatActionsDo} collapsible collapseKey="scheduling-action-help">
+                  <ul className="scheduling-action-help">
+                    <li>i18n:govoplan-scheduling.open_starts_collecting_availability_responses.c8ec34e5</li>
+                    <li>i18n:govoplan-scheduling.close_stops_accepting_new_availability_responses.a1d57519</li>
+                    <li>i18n:govoplan-scheduling.free_busy_checks_each_candidate_slot_against_the_selecte.50f0371a</li>
+                    <li>i18n:govoplan-scheduling.tentative_holds_create_one_provisional_calendar_event_pe.ff3f1884</li>
+                    <li>i18n:govoplan-scheduling.the_final_event_is_created_only_for_the_selected_slot.e3621252</li>
+                    <li>i18n:govoplan-scheduling.reminder_creates_a_notification_job_for_every_active_par.7ec68797</li>
+                  </ul>
                 </Card>
               </div>
-
-              <Card title={I18N.whatActionsDo} collapsible collapseKey="scheduling-action-help">
-                <ul className="scheduling-action-help">
-                  <li>i18n:govoplan-scheduling.open_starts_collecting_availability_responses.c8ec34e5</li>
-                  <li>i18n:govoplan-scheduling.close_stops_accepting_new_availability_responses.a1d57519</li>
-                  <li>i18n:govoplan-scheduling.free_busy_checks_each_candidate_slot_against_the_selecte.50f0371a</li>
-                  <li>i18n:govoplan-scheduling.tentative_holds_create_one_provisional_calendar_event_pe.ff3f1884</li>
-                  <li>i18n:govoplan-scheduling.the_final_event_is_created_only_for_the_selected_slot.e3621252</li>
-                  <li>i18n:govoplan-scheduling.reminder_creates_a_notification_job_for_every_active_par.7ec68797</li>
-                </ul>
-              </Card>
-            </>
-          ) : <div className="scheduling-empty">{I18N.noRequest}</div>}
+            ) : <div className="scheduling-empty">{I18N.noRequest}</div>}
+          </section>
         </div>
       </section>
     </main>
@@ -780,6 +1116,53 @@ export default function SchedulingPage({ settings, auth }: { settings: ApiSettin
     setDraftDirty(true);
   }
 
+  function changeSlotDraft(index: number, field: "label" | "start_at" | "end_at", value: string) {
+    setSlots((items) => items.map((item, itemIndex) => {
+      if (itemIndex !== index) return item;
+      if (field === "start_at" && value && (!item.end_at || new Date(item.end_at) <= new Date(value))) {
+        return { ...item, start_at: value, end_at: addLocalMinutes(value, 60) };
+      }
+      return { ...item, [field]: value };
+    }));
+    setDraftDirty(true);
+  }
+
+  function changeAvailability(
+    request: SchedulingRequest,
+    slotId: string,
+    value: SchedulingAvailabilityValue | ""
+  ) {
+    setAvailability((current) => applySchedulingAvailabilityChoice(
+      request.slots.map((slot) => slot.id),
+      current,
+      slotId,
+      value,
+      request.single_choice
+    ));
+  }
+
+  function selectRequest(requestId: string) {
+    if (!editorMode && requestId === selected?.id) return;
+    requestNavigation(() => {
+      exitEditor();
+      setSelectedId(requestId);
+      setSelectedRequestSearchParam(requestId);
+      setError("");
+      setSuccess("");
+    });
+  }
+
+  function setSelectedRequestSearchParam(requestId: string) {
+    const next = new URLSearchParams(searchParams);
+    next.set("request_id", requestId);
+    setSearchParams(next, { replace: true });
+  }
+
+  function resetResponseDraft() {
+    setAvailability({ ...savedAvailability });
+    setAvailabilityComment(savedAvailabilityComment);
+  }
+
   function replaceRequest(updated: SchedulingRequest) {
     setRequests((items) => items.map((item) => item.id === updated.id ? updated : item));
   }
@@ -793,7 +1176,15 @@ export default function SchedulingPage({ settings, auth }: { settings: ApiSettin
     setSlots(initialSlots(translateText));
     setParticipants([emptyParticipant()]);
     setParticipantRosterVisible(false);
-    setCreateSection("basic");
+    setNotifyOnAnswers(true);
+    setSingleChoice(false);
+    setParticipantLimitEnabled(false);
+    setMaxParticipantsPerOption(1);
+    setAllowMaybe(true);
+    setAllowComments(false);
+    setParticipantEmailRequired(false);
+    setAnonymousPasswordProtectionEnabled(false);
+    setAnonymousPassword("");
     setDraftDirty(false);
   }
 }
@@ -812,7 +1203,8 @@ function RequestGroup({
   onSelect: (requestId: string) => void;
 }) {
   return (
-    <Card title={title}>
+    <section className="scheduling-request-group" aria-label={title}>
+      <h2>{title}</h2>
       <div className="scheduling-list-group">
         {requests.length ? (
           <SelectionList label={title} className="scheduling-request-list">
@@ -823,12 +1215,178 @@ function RequestGroup({
                 className="scheduling-list-item"
                 onClick={() => onSelect(request.id)}>
                 <span><strong>{request.title}</strong><small>{formatRelevantDate(request)}</small></span>
-                <small className="scheduling-list-status">{requestStatusLabel(request, actor)}</small>
+                <StatusBadge status={request.status} label={requestStatusLabel(request, actor)} />
               </SelectionListItem>
             ))}
           </SelectionList>
         ) : <p className="scheduling-list-empty">{I18N.noRequestsInGroup}</p>}
       </div>
+    </section>
+  );
+}
+
+type SchedulingSettingField =
+  | "notifyOnAnswers"
+  | "singleChoice"
+  | "participantLimitEnabled"
+  | "maxParticipantsPerOption"
+  | "allowMaybe"
+  | "allowComments"
+  | "participantEmailRequired"
+  | "anonymousPasswordProtectionEnabled"
+  | "anonymousPassword";
+
+function SchedulingPrivacySettings({
+  disabled,
+  participantRosterVisible,
+  onChange
+}: {
+  disabled: boolean;
+  participantRosterVisible: boolean;
+  onChange: (value: boolean) => void;
+}) {
+  return (
+    <Card title={I18N.participantPrivacy}>
+      <ToggleSwitch
+        label={I18N.participantRosterVisibility}
+        help={I18N.participantRosterVisibilityHelp}
+        checked={participantRosterVisible}
+        disabled={disabled}
+        onChange={onChange} />
+    </Card>
+  );
+}
+
+function SchedulingSettings({
+  disabled,
+  policyLocked,
+  notifyOnAnswers,
+  singleChoice,
+  participantLimitEnabled,
+  maxParticipantsPerOption,
+  allowMaybe,
+  allowComments,
+  participantEmailRequired,
+  anonymousPasswordProtectionEnabled,
+  anonymousPassword,
+  passwordRequired,
+  onChange
+}: {
+  disabled: boolean;
+  policyLocked: boolean;
+  notifyOnAnswers: boolean;
+  singleChoice: boolean;
+  participantLimitEnabled: boolean;
+  maxParticipantsPerOption: number;
+  allowMaybe: boolean;
+  allowComments: boolean;
+  participantEmailRequired: boolean;
+  anonymousPasswordProtectionEnabled: boolean;
+  anonymousPassword: string;
+  passwordRequired: boolean;
+  onChange: (field: SchedulingSettingField, value: boolean | number | string) => void;
+}) {
+  return (
+    <Card title={I18N.generalSettings}>
+      <div className="settings-grid">
+        <ToggleSwitch
+          label={I18N.notifyOnAnswers}
+          help={I18N.notifyOnAnswersHelp}
+          checked={notifyOnAnswers}
+          disabled={disabled}
+          onChange={(value) => onChange("notifyOnAnswers", value)} />
+        <ToggleSwitch
+          label={I18N.singleChoice}
+          help={I18N.singleChoiceHelp}
+          checked={singleChoice}
+          disabled={disabled || policyLocked}
+          onChange={(value) => onChange("singleChoice", value)} />
+        <ToggleSwitch
+          label={I18N.allowMaybe}
+          help={I18N.allowMaybeHelp}
+          checked={allowMaybe}
+          disabled={disabled || policyLocked}
+          onChange={(value) => onChange("allowMaybe", value)} />
+        <ToggleSwitch
+          label={I18N.allowComments}
+          help={I18N.allowCommentsHelp}
+          checked={allowComments}
+          disabled={disabled || policyLocked}
+          onChange={(value) => onChange("allowComments", value)} />
+        <ToggleSwitch
+          label={I18N.anonymousEmailRequired}
+          help={I18N.anonymousEmailRequiredHelp}
+          checked={participantEmailRequired}
+          disabled={disabled || policyLocked}
+          onChange={(value) => onChange("participantEmailRequired", value)} />
+        <div className="scheduling-setting-with-field">
+          <ToggleSwitch
+            label={I18N.maxParticipants}
+            help={I18N.maxParticipantsHelp}
+            checked={participantLimitEnabled}
+            disabled={disabled || policyLocked}
+            onChange={(value) => onChange("participantLimitEnabled", value)} />
+          <FormField label={I18N.maxParticipantsCount} help={I18N.maxParticipantsHelp}>
+            <input
+              type="number"
+              min={1}
+              step={1}
+              required={participantLimitEnabled}
+              disabled={disabled || policyLocked || !participantLimitEnabled}
+              value={maxParticipantsPerOption}
+              onChange={(event) => onChange("maxParticipantsPerOption", Math.max(1, event.target.valueAsNumber || 1))} />
+          </FormField>
+        </div>
+        <div className="scheduling-setting-with-field">
+          <ToggleSwitch
+            label={I18N.anonymousPasswordProtection}
+            help={I18N.anonymousPasswordProtectionHelp}
+            checked={anonymousPasswordProtectionEnabled}
+            disabled={disabled || policyLocked}
+            onChange={(value) => onChange("anonymousPasswordProtectionEnabled", value)} />
+          <FormField label={I18N.anonymousPassword} help={I18N.anonymousPasswordHelp}>
+            <PasswordField
+              autoComplete="new-password"
+              minLength={8}
+              maxLength={1024}
+              required={passwordRequired}
+              disabled={disabled || policyLocked || !anonymousPasswordProtectionEnabled}
+              value={anonymousPassword}
+              saved={anonymousPasswordProtectionEnabled && !passwordRequired}
+              onValueChange={(value) => onChange("anonymousPassword", value)} />
+          </FormField>
+        </div>
+        </div>
+      {policyLocked ? (
+        <DismissibleAlert tone="info" dismissible={false} compact>
+          {I18N.policyLocked}
+        </DismissibleAlert>
+      ) : null}
+    </Card>
+  );
+}
+
+function ParticipationStats({
+  request,
+  responseCount,
+  loading
+}: {
+  request: SchedulingRequest;
+  responseCount: number | null;
+  loading: boolean;
+}) {
+  const total = request.participant_aggregate.total;
+  const knownResponseCount = responseCount ?? 0;
+  const awaiting = responseCount === null ? null : Math.max(0, total - knownResponseCount);
+  const rate = responseCount === null ? null : total ? Math.round((knownResponseCount / total) * 100) : 0;
+  return (
+    <Card title={I18N.participation}>
+      <div className="metric-grid inside">
+        <MetricCard label={I18N.participants} value={total} />
+        <MetricCard label={I18N.responses} value={loading ? "…" : responseCount ?? "—"} tone="good" />
+        <MetricCard label={I18N.awaiting} value={loading ? "…" : awaiting ?? "—"} tone={awaiting ? "warning" : "neutral"} />
+        <MetricCard label={I18N.participationRate} value={loading ? "…" : rate === null ? "—" : `${rate}%`} tone="info" />
+      </div>
     </Card>
   );
 }
@@ -862,12 +1420,16 @@ function LifecycleActions({
 
 function EditableSlots({
   slots,
+  disabled,
+  reorderable,
   onAddBelow,
   onChange,
   onMove,
   onRemove
 }: {
   slots: SlotDraft[];
+  disabled: boolean;
+  reorderable: boolean;
   onAddBelow: (index: number) => void;
   onChange: (index: number, field: "label" | "start_at" | "end_at", value: string) => void;
   onMove: (from: number, to: number) => void;
@@ -882,8 +1444,9 @@ function EditableSlots({
       value: (slot) => slot.label,
       render: (slot, index) => (
         <input
-          className="scheduling-grid-input"
           required
+          maxLength={500}
+          disabled={disabled}
           aria-label={I18N.title}
           value={slot.label}
           onChange={(event) => onChange(index, "label", event.target.value)} />
@@ -897,8 +1460,8 @@ function EditableSlots({
       value: (slot) => slot.start_at,
       render: (slot, index) => (
         <DateTimeField
-          className="scheduling-grid-date-time"
           required
+          disabled={disabled}
           aria-label={I18N.start}
           value={slot.start_at}
           onChange={(value) => onChange(index, "start_at", value)} />
@@ -912,10 +1475,11 @@ function EditableSlots({
       value: (slot) => slot.end_at,
       render: (slot, index) => (
         <DateTimeField
-          className="scheduling-grid-date-time"
           required
+          disabled={disabled}
           aria-label={I18N.end}
           value={slot.end_at}
+          min={addLocalMinutes(slot.start_at, 1)}
           onChange={(value) => onChange(index, "end_at", value)} />
       )
     },
@@ -926,9 +1490,11 @@ function EditableSlots({
       sticky: "end",
       render: (_slot, index) => (
         <DataGridRowActions
+          disabled={disabled}
+          reorderable={reorderable}
           onAddBelow={() => onAddBelow(index)}
-          onMoveUp={index > 0 ? () => onMove(index, index - 1) : undefined}
-          onMoveDown={index < slots.length - 1 ? () => onMove(index, index + 1) : undefined}
+          onMoveUp={reorderable && index > 0 ? () => onMove(index, index - 1) : undefined}
+          onMoveDown={reorderable && index < slots.length - 1 ? () => onMove(index, index + 1) : undefined}
           onRemove={() => onRemove(index)}
           removeDisabled={slots.length === 1}
           addLabel={I18N.addSlot}
@@ -951,23 +1517,18 @@ function EditableSlots({
 
 function EditableParticipants({
   participants,
-  participantRosterVisible,
   disabled,
-  onParticipantRosterVisibleChange,
   onAddBelow,
   onChange,
-  onMove,
   onRemove
 }: {
   participants: ParticipantDraft[];
-  participantRosterVisible: boolean;
   disabled: boolean;
-  onParticipantRosterVisibleChange: (checked: boolean) => void;
   onAddBelow: (index: number) => void;
   onChange: (index: number, patch: Partial<ParticipantDraft>) => void;
-  onMove: (from: number, to: number) => void;
   onRemove: (index: number) => void;
 }) {
+  const lockedIdentityHelpId = "scheduling-invited-participant-identity-help";
   const columns: DataGridColumn<ParticipantDraft>[] = [
     {
       id: "name",
@@ -977,8 +1538,9 @@ function EditableParticipants({
       value: (participant) => participant.display_name,
       render: (participant, index) => (
         <input
-          className="scheduling-grid-input"
-          disabled={disabled}
+          disabled={disabled || participant.identityLocked}
+          maxLength={500}
+          aria-describedby={participant.identityLocked ? lockedIdentityHelpId : undefined}
           aria-label={I18N.name}
           value={participant.display_name}
           onChange={(event) => onChange(index, { display_name: event.target.value })} />
@@ -992,9 +1554,10 @@ function EditableParticipants({
       value: (participant) => participant.email,
       render: (participant, index) => (
         <input
-          className="scheduling-grid-input"
-          disabled={disabled}
+          disabled={disabled || participant.identityLocked}
           type="email"
+          maxLength={320}
+          aria-describedby={participant.identityLocked ? lockedIdentityHelpId : undefined}
           aria-label={I18N.participantEmail}
           value={participant.email}
           onChange={(event) => onChange(index, { email: event.target.value })} />
@@ -1003,14 +1566,13 @@ function EditableParticipants({
     {
       id: "actions",
       header: I18N.actions,
-      width: 184,
+      width: 112,
       sticky: "end",
       render: (_participant, index) => (
         <DataGridRowActions
           disabled={disabled}
+          reorderable={false}
           onAddBelow={() => onAddBelow(index)}
-          onMoveUp={index > 0 ? () => onMove(index, index - 1) : undefined}
-          onMoveDown={index < participants.length - 1 ? () => onMove(index, index + 1) : undefined}
           onRemove={() => onRemove(index)}
           addLabel={I18N.addParticipant}
           removeLabel={i18nMessage("i18n:govoplan-scheduling.remove_participant_value.e55f2b70", { value0: index + 1 })} />
@@ -1020,12 +1582,9 @@ function EditableParticipants({
 
   return (
     <Card title={I18N.participants}>
-      <ToggleSwitch
-        label={I18N.participantRosterVisibility}
-        help={I18N.participantRosterVisibilityHelp}
-        checked={participantRosterVisible}
-        disabled={disabled}
-        onChange={onParticipantRosterVisibleChange} />
+      {participants.some((participant) => participant.identityLocked) ? (
+        <p id={lockedIdentityHelpId} className="scheduling-capability-note">{I18N.invitedIdentityLocked}</p>
+      ) : null}
       <DataGrid
         id="scheduling-create-participants-grid"
         rows={participants}
@@ -1034,7 +1593,7 @@ function EditableParticipants({
         initialFit="container"
         emptyText={I18N.noParticipants}
         emptyActionColumnId="actions"
-        emptyAction={<DataGridEmptyAction disabled={disabled} onAdd={() => onAddBelow(-1)} label={I18N.addParticipant} />} />
+        emptyAction={<DataGridEmptyAction disabled={disabled} reorderable={false} onAdd={() => onAddBelow(-1)} label={I18N.addParticipant} />} />
     </Card>
   );
 }
@@ -1042,14 +1601,22 @@ function EditableParticipants({
 function CandidateSlotsGrid({
   slots,
   optionResultById,
-  canDecide,
+  showDecisionAction,
+  decisionEnabled,
+  resultsAvailable,
   saving,
+  allowMaybe,
+  maxParticipantsPerOption,
   onDecide
 }: {
   slots: SchedulingCandidateSlot[];
   optionResultById: Map<string, SchedulingPollOptionResult>;
-  canDecide: boolean;
+  showDecisionAction: boolean;
+  decisionEnabled: boolean;
+  resultsAvailable: boolean;
   saving: boolean;
+  allowMaybe: boolean;
+  maxParticipantsPerOption: number | null;
   onDecide: (slot: SchedulingCandidateSlot) => void;
 }) {
   const columns: DataGridColumn<SchedulingCandidateSlot>[] = [
@@ -1062,7 +1629,7 @@ function CandidateSlotsGrid({
       render: (slot) => (
         <span className="scheduling-slot-title">
           <strong>{slot.label}</strong>
-          {slot.freebusy_status ? <small className={`scheduling-freebusy ${slot.freebusy_status}`}>{freeBusyLabel(slot.freebusy_status)}</small> : null}
+          {slot.freebusy_status ? <StatusBadge status={slot.freebusy_status} label={freeBusyLabel(slot.freebusy_status)} /> : null}
         </span>
       )
     },
@@ -1073,23 +1640,36 @@ function CandidateSlotsGrid({
       header: I18N.available,
       width: 100,
       align: "right",
-      value: (slot) => slot.poll_option_id ? optionResultById.get(slot.poll_option_id)?.values.available ?? 0 : 0
+      value: (slot) => resultsAvailable
+        ? optionResultById.get(slot.poll_option_id ?? `slot-${slot.position + 1}`)?.values.available ?? 0
+        : "—"
     },
-    {
+    ...(allowMaybe ? [{
       id: "maybe",
       header: I18N.maybe,
       width: 90,
       align: "right",
-      value: (slot) => slot.poll_option_id ? optionResultById.get(slot.poll_option_id)?.values.maybe ?? 0 : 0
-    },
+      value: (slot) => resultsAvailable
+        ? optionResultById.get(slot.poll_option_id ?? `slot-${slot.position + 1}`)?.values.maybe ?? 0
+        : "—"
+    } satisfies DataGridColumn<SchedulingCandidateSlot>] : []),
+    ...(maxParticipantsPerOption !== null ? [{
+      id: "capacity",
+      header: I18N.capacity,
+      width: 100,
+      align: "right",
+      value: () => maxParticipantsPerOption
+    } satisfies DataGridColumn<SchedulingCandidateSlot>] : []),
     {
       id: "unavailable",
       header: I18N.unavailable,
       width: 110,
       align: "right",
-      value: (slot) => slot.poll_option_id ? optionResultById.get(slot.poll_option_id)?.values.unavailable ?? 0 : 0
+      value: (slot) => resultsAvailable
+        ? optionResultById.get(slot.poll_option_id ?? `slot-${slot.position + 1}`)?.values.unavailable ?? 0
+        : "—"
     },
-    {
+    ...(showDecisionAction ? [{
       id: "actions",
       header: I18N.actions,
       width: 72,
@@ -1098,11 +1678,11 @@ function CandidateSlotsGrid({
         id: "decide",
         label: i18nMessage("i18n:govoplan-scheduling.decide_on_value.196409cd", { value0: slot.label }),
         icon: <Check aria-hidden="true" size={16} />,
-        applicable: canDecide,
-        disabled: saving,
+        disabled: saving || !decisionEnabled,
+        disabledReason: !decisionEnabled ? I18N.decideUnavailable : undefined,
         onClick: () => onDecide(slot)
       }]} />
-    }
+    } satisfies DataGridColumn<SchedulingCandidateSlot>] : [])
   ];
 
   return (
@@ -1119,7 +1699,13 @@ function ParticipantsGrid({ participants }: { participants: SchedulingParticipan
   const columns: DataGridColumn<SchedulingParticipant>[] = [
     { id: "name", header: I18N.name, minWidth: 180, resizable: true, value: (participant) => participant.display_name ?? "" },
     { id: "email", header: I18N.participantEmail, minWidth: 220, resizable: true, value: (participant) => participant.email ?? "" },
-    { id: "status", header: I18N.statusLabel, width: 140, value: (participant) => participantStatusLabel(participant.status) }
+    {
+      id: "status",
+      header: I18N.statusLabel,
+      width: 140,
+      value: (participant) => participantStatusLabel(participant.status),
+      render: (participant) => <StatusBadge status={participant.status} label={participantStatusLabel(participant.status)} />
+    }
   ];
 
   return (
@@ -1133,8 +1719,8 @@ function ParticipantsGrid({ participants }: { participants: SchedulingParticipan
   );
 }
 
-function firstRequest(groups: SchedulingRequestGroups): SchedulingRequest | null {
-  return groups.owned[0] ?? groups.invited[0] ?? groups.other[0] ?? null;
+function firstRequest(groups: SchedulingRequestGroups, includeManaged: boolean): SchedulingRequest | null {
+  return groups.owned[0] ?? groups.invited[0] ?? (includeManaged ? groups.other[0] : null) ?? null;
 }
 
 function requestStatusLabel(request: SchedulingRequest, actor: SchedulingActor): string {
@@ -1200,12 +1786,25 @@ function newSlot(position: number, translateText: (value: string) => string): Sl
     draftId: nextDraftId("slot"),
     label: translateText(i18nMessage("i18n:govoplan-scheduling.option_value.3f643dc0", { value0: position })),
     start_at: localValue(start),
-    end_at: localValue(end)
+    end_at: localValue(end),
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
+    metadata: {}
   };
 }
 
 function emptyParticipant(): ParticipantDraft {
-  return { draftId: nextDraftId("participant"), display_name: "", email: "", required: true };
+  return {
+    draftId: nextDraftId("participant"),
+    display_name: "",
+    email: "",
+    participant_type: "external",
+    required: true,
+    metadata: {}
+  };
+}
+
+function normalizeParticipantType(value: string | null): ParticipantDraft["participant_type"] {
+  return value === "internal" || value === "resource" ? value : "external";
 }
 
 let draftIdSequence = 0;
@@ -1233,10 +1832,25 @@ function localValue(date: Date): string {
   return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}`;
 }
 
+function addLocalMinutes(value: string, minutes: number): string {
+  if (!value) return "";
+  const date = new Date(value);
+  if (!Number.isFinite(date.getTime())) return value;
+  return localValue(new Date(date.getTime() + minutes * 60 * 1000));
+}
+
 function isoFromLocal(value: string): string {
   return new Date(value).toISOString();
 }
 
+function availabilityValuesEqual(
+  left: Record<string, SchedulingAvailabilityValue | "">,
+  right: Record<string, SchedulingAvailabilityValue | "">
+): boolean {
+  const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+  return Array.from(keys).every((key) => (left[key] ?? "") === (right[key] ?? ""));
+}
+
 const SHORT_DATE_TIME_OPTIONS: FormatDateTimeOptions = {
   year: undefined,
   month: undefined,
diff --git a/webui/src/features/scheduling/schedulingViewModel.ts b/webui/src/features/scheduling/schedulingViewModel.ts
index 39c81ab..1ad5484 100644
--- a/webui/src/features/scheduling/schedulingViewModel.ts
+++ b/webui/src/features/scheduling/schedulingViewModel.ts
@@ -1,4 +1,8 @@
-import type { SchedulingParticipant, SchedulingRequest } from "../../api/scheduling";
+import type {
+  SchedulingAvailabilityValue,
+  SchedulingParticipant,
+  SchedulingRequest
+} from "../../api/scheduling";
 
 export type SchedulingActor = {
   accountId?: string | null;
@@ -28,20 +32,27 @@ export function schedulingActorIds(actor: SchedulingActor): string[] {
     actor.membershipId,
     actor.identityId,
     actor.email
-  ].filter((value): value is string => Boolean(value))));
+  ].filter((value): value is string => Boolean(value)).flatMap((value) =>
+    value.includes("@") ? [value, value.trim().toLowerCase()] : [value]
+  )));
 }
 
 export function schedulingParticipantForActor(
   request: SchedulingRequest,
   actor: SchedulingActor
 ): SchedulingParticipant | null {
+  const projected = request.participants.find(
+    (participant) => participant.is_current_participant
+  );
+  if (projected) return projected;
   const ids = new Set(schedulingActorIds(actor));
-  return request.participants.find((participant) =>
-    Boolean(
+  return request.participants.find((participant) => {
+    const email = participant.email?.trim().toLowerCase();
+    return Boolean(
       (participant.respondent_id && ids.has(participant.respondent_id)) ||
-      (participant.email && ids.has(participant.email))
-    )
-  ) ?? null;
+      (email && ids.has(email))
+    );
+  }) ?? null;
 }
 
 export function schedulingRequestIsOwned(
@@ -137,6 +148,26 @@ export function schedulingRequestIsPast(
   return slotEnds.every((value) => Number.isFinite(value) && value < now.getTime());
 }
 
+export function applySchedulingAvailabilityChoice(
+  slotIds: string[],
+  current: Record<string, SchedulingAvailabilityValue | "">,
+  slotId: string,
+  value: SchedulingAvailabilityValue | "",
+  singleChoice: boolean
+): Record<string, SchedulingAvailabilityValue | ""> {
+  if (!singleChoice || !["available", "maybe"].includes(value)) {
+    return { ...current, [slotId]: value };
+  }
+  return Object.fromEntries(slotIds.map((candidateId) => [
+    candidateId,
+    candidateId === slotId
+      ? value
+      : current[candidateId] && current[candidateId] !== "unavailable"
+        ? "unavailable"
+        : current[candidateId] ?? ""
+  ]));
+}
+
 const SORT_PHASE_ORDER: Record<SchedulingSortPhase, number> = {
   unanswered: 0,
   answered: 1,
diff --git a/webui/src/i18n/generatedTranslations.ts b/webui/src/i18n/generatedTranslations.ts
index ea7cb19..f1cc634 100644
--- a/webui/src/i18n/generatedTranslations.ts
+++ b/webui/src/i18n/generatedTranslations.ts
@@ -1,5 +1,38 @@
 export const generatedTranslations = {
   en: {
+    "i18n:govoplan-scheduling.save_or_discard_your_unsent_availability_changes_before_leaving.97e10df1": "Save or discard your unsent availability changes before leaving.",
+    "i18n:govoplan-scheduling.a_slot_can_be_selected_after_the_request_is_closed.f91ec02d": "A slot can be selected after the request is closed.",
+    "i18n:govoplan-scheduling.add_maybe_between_yes_and_no_for_each_candidate_slot.74dc9db6": "Add Maybe between Available and Unavailable for each candidate slot.",
+    "i18n:govoplan-scheduling.allow_comments.d63202a6": "Allow comments",
+    "i18n:govoplan-scheduling.awaiting.42aa82e0": "Awaiting",
+    "i18n:govoplan-scheduling.capacity.d3c375f8": "Capacity",
+    "i18n:govoplan-scheduling.comment.d03495b1": "Comment",
+    "i18n:govoplan-scheduling.create_an_organizer_notification_whenever_a_response_is.253ddca8": "Create an organizer notification whenever a response is submitted or updated.",
+    "i18n:govoplan-scheduling.each_participant_can_answer_yes_to_at_most_one_candidate.5313a465": "Each participant can select Available or Maybe for at most one candidate slot.",
+    "i18n:govoplan-scheduling.edit_scheduling_request.7e749c19": "Edit scheduling request",
+    "i18n:govoplan-scheduling.invited_participant_identity_is_locked_remove_and_add_the_participant_to_change_it.34e1201a": "An invited participant's name and email are locked. Remove and add the participant to change them.",
+    "i18n:govoplan-scheduling.guest_links_are_not_issued_while_the_configured_participation.0794ebf0": "Guest links are not issued while the configured participation controls cannot be enforced by the public response gateway. Signed-in participants can still respond here.",
+    "i18n:govoplan-scheduling.guest_password.94545e82": "Guest password",
+    "i18n:govoplan-scheduling.let_participants_add_a_comment_to_their_response.9dce8d17": "Let participants add a comment to their response.",
+    "i18n:govoplan-scheduling.limit_participants_per_option.1e9aa51d": "Limit participants per option",
+    "i18n:govoplan-scheduling.maximum_participants_per_option.5abdfb27": "Maximum participants per option",
+    "i18n:govoplan-scheduling.notify_me_about_each_answer.505749d6": "Notify me about each answer",
+    "i18n:govoplan-scheduling.participants_can_choose_only_one_option.4311f51c": "Participants can choose only one option",
+    "i18n:govoplan-scheduling.participation.9ad70cc4": "Participation",
+    "i18n:govoplan-scheduling.participation_rate.46bc5504": "Participation rate",
+    "i18n:govoplan-scheduling.participation_settings.8dc6f62c": "Participation settings",
+    "i18n:govoplan-scheduling.participant_privacy.108c470f": "Participant privacy",
+    "i18n:govoplan-scheduling.participation_controls_are_locked_after_invitation_links_are_issued.66f5a740": "Participation controls are locked after invitation links are issued. Participant visibility and answer notifications can still be changed.",
+    "i18n:govoplan-scheduling.password_protect_guest_access.13d7f08b": "Password-protect guest access",
+    "i18n:govoplan-scheduling.people_responding_without_an_account_must_provide_an_email.19fd3dc8": "People responding without an account must provide an email address.",
+    "i18n:govoplan-scheduling.people_who_are_not_signed_in_must_enter_this_password.82bcc4ce": "People who are not signed in must enter this password before viewing the request.",
+    "i18n:govoplan-scheduling.provide_a_maybe_option.e39da57a": "Provide a Maybe option",
+    "i18n:govoplan-scheduling.require_an_email_address_from_guests.c2289a58": "Require an email address from guests",
+    "i18n:govoplan-scheduling.responses.3427e3ab": "Responses",
+    "i18n:govoplan-scheduling.response_results_are_not_available_for_this_view.1e82db18": "Response results are not available for this view.",
+    "i18n:govoplan-scheduling.notifications_could_not_be_loaded.f0e1b2c3": "Notifications could not be loaded.",
+    "i18n:govoplan-scheduling.stop_accepting_yes_responses_for_an_option_when_its_limit.79af21db": "Stop accepting Available responses for an option when its limit is reached.",
+    "i18n:govoplan-scheduling.use_at_least_8_characters_the_password_is_never_displayed.035708a2": "Use at least 8 characters. The password is never displayed after it is saved.",
     "i18n:govoplan-scheduling.add_participant.6cff957d": "Add participant",
     "i18n:govoplan-scheduling.add_scheduling_request.3c71be15": "Add scheduling request",
     "i18n:govoplan-scheduling.add_slot.9fcff3ed": "Add slot",
@@ -21,7 +54,6 @@ export const generatedTranslations = {
     "i18n:govoplan-scheduling.close_poll.a6a18916": "Close poll",
     "i18n:govoplan-scheduling.close_stops_accepting_new_availability_responses.a1d57519": "Close stops accepting new availability responses.",
     "i18n:govoplan-scheduling.closed.88d86b77": "Closed",
-    "i18n:govoplan-scheduling.create_and_open_scheduling_request.1dbc9345": "Create and open scheduling request",
     "i18n:govoplan-scheduling.create_calendar_event.0b87cfcf": "Create calendar event",
     "i18n:govoplan-scheduling.create_tentative_holds.51c4744e": "Create tentative holds",
     "i18n:govoplan-scheduling.cancellation.319aaae4": "Cancellation",
@@ -108,6 +140,39 @@ export const generatedTranslations = {
     "i18n:govoplan-scheduling.your_response_has_been_recorded.b855088d": "Your response has been recorded."
   },
   de: {
+    "i18n:govoplan-scheduling.save_or_discard_your_unsent_availability_changes_before_leaving.97e10df1": "Speichern oder verwerfen Sie Ihre noch nicht gesendeten Verfügbarkeitsänderungen, bevor Sie die Ansicht verlassen.",
+    "i18n:govoplan-scheduling.a_slot_can_be_selected_after_the_request_is_closed.f91ec02d": "Ein Terminvorschlag kann ausgewählt werden, nachdem die Anfrage geschlossen wurde.",
+    "i18n:govoplan-scheduling.add_maybe_between_yes_and_no_for_each_candidate_slot.74dc9db6": "Für jeden Terminvorschlag Vielleicht zwischen Verfügbar und Nicht verfügbar anbieten.",
+    "i18n:govoplan-scheduling.allow_comments.d63202a6": "Kommentare erlauben",
+    "i18n:govoplan-scheduling.awaiting.42aa82e0": "Ausstehend",
+    "i18n:govoplan-scheduling.capacity.d3c375f8": "Kapazität",
+    "i18n:govoplan-scheduling.comment.d03495b1": "Kommentar",
+    "i18n:govoplan-scheduling.create_an_organizer_notification_whenever_a_response_is.253ddca8": "Bei jeder neuen oder geänderten Antwort eine Benachrichtigung für die organisierende Person erstellen.",
+    "i18n:govoplan-scheduling.each_participant_can_answer_yes_to_at_most_one_candidate.5313a465": "Jede teilnehmende Person kann höchstens einen Terminvorschlag als Verfügbar oder Vielleicht markieren.",
+    "i18n:govoplan-scheduling.edit_scheduling_request.7e749c19": "Terminanfrage bearbeiten",
+    "i18n:govoplan-scheduling.invited_participant_identity_is_locked_remove_and_add_the_participant_to_change_it.34e1201a": "Name und E-Mail-Adresse einer eingeladenen Person sind gesperrt. Entfernen Sie die Person und fügen Sie sie erneut hinzu, um diese Angaben zu ändern.",
+    "i18n:govoplan-scheduling.guest_links_are_not_issued_while_the_configured_participation.0794ebf0": "Gastlinks werden nicht ausgegeben, solange die konfigurierten Teilnahmeregeln am öffentlichen Antwortzugang nicht durchgesetzt werden können. Angemeldete Teilnehmende können weiterhin hier antworten.",
+    "i18n:govoplan-scheduling.guest_password.94545e82": "Gastpasswort",
+    "i18n:govoplan-scheduling.let_participants_add_a_comment_to_their_response.9dce8d17": "Teilnehmende können ihrer Antwort einen Kommentar hinzufügen.",
+    "i18n:govoplan-scheduling.limit_participants_per_option.1e9aa51d": "Teilnehmende je Terminvorschlag begrenzen",
+    "i18n:govoplan-scheduling.maximum_participants_per_option.5abdfb27": "Maximale Teilnehmendenzahl je Terminvorschlag",
+    "i18n:govoplan-scheduling.notify_me_about_each_answer.505749d6": "Über jede Antwort benachrichtigen",
+    "i18n:govoplan-scheduling.participants_can_choose_only_one_option.4311f51c": "Teilnehmende können nur einen Terminvorschlag wählen",
+    "i18n:govoplan-scheduling.participation.9ad70cc4": "Teilnahme",
+    "i18n:govoplan-scheduling.participation_rate.46bc5504": "Teilnahmequote",
+    "i18n:govoplan-scheduling.participation_settings.8dc6f62c": "Teilnahmeeinstellungen",
+    "i18n:govoplan-scheduling.participant_privacy.108c470f": "Datenschutz für Teilnehmende",
+    "i18n:govoplan-scheduling.participation_controls_are_locked_after_invitation_links_are_issued.66f5a740": "Teilnahmeregeln sind gesperrt, nachdem Einladungslinks erstellt wurden. Sichtbarkeit und Antwortbenachrichtigungen können weiterhin geändert werden.",
+    "i18n:govoplan-scheduling.password_protect_guest_access.13d7f08b": "Gastzugang mit Passwort schützen",
+    "i18n:govoplan-scheduling.people_responding_without_an_account_must_provide_an_email.19fd3dc8": "Personen ohne Konto müssen für ihre Antwort eine E-Mail-Adresse angeben.",
+    "i18n:govoplan-scheduling.people_who_are_not_signed_in_must_enter_this_password.82bcc4ce": "Nicht angemeldete Personen müssen dieses Passwort eingeben, bevor sie die Anfrage sehen können.",
+    "i18n:govoplan-scheduling.provide_a_maybe_option.e39da57a": "Antwort Vielleicht anbieten",
+    "i18n:govoplan-scheduling.require_an_email_address_from_guests.c2289a58": "E-Mail-Adresse von Gästen verlangen",
+    "i18n:govoplan-scheduling.responses.3427e3ab": "Antworten",
+    "i18n:govoplan-scheduling.response_results_are_not_available_for_this_view.1e82db18": "Antwortergebnisse sind für diese Ansicht nicht verfügbar.",
+    "i18n:govoplan-scheduling.notifications_could_not_be_loaded.f0e1b2c3": "Benachrichtigungen konnten nicht geladen werden.",
+    "i18n:govoplan-scheduling.stop_accepting_yes_responses_for_an_option_when_its_limit.79af21db": "Keine weiteren Verfügbar-Antworten annehmen, sobald die Begrenzung eines Terminvorschlags erreicht ist.",
+    "i18n:govoplan-scheduling.use_at_least_8_characters_the_password_is_never_displayed.035708a2": "Verwenden Sie mindestens 8 Zeichen. Das Passwort wird nach dem Speichern nicht mehr angezeigt.",
     "i18n:govoplan-scheduling.add_participant.6cff957d": "Teilnehmende Person hinzufügen",
     "i18n:govoplan-scheduling.add_scheduling_request.3c71be15": "Terminanfrage hinzufügen",
     "i18n:govoplan-scheduling.add_slot.9fcff3ed": "Terminvorschlag hinzufügen",
@@ -129,7 +194,6 @@ export const generatedTranslations = {
     "i18n:govoplan-scheduling.close_poll.a6a18916": "Abstimmung schließen",
     "i18n:govoplan-scheduling.close_stops_accepting_new_availability_responses.a1d57519": "Schließen beendet die Annahme neuer Verfügbarkeitsantworten.",
     "i18n:govoplan-scheduling.closed.88d86b77": "Geschlossen",
-    "i18n:govoplan-scheduling.create_and_open_scheduling_request.1dbc9345": "Terminanfrage erstellen und öffnen",
     "i18n:govoplan-scheduling.create_calendar_event.0b87cfcf": "Kalendertermin erstellen",
     "i18n:govoplan-scheduling.create_tentative_holds.51c4744e": "Vorläufige Reservierungen erstellen",
     "i18n:govoplan-scheduling.cancellation.319aaae4": "Stornierung",
diff --git a/webui/src/styles/scheduling.css b/webui/src/styles/scheduling.css
index e720926..a32f011 100644
--- a/webui/src/styles/scheduling.css
+++ b/webui/src/styles/scheduling.css
@@ -13,8 +13,7 @@
   box-sizing: border-box;
 }
 
-.scheduling-workspace,
-.scheduling-full-editor {
+.scheduling-workspace {
   width: 100%;
   height: 100%;
   min-width: 0;
@@ -26,6 +25,72 @@
   background: var(--bg);
 }
 
+.scheduling-workspace-layout {
+  min-width: 0;
+  min-height: 0;
+  flex: 1 1 auto;
+  display: grid;
+  grid-template-columns: minmax(310px, 370px) minmax(0, 1fr);
+  overflow: hidden;
+}
+
+.scheduling-request-sidebar,
+.scheduling-main-panel,
+.scheduling-editor-surface {
+  min-width: 0;
+  min-height: 0;
+}
+
+.scheduling-request-sidebar {
+  padding: 12px;
+  border-right: var(--border-line);
+  background: var(--panel-soft);
+}
+
+.scheduling-request-sidebar > .card {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+}
+
+.scheduling-request-sidebar > .card > .card-body {
+  min-height: 0;
+  flex: 1 1 auto;
+  overflow: auto;
+  padding: 10px 12px;
+}
+
+.scheduling-sidebar-actions {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.scheduling-sidebar-actions .btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+}
+
+.scheduling-main-panel {
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  background: var(--bg);
+}
+
+.scheduling-main-panel > .alert {
+  flex: 0 0 auto;
+  margin: 12px 14px 0;
+}
+
+.scheduling-editor-surface {
+  flex: 1 1 auto;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
 .scheduling-page-header {
   min-height: 58px;
   flex: 0 0 auto;
@@ -89,28 +154,9 @@
   gap: 6px;
 }
 
-.scheduling-alert,
-.scheduling-success {
-  margin: 10px 14px 0;
-  padding: 9px 11px;
-  border: var(--border-line);
-  border-radius: 7px;
-}
-
-.scheduling-alert {
-  border-color: var(--danger-border-strong);
-  color: var(--danger-text-strong);
-  background: var(--danger-soft);
-}
-
-.scheduling-success {
-  border-color: var(--success);
-  color: var(--success);
-  background: color-mix(in srgb, var(--success) 10%, var(--panel));
-}
-
 .scheduling-detail,
 .scheduling-editor-scroll {
+  flex: 1 1 auto;
   min-width: 0;
   min-height: 0;
   overflow: auto;
@@ -124,15 +170,21 @@
   gap: 12px;
 }
 
-.scheduling-request-groups {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
-  gap: 12px;
+.scheduling-request-group + .scheduling-request-group {
+  margin-top: 14px;
+  padding-top: 14px;
+  border-top: var(--border-line);
+}
+
+.scheduling-request-group h2 {
+  margin: 0 0 8px;
+  color: var(--text-strong);
+  font-size: 13px;
 }
 
 .scheduling-list-group {
   min-height: 52px;
-  max-height: 270px;
+  max-height: min(31vh, 320px);
   overflow: auto;
 }
 
@@ -171,14 +223,6 @@
   font-size: 12px;
 }
 
-.scheduling-list-status {
-  max-width: 120px;
-  padding: 3px 7px;
-  border-radius: 999px;
-  background: var(--panel-soft);
-  font-weight: 700;
-}
-
 .scheduling-list-empty {
   margin: 3px 0 8px;
 }
@@ -187,46 +231,12 @@
   flex-wrap: wrap;
 }
 
-.scheduling-status {
-  padding: 4px 8px;
-  border-radius: 999px;
-  color: var(--text-strong);
-  background: var(--panel-soft);
-  font-size: 12px;
-  font-weight: 800;
-}
-
-.scheduling-status-collecting,
-.scheduling-status-handed_off {
-  background: color-mix(in srgb, var(--accent) 18%, transparent);
-}
-
 .scheduling-slot-title {
   min-width: 0;
   display: grid;
   justify-items: start;
 }
 
-.scheduling-freebusy {
-  display: inline-block;
-  margin-top: 3px;
-  padding: 2px 6px;
-  border-radius: 5px;
-  color: var(--muted);
-  background: var(--panel-soft);
-  font-size: 11px;
-  font-weight: 700;
-}
-
-.scheduling-freebusy.free {
-  color: var(--success);
-}
-
-.scheduling-freebusy.busy,
-.scheduling-freebusy.error {
-  color: var(--danger-text-strong);
-}
-
 .scheduling-columns {
   display: grid;
   grid-template-columns: repeat(2, minmax(0, 1fr));
@@ -284,20 +294,6 @@
   color: var(--muted);
 }
 
-.scheduling-response-grid select,
-.scheduling-field input,
-.scheduling-field textarea,
-.scheduling-grid-input {
-  width: 100%;
-  min-height: 36px;
-  padding: 7px 9px;
-  border: var(--border-line);
-  border-radius: 6px;
-  color: var(--text);
-  background: var(--control-bg);
-  font: inherit;
-}
-
 .scheduling-action-help {
   margin: 0;
 }
@@ -308,47 +304,14 @@
   text-align: center;
 }
 
-.scheduling-editor-page {
-  background: var(--panel);
-}
-
-.scheduling-editor-layout {
+.scheduling-setting-with-field {
   min-width: 0;
-  min-height: 0;
-  flex: 1 1 auto;
   display: grid;
-  grid-template-columns: 198px minmax(0, 1fr);
-  overflow: hidden;
+  gap: 10px;
 }
 
-.scheduling-create-subnav {
-  min-height: 0;
-}
-
-.scheduling-create-section {
-  min-width: 0;
-  scroll-margin-top: 14px;
-}
-
-.scheduling-form-grid {
-  display: grid;
-  grid-template-columns: repeat(2, minmax(0, 1fr));
-  gap: 12px;
-}
-
-.scheduling-field-wide {
-  grid-column: 1 / -1;
-}
-
-.scheduling-field {
-  display: grid;
-  gap: 5px;
-}
-
-.scheduling-field > span {
-  color: var(--muted);
-  font-size: 12px;
-  font-weight: 800;
+.scheduling-setting-with-field .form-field {
+  padding-left: 48px;
 }
 
 .scheduling-capability-note {
@@ -362,9 +325,10 @@
 }
 
 @media (max-width: 900px) {
-  .scheduling-editor-layout {
-    grid-template-columns: minmax(0, 1fr);
+  .scheduling-workspace-layout {
+    grid-template-columns: minmax(270px, 320px) minmax(0, 1fr);
   }
+
 }
 
 @media (max-width: 820px) {
@@ -375,16 +339,27 @@
   }
 
   .scheduling-workspace,
-  .scheduling-full-editor,
-  .scheduling-editor-layout,
+  .scheduling-workspace-layout,
+  .scheduling-main-panel,
+  .scheduling-editor-surface,
   .scheduling-detail,
   .scheduling-editor-scroll {
     height: auto;
     overflow: visible;
   }
 
-  .scheduling-columns,
-  .scheduling-form-grid {
+  .scheduling-workspace-layout {
+    display: grid;
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .scheduling-request-sidebar {
+    max-height: 48vh;
+    border-right: 0;
+    border-bottom: var(--border-line);
+  }
+
+  .scheduling-columns {
     grid-template-columns: minmax(0, 1fr);
   }
 
diff --git a/webui/tests/scheduling-view-model.test.ts b/webui/tests/scheduling-view-model.test.ts
index 236e2ce..f1be5fe 100644
--- a/webui/tests/scheduling-view-model.test.ts
+++ b/webui/tests/scheduling-view-model.test.ts
@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import type { SchedulingRequest } from "../src/api/scheduling.ts";
 import {
+  applySchedulingAvailabilityChoice,
   groupSchedulingRequests,
   schedulingSortPhase,
   type SchedulingActor
@@ -47,6 +48,15 @@ function request(
       source_path: [],
       details: {}
     },
+    notify_on_answers: true,
+    single_choice: false,
+    max_participants_per_option: null,
+    allow_maybe: true,
+    allow_comments: false,
+    participant_email_required: false,
+    anonymous_password_protection_enabled: false,
+    public_participation_policy_enforcement_available: false,
+    public_participation_policy_enforcement_reason: "Public participation gateway not installed",
     calendar_integration_enabled: false,
     calendar_freebusy_enabled: false,
     calendar_hold_enabled: false,
@@ -61,11 +71,13 @@ function request(
       end_at: options.end ?? "2026-07-21T10:00:00Z",
       timezone: "UTC",
       position: 0,
+      revision: "0".repeat(64),
       freebusy_conflicts: [],
       metadata: {}
     }],
     participants: options.participantStatus ? [{
       id: `participant-${id}`,
+      is_current_participant: true,
       respondent_id: "membership-1",
       email: "person@example.test",
       participant_type: "internal",
@@ -88,6 +100,29 @@ test("groups owned, invited, and administrator-only requests without hiding any"
   assert.deepEqual(groups.other.map((item) => item.id), ["managed"]);
 });
 
+test("matches email-only invitations without case sensitivity", () => {
+  const invited = request("email-case", { participantStatus: "invited" });
+  invited.participants[0].is_current_participant = false;
+  invited.participants[0].respondent_id = null;
+  invited.participants[0].email = "Person@Example.Test";
+
+  const groups = groupSchedulingRequests([invited], actor, now);
+
+  assert.deepEqual(groups.invited.map((item) => item.id), ["email-case"]);
+  assert.deepEqual(groups.other, []);
+});
+
+test("recognizes the current participant after identity bindings are redacted", () => {
+  const invited = request("safe-projection", { participantStatus: "invited" });
+  invited.participants[0].respondent_id = null;
+  invited.participants[0].email = null;
+
+  const groups = groupSchedulingRequests([invited], actor, now);
+
+  assert.deepEqual(groups.invited.map((item) => item.id), ["safe-projection"]);
+  assert.deepEqual(groups.other, []);
+});
+
 test("keeps an organizer's active request in the open phase even if they also responded", () => {
   const owned = request("mine-and-invited", {
     organizer: "account-1",
@@ -122,3 +157,31 @@ test("orders unanswered by nearest slot before answered, closed, determined, and
   assert.equal(schedulingSortPhase(groups.invited[0], actor, now), "unanswered");
   assert.equal(schedulingSortPhase(groups.invited.at(-1)!, actor, now), "past");
 });
+
+test("single-choice availability keeps one positive choice while preserving explicit no answers", () => {
+  const next = applySchedulingAvailabilityChoice(
+    ["slot-a", "slot-b", "slot-c"],
+    { "slot-a": "available", "slot-b": "maybe", "slot-c": "unavailable" },
+    "slot-b",
+    "available",
+    true
+  );
+
+  assert.deepEqual(next, {
+    "slot-a": "unavailable",
+    "slot-b": "available",
+    "slot-c": "unavailable"
+  });
+});
+
+test("multi-choice availability changes only the selected slot", () => {
+  const next = applySchedulingAvailabilityChoice(
+    ["slot-a", "slot-b"],
+    { "slot-a": "available" },
+    "slot-b",
+    "maybe",
+    false
+  );
+
+  assert.deepEqual(next, { "slot-a": "available", "slot-b": "maybe" });
+});