feat(files): orchestrate connector folder sync

src/govoplan_files/backend/manifest.py

@@ -452,7 +452,7 @@ def _dsar_provider(context: ModuleContext) -> object:
 manifest = ModuleManifest(
     id="files",
     name="Files",
-    version="0.1.19",
+    version="0.1.20",
     required_capabilities=(
         CAPABILITY_AUTH_PRINCIPAL_RESOLVER,
         CAPABILITY_AUTH_PERMISSION_EVALUATOR,
@@ -1299,12 +1299,14 @@ manifest = ModuleManifest(
         ),
         DocumentationTopic(
             id="files.governed-connectors-and-provenance",
-            title="Govern file connections and credential deletion",
-            summary="Keep endpoint profiles, reusable credentials, and inherited connector policy separate, and understand what DELETE removes immediately.",
+            title="Govern file connections, folder sync, and credential deletion",
+            summary="Keep endpoints, credentials, inherited policy, and bounded manual synchronization separate, with reviewable outcomes and provenance.",
             body=(
                 "System, tenant, and one user/group/campaign leaf form the effective policy chain: deny rules win and every configured allow rule must match. "
                 "Responses redact secret values and deployment references. Deleting a database-managed credential or profile immediately scrubs Files-owned encrypted material and private metadata in the same transaction as a non-secret audit event; dependent profiles are disabled, while legacy non-owned references are only detached and audited. "
-                "Removing a connector space is a separate owner-authorized operation: it retires only the local virtual-space link and leaves provider content, imported managed files and shares, profiles, credentials, and remote references untouched. Intrinsic user and group managed spaces cannot be removed. Connector spaces remain read-only by default. An administrator may explicitly enable two-way mode only for an S3 profile carrying the write capability; each write requires separate authority, inherited path policy, a conditional create or expected revision, and durable recovery evidence. Automatic remote deletion, rename, and move propagation remain disabled."
+                "Removing a connector space is a separate owner-authorized operation: it retires only the local virtual-space link and leaves provider content, imported managed files and shares, profiles, credentials, and remote references untouched. Intrinsic user and group managed spaces cannot be removed. "
+                "A manual connector-folder sync traverses provider pagination with explicit file-count and depth bounds, preserves remote relative paths in the linked owner's managed space, and evaluates policy for the root and every downloaded item. Matching source identities produce unchanged or version-appending updates; new identities create managed assets. Unrelated target collisions default to skip, while rename, reject, and overwrite are explicit choices. Per-file savepoints keep successful siblings while conflicts, skips, policy denials, and transport failures remain visible in the response. The files.connector.folder_synced audit event records provenance, typed counts, truncation, and bounded result references without content or credentials. Scheduling remains separate. "
+                "Connector spaces remain read-only by default. An administrator may explicitly enable two-way mode only for an S3 profile carrying the write capability; each write requires separate authority, inherited path policy, a conditional create or expected revision, and durable recovery evidence. Automatic remote deletion, rename, and move propagation remain disabled."
             ),
             layer="configured",
             documentation_types=("admin",),
@@ -1343,12 +1345,30 @@ manifest = ModuleManifest(
                     href="/api/v1/files/connectors/credentials",
                     kind="api",
                 ),
+                DocumentationLink(
+                    label="Manual connector-folder sync API",
+                    href="/api/v1/files/connector-spaces/{space_id}/sync",
+                    kind="api",
+                ),
                 DocumentationLink(
                     label="Files handbook",
                     href="govoplan-files/docs/FILES_HANDBOOK.md",
                     kind="repository",
                 ),
             ),
+            translations={
+                "de": {
+                    "title": "Dateiverbindungen, Ordnersynchronisierung und das Löschen von Zugangsdaten steuern",
+                    "summary": "Endpunkte, Zugangsdaten, vererbte Richtlinien und begrenzte manuelle Synchronisierung getrennt und mit prüfbaren Ergebnissen sowie Herkunftsnachweisen verwalten.",
+                    "body": (
+                        "System, Mandant und genau eine Benutzer-, Gruppen- oder Kampagnenebene bilden die wirksame Richtlinienkette: Ablehnungsregeln haben Vorrang und jede konfigurierte Erlaubnisregel muss zutreffen. "
+                        "Antworten blenden Geheimwerte und Bereitstellungsverweise aus. Beim Löschen datenbankverwalteter Zugangsdaten oder Profile entfernt Files eigenes verschlüsseltes Material und private Metadaten in derselben Transaktion wie das nicht geheime Audit-Ereignis. Abhängige Profile werden deaktiviert; ältere, nicht Files gehörende Verweise werden nur getrennt und auditiert. "
+                        "Das Entfernen eines Connector-Bereichs ist ein eigener, eigentümerberechtigter Vorgang: Nur die lokale Verknüpfung des virtuellen Bereichs wird außer Kraft gesetzt. Inhalte beim Anbieter, importierte verwaltete Dateien und Freigaben, Profile, Zugangsdaten und Remote-Verweise bleiben erhalten. Intrinsische Benutzer- und Gruppenbereiche können nicht entfernt werden. "
+                        "Eine manuelle Connector-Ordnersynchronisierung durchläuft die Anbieter-Paginierung innerhalb ausdrücklicher Grenzen für Dateizahl und Tiefe, erhält relative Remote-Pfade im verwalteten Bereich des verknüpften Eigentümers und prüft die Richtlinie für die Wurzel sowie jede heruntergeladene Datei. Übereinstimmende Quellidentitäten bleiben unverändert oder erhalten eine neue Version; neue Identitäten erzeugen verwaltete Dateien. Nicht zugehörige Zielkonflikte werden standardmäßig übersprungen; Umbenennen, Ablehnen und Ersetzen sind ausdrückliche Entscheidungen. Savepoints je Datei bewahren erfolgreiche Geschwister, während Konflikte, Überspringungen, Richtlinienablehnungen und Transportfehler in der Antwort prüfbar bleiben. Das Audit-Ereignis files.connector.folder_synced hält Herkunft, typisierte Zähler, Abbruch am Grenzwert und begrenzte Ergebnisverweise ohne Inhalte oder Zugangsdaten fest. Zeitplanung bleibt getrennt. "
+                        "Connector-Bereiche bleiben standardmäßig schreibgeschützt. Eine Administration kann den Zweiwege-Modus nur für ein S3-Profil mit Schreib-Capability ausdrücklich aktivieren. Jeder Schreibvorgang benötigt eigene Berechtigung, die vererbte Pfadrichtlinie, eine bedingte Neuanlage oder erwartete Revision sowie dauerhafte Wiederherstellungsnachweise. Automatisches Löschen, Umbenennen und Verschieben auf dem Remote-System bleibt deaktiviert."
+                    ),
+                }
+            },
             related_modules=("access", "audit", "mail"),
             unlocks=(
                 "Scoped, explainable external-file access without exposing credentials to consuming modules.",
@@ -1369,12 +1389,34 @@ manifest = ModuleManifest(
                     "files.connectors",
                     "files.connector.credentials",
                     "files.connector.policy",
+                    "files.connector-folder-sync.remote-path",
+                    "files.connector-folder-sync.target-folder",
+                    "files.connector-folder-sync.conflict-strategy",
+                    "files.connector-folder-sync.max-files",
+                    "files.connector-folder-sync.recursive",
                 ],
+                "prerequisites": [
+                    "A visible active connector space uses manual sync and links to an accessible managed user or group space.",
+                    "The operator has files:file:upload and the effective connector policy permits the requested root and source paths.",
+                ],
+                "steps": [
+                    "Open the linked connector folder, choose Sync folder, and review the managed destination.",
+                    "Keep the safe skip default or explicitly choose rename, reject, or overwrite for unrelated target collisions.",
+                    "Set the bounded file count and subfolder choice, run the sync, and review every typed item outcome and any truncation warning.",
+                    "Continue a truncated run from a narrower remote folder; configure scheduling separately if background operation is required.",
+                ],
+                "limitations": [
+                    "Manual folder sync does not schedule future runs or mutate, delete, rename, move, or change ACLs on remote content.",
+                    "A successful partial run is not complete coverage when the response is truncated or contains review outcomes.",
+                ],
+                "outcome": "Permitted connector files become governed managed assets or versions while every exception remains explicit and auditable.",
+                "verification": "Compare the response summary and per-item outcomes with the files.connector.folder_synced audit event, then inspect provenance on representative created, updated, and unchanged assets.",
                 "security_invariants": [
                     "New API-managed external secret references fail closed until Files can prove ownership and provider-side deletion.",
                     "Deletion and destructive retirement scrub Files-owned encrypted connector material before completion and emit non-secret audit evidence.",
                     "Legacy non-owned external references are detached and audited, never sent to an arbitrary provider delete operation.",
                     "Connector-space removal is local and soft; it never claims to delete remote or previously imported managed content.",
+                    "Folder sync is bounded, path-contained, policy-checked per item, and never includes remote bytes or credentials in audit details.",
                     "Two-way connector mode is explicit and S3-only; it never enables automatic remote delete, rename, move, or ACL propagation.",
                 ],
                 "related_topic_ids": [

src/govoplan_files/backend/routes/connector_io.py

@@ -9,6 +9,10 @@ from govoplan_core.audit.logging import audit_from_principal
 from govoplan_files.backend.schemas import (
     FileConnectorBrowseItem,
     FileConnectorBrowseResponse,
+    FileConnectorFolderSyncItemResponse,
+    FileConnectorFolderSyncRequest,
+    FileConnectorFolderSyncResponse,
+    FileConnectorFolderSyncSummary,
     FileConnectorImportRequest,
     FileConnectorSyncResponse,
     FileConnectorWriteRequest,
@@ -28,6 +32,11 @@ from govoplan_files.backend.storage.connector_imports import (
     ConnectorImportError,
     ConnectorImportUnsupported,
 )
+from govoplan_files.backend.storage.connector_folder_sync import (
+    connector_relative_path,
+    discover_connector_folder,
+    join_connector_path,
+)
 from govoplan_files.backend.storage.connector_deployment import (
     connector_effective_endpoint_url,
 )
@@ -43,6 +52,7 @@ from govoplan_files.backend.storage.files import (
     sync_file_asset_from_source,
 )
 from govoplan_files.backend.storage.connector_spaces import (
+    connector_space_owner_id,
     get_connector_space_for_user,
 )
 from govoplan_files.backend.storage.connector_writes import write_connector_file
@@ -54,6 +64,7 @@ from govoplan_files.backend.route_support import (
     _audit_connector_sync,
     _connector_browse_next_token,
     _connector_policy_error,
+    _connector_space_policy_decision,
     _download_connector_payload,
     _ensure_campaign_file_access,
     _http_error,
@@ -64,6 +75,259 @@ from govoplan_files.backend.route_support import (
 router = APIRouter(prefix="/files", tags=["files"])
 
 
+@router.post(
+    "/connector-spaces/{space_id}/sync",
+    response_model=FileConnectorFolderSyncResponse,
+)
+def sync_connector_space_folder(
+    space_id: str,
+    payload: FileConnectorFolderSyncRequest,
+    session: Session = Depends(get_session),
+    principal: ApiPrincipal = Depends(require_scope("files:file:upload")),
+):
+    try:
+        space = get_connector_space_for_user(
+            session,
+            tenant_id=principal.tenant_id,
+            user_id=principal.user.id,
+            space_id=space_id,
+            is_admin=_is_admin(principal),
+        )
+    except FileStorageError as exc:
+        session.rollback()
+        raise _http_error(exc, not_found=True) from exc
+
+    try:
+        if space.sync_mode != "manual":
+            raise FileStorageError("This connector space is not configured for manual sync")
+        profile = _visible_connector_profile(
+            session, principal, space.connector_profile_id
+        )
+        remote_path = join_connector_path(space.remote_path, payload.path)
+        target_folder = join_connector_path(payload.target_folder)
+        decision = _connector_space_policy_decision(
+            profile,
+            library_id=space.library_id,
+            remote_path=remote_path,
+            operation="sync",
+        )
+        if not decision.allowed:
+            raise ConnectorPolicyDenied(decision)
+        discovery = discover_connector_folder(
+            profile,
+            path=remote_path,
+            library_id=space.library_id,
+            recursive=payload.recursive,
+            max_files=payload.max_files,
+            max_depth=payload.max_depth,
+        )
+    except ConnectorPolicyDenied as exc:
+        session.rollback()
+        raise _connector_policy_error(exc) from exc
+    except ConnectorBrowseUnsupported as exc:
+        session.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_501_NOT_IMPLEMENTED, detail=str(exc)
+        ) from exc
+    except (ConnectorBrowseError, FileStorageError, ValueError) as exc:
+        session.rollback()
+        raise _http_error(exc) from exc
+
+    owner_id = connector_space_owner_id(space)
+    items: list[FileConnectorFolderSyncItemResponse] = [
+        FileConnectorFolderSyncItemResponse(
+            source_path=skipped.path,
+            action="skipped",
+            detail=skipped.reason,
+        )
+        for skipped in discovery.skipped
+    ]
+    counts = {
+        "created": 0,
+        "updated": 0,
+        "unchanged": 0,
+        "skipped": len(discovery.skipped),
+        "conflicts": 0,
+        "policy_denied": 0,
+        "failed": 0,
+    }
+
+    for source in discovery.files:
+        source_path = normalize_connector_browse_path(source.path)
+        try:
+            relative_path = connector_relative_path(
+                space_root=space.remote_path,
+                item_path=source_path,
+            )
+            target_path = join_connector_path(target_folder, relative_path)
+        except (ConnectorBrowseError, ValueError) as exc:
+            counts["failed"] += 1
+            items.append(
+                FileConnectorFolderSyncItemResponse(
+                    source_path=source_path,
+                    action="failed",
+                    detail=str(exc),
+                )
+            )
+            continue
+
+        try:
+            with session.begin_nested():
+                file_payload = FileConnectorImportRequest(
+                    library_id=space.library_id or "",
+                    path=source_path,
+                    owner_type=space.owner_type,
+                    owner_id=owner_id,
+                    target_path=target_path,
+                    conflict_strategy=payload.conflict_strategy,
+                    source_revision=source.etag,
+                    metadata={
+                        **dict(source.metadata),
+                        **payload.metadata,
+                        "connector_space_id": space.id,
+                        "browse_name": source.name,
+                        "browse_path": source_path,
+                        "browse_modified_at": source.modified_at,
+                        "browse_etag": source.etag,
+                        "folder_sync": True,
+                    },
+                )
+                _source_path, downloaded, metadata = _download_connector_payload(
+                    profile, file_payload, operation="sync"
+                )
+                stored, sync_action, previous_version_id = (
+                    sync_file_asset_from_source(
+                        session,
+                        tenant_id=principal.tenant_id,
+                        owner_type=space.owner_type,
+                        owner_id=owner_id,
+                        user_id=principal.user.id,
+                        filename=downloaded.filename,
+                        data=downloaded.data,
+                        display_path=target_path,
+                        content_type=downloaded.content_type,
+                        metadata=metadata,
+                        conflict_strategy=payload.conflict_strategy,
+                        is_admin=_is_admin(principal),
+                    )
+                )
+                _audit_connector_sync(
+                    session,
+                    principal,
+                    stored.asset,
+                    sync_action=sync_action,
+                    previous_version_id=previous_version_id,
+                )
+                file_response = _asset_response(
+                    session, stored.asset, include_shares=True
+                )
+            counts[sync_action] += 1
+            items.append(
+                FileConnectorFolderSyncItemResponse(
+                    source_path=source_path,
+                    target_path=target_path,
+                    action=sync_action,
+                    file=file_response,
+                    previous_version_id=previous_version_id,
+                    current_version_id=stored.version.id,
+                    source_revision=file_response.source_revision,
+                )
+            )
+        except ConnectorPolicyDenied as exc:
+            counts["policy_denied"] += 1
+            items.append(
+                FileConnectorFolderSyncItemResponse(
+                    source_path=source_path,
+                    target_path=target_path,
+                    action="policy_denied",
+                    source_revision=source.etag,
+                    detail=str(exc),
+                    policy_decision=exc.decision.to_dict(),
+                )
+            )
+        except FileStorageError as exc:
+            detail = str(exc)
+            if detail.startswith("Skipped upload target:"):
+                action = "skipped"
+                counts["skipped"] += 1
+            elif detail.startswith("Target file already exists:"):
+                action = "conflict"
+                counts["conflicts"] += 1
+            else:
+                action = "failed"
+                counts["failed"] += 1
+            items.append(
+                FileConnectorFolderSyncItemResponse(
+                    source_path=source_path,
+                    target_path=target_path,
+                    action=action,
+                    source_revision=source.etag,
+                    detail=detail,
+                )
+            )
+        except (
+            ConnectorImportError,
+            UnsafeFilePathError,
+            OSError,
+            ValueError,
+            json.JSONDecodeError,
+        ) as exc:
+            counts["failed"] += 1
+            items.append(
+                FileConnectorFolderSyncItemResponse(
+                    source_path=source_path,
+                    target_path=target_path,
+                    action="failed",
+                    source_revision=source.etag,
+                    detail=str(exc),
+                )
+            )
+
+    summary = FileConnectorFolderSyncSummary(
+        discovered=len(discovery.files),
+        **counts,
+    )
+    audit_from_principal(
+        session,
+        principal,
+        action="files.connector.folder_synced",
+        object_type="file_connector_space",
+        object_id=space.id,
+        details={
+            "connector_profile_id": profile.id,
+            "provider": profile.provider,
+            "library_id": space.library_id,
+            "remote_path": remote_path,
+            "target_folder": target_folder,
+            "recursive": payload.recursive,
+            "truncated": discovery.truncated,
+            "summary": summary.model_dump(),
+            "results": [
+                {
+                    "source_path": item.source_path,
+                    "target_path": item.target_path,
+                    "action": item.action,
+                    "file_id": item.file.id if item.file else None,
+                    "current_version_id": item.current_version_id,
+                }
+                for item in items
+            ],
+        },
+    )
+    session.commit()
+    return FileConnectorFolderSyncResponse(
+        connector_space_id=space.id,
+        connector_profile_id=profile.id,
+        provider=profile.provider,
+        remote_path=remote_path,
+        target_folder=target_folder,
+        recursive=payload.recursive,
+        truncated=discovery.truncated,
+        summary=summary,
+        items=items,
+    )
+
+
 @router.post(
     "/connector-spaces/{space_id}/write-back",
     response_model=FileConnectorWriteResponse,

src/govoplan_files/backend/schemas.py

@@ -530,7 +530,7 @@ class FileConnectorImportRequest(BaseModel):
     target_folder: str | None = None
     target_path: str | None = None
     campaign_id: str | None = None
-    conflict_strategy: Literal["reject", "overwrite", "rename"] = "reject"
+    conflict_strategy: Literal["reject", "overwrite", "rename", "skip"] = "reject"
     source_revision: str | None = None
     metadata: dict[str, Any] = Field(default_factory=dict)
 
@@ -542,6 +542,59 @@ class FileConnectorSyncResponse(BaseModel):
     current_version_id: str
 
 
+class FileConnectorFolderSyncRequest(BaseModel):
+    path: str = ""
+    target_folder: str | None = None
+    recursive: bool = True
+    conflict_strategy: Literal["reject", "overwrite", "rename", "skip"] = "skip"
+    max_files: int = Field(default=100, ge=1, le=500)
+    max_depth: int = Field(default=12, ge=0, le=50)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class FileConnectorFolderSyncItemResponse(BaseModel):
+    source_path: str
+    target_path: str | None = None
+    action: Literal[
+        "created",
+        "updated",
+        "unchanged",
+        "skipped",
+        "conflict",
+        "policy_denied",
+        "failed",
+    ]
+    file: FileAssetResponse | None = None
+    previous_version_id: str | None = None
+    current_version_id: str | None = None
+    source_revision: str | None = None
+    detail: str | None = None
+    policy_decision: dict[str, Any] | None = None
+
+
+class FileConnectorFolderSyncSummary(BaseModel):
+    discovered: int = 0
+    created: int = 0
+    updated: int = 0
+    unchanged: int = 0
+    skipped: int = 0
+    conflicts: int = 0
+    policy_denied: int = 0
+    failed: int = 0
+
+
+class FileConnectorFolderSyncResponse(BaseModel):
+    connector_space_id: str
+    connector_profile_id: str
+    provider: str
+    remote_path: str
+    target_folder: str
+    recursive: bool
+    truncated: bool = False
+    summary: FileConnectorFolderSyncSummary
+    items: list[FileConnectorFolderSyncItemResponse] = Field(default_factory=list)
+
+
 class FileConnectorWriteRequest(BaseModel):
     file_id: str
     remote_path: str

src/govoplan_files/backend/storage/connector_folder_sync.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass, field
+
+from govoplan_files.backend.storage.connector_browse import (
+    ConnectorBrowseItem,
+    browse_connector_profile,
+    normalize_connector_browse_path,
+)
+from govoplan_files.backend.storage.connector_profiles import ConnectorProfile
+
+
+@dataclass(frozen=True, slots=True)
+class ConnectorFolderSkip:
+    path: str
+    reason: str
+
+
+@dataclass(slots=True)
+class ConnectorFolderDiscovery:
+    files: list[ConnectorBrowseItem] = field(default_factory=list)
+    skipped: list[ConnectorFolderSkip] = field(default_factory=list)
+    truncated: bool = False
+
+
+def discover_connector_folder(
+    profile: ConnectorProfile,
+    *,
+    path: str,
+    library_id: str | None,
+    recursive: bool,
+    max_files: int,
+    max_depth: int,
+) -> ConnectorFolderDiscovery:
+    """Discover a bounded, deterministic set of files below one connector folder."""
+
+    root_path = normalize_connector_browse_path(path)
+    queue: deque[tuple[str, int]] = deque([(root_path, 0)])
+    visited_folders: set[str] = set()
+    seen_files: set[tuple[str, str]] = set()
+    result = ConnectorFolderDiscovery()
+
+    while queue:
+        folder_path, depth = queue.popleft()
+        if folder_path in visited_folders:
+            continue
+        visited_folders.add(folder_path)
+
+        continuation_token: str | None = None
+        seen_tokens: set[str] = set()
+        while True:
+            items = browse_connector_profile(
+                profile,
+                path=folder_path,
+                library_id=library_id,
+                continuation_token=continuation_token,
+            )
+            for item in items:
+                item_path = normalize_connector_browse_path(item.path)
+                if item.kind == "file":
+                    identity = (str(item.external_id or ""), item_path)
+                    if identity in seen_files:
+                        continue
+                    if len(result.files) >= max_files:
+                        result.truncated = True
+                        result.skipped.append(
+                            ConnectorFolderSkip(
+                                path=item_path or folder_path,
+                                reason=f"The manual sync limit of {max_files} files was reached.",
+                            )
+                        )
+                        return result
+                    seen_files.add(identity)
+                    result.files.append(item)
+                    continue
+
+                if item.kind == "folder":
+                    if not recursive:
+                        result.skipped.append(
+                            ConnectorFolderSkip(
+                                path=item_path,
+                                reason="Subfolder skipped because recursive sync is disabled.",
+                            )
+                        )
+                    elif depth >= max_depth:
+                        result.skipped.append(
+                            ConnectorFolderSkip(
+                                path=item_path,
+                                reason=f"Subfolder skipped at the configured depth limit of {max_depth}.",
+                            )
+                        )
+                    else:
+                        queue.append((item_path, depth + 1))
+                    continue
+
+                result.skipped.append(
+                    ConnectorFolderSkip(
+                        path=item_path,
+                        reason=f"Connector item kind {item.kind!r} cannot be synchronized as a file.",
+                    )
+                )
+
+            next_token = _next_continuation_token(items)
+            if not next_token or next_token in seen_tokens:
+                break
+            seen_tokens.add(next_token)
+            continuation_token = next_token
+
+    result.files.sort(key=lambda item: normalize_connector_browse_path(item.path).casefold())
+    result.skipped.sort(key=lambda item: (item.path.casefold(), item.reason))
+    return result
+
+
+def connector_relative_path(*, space_root: str, item_path: str) -> str:
+    root = normalize_connector_browse_path(space_root)
+    item = normalize_connector_browse_path(item_path)
+    if not root:
+        return item
+    if item == root:
+        return item.rsplit("/", 1)[-1]
+    prefix = f"{root}/"
+    if not item.startswith(prefix):
+        raise ValueError("Connector returned a file outside the linked connector-space root")
+    return item[len(prefix) :]
+
+
+def join_connector_path(*parts: str | None) -> str:
+    return normalize_connector_browse_path(
+        "/".join(str(part or "").strip("/\\") for part in parts if str(part or "").strip("/\\"))
+    )
+
+
+def _next_continuation_token(items: list[ConnectorBrowseItem]) -> str | None:
+    for item in reversed(items):
+        value = item.metadata.get("next_continuation_token")
+        if value is not None and str(value).strip():
+            return str(value).strip()
+    return None

src/govoplan_files/backend/storage/files.py

@@ -1108,7 +1108,7 @@ def _resolution_by_path(conflict_resolutions: Iterable[FileConflictResolution] |
 
 def _normalize_conflict_strategy(strategy: str | None) -> str:
     normalized = (strategy or "reject").lower().strip()
-    if normalized not in {"reject", "overwrite", "rename"}:
+    if normalized not in {"reject", "overwrite", "rename", "skip"}:
         raise FileStorageError("Unsupported conflict strategy")
     return normalized