@@ -64,7 +64,8 @@ machine output. CLI synchronization requires POSIX process groups.
 resolve typed targets, honor drift and dirty policy, and retain native
 recovery results. Existing tag and commit checkouts move when their target
 changes. Parent Git options, selected remotes, and explicit detachment apply
-to worktree updates. Missing worktrees use native linked-worktree creation.
+to worktree updates. Missing worktrees fetch and create under the same native
+ownership lock; requested lock failures retain the completed creation result.
 
 Configured discard requires `--yes`; included worktree policies are checked
 before the main checkout changes. JSON and NDJSON retain exact recovery
 
@@ -36,6 +36,12 @@ accepts `--timeout`. A timed-out worktree prevents further worktrees for that
 repository from starting. Interrupted worktree metadata remains unknown when
 the worker did not return it.
 
+### Guarded worktree creation
+
+Worktree creation fetches configured remotes before selecting its initial
+target. A failed requested worktree lock returns an error with completed
+creation state; inspect that result before retrying an occupied destination.
+
 ### Explicit checkout policy and sync results
 
 The main checkout passes its selector kind, remote, and `sync` policy to
 
@@ -22,8 +22,9 @@ Sync all configured worktrees:
 $ vcspull worktree sync '*'
 ```
 
-Missing worktrees require locally available target metadata and use Git's
-linked-worktree operation. Existing
+Missing worktrees fetch configured remotes and establish their initial target
+with Git's linked-worktree operation. Creation holds the repository's ownership
+lock through fetch, target selection, worktree creation, and lock setup. Existing
 worktrees follow their configured `branch`, `tag`, `commit`, or native `rev`;
 changing a tag or commit target moves the checkout to that resolved commit.
 Branch updates are fast-forward only. A matching commit is not drift, even
@@ -56,6 +57,10 @@ does not automatically restore interrupted operations into their source.
 
 ## Timeouts and interruption
 
+A requested worktree lock that fails reports an error even when the checkout
+was created. Inspect `update_state` before retrying; failed creation can leave
+refs or a partial checkout.
+
 Each worktree has its own deadline, including native creation and update.
 Set it with `--timeout` or `VCSPULL_SYNC_TIMEOUT_SECONDS`; the default is
 10 seconds:
 
@@ -777,14 +777,6 @@ def plan_worktree_sync(
     return entries
 
 
-def _prepare_worktree(project: GitSync) -> SyncResult:
-    """Check existing native ownership before the separate worktree-add command."""
-    return project.update_repo(
-        target=SyncTarget(commit=project.get_position().revision),
-        policy=SyncPolicy(drift="keep"),
-    )
-
-
 def sync_worktree(
     repo_path: pathlib.Path,
     wt_config: WorktreeConfigDict,
@@ -826,6 +818,7 @@ def sync_worktree(
     try:
         validate_worktree_config(wt_config)
         target, policy = checkout_settings(wt_config, worktree=True)
+        assert target is not None
         path = _resolve_worktree_path(wt_config, workspace_root)
         exists = _worktree_exists(repo_path, path)
         if path.exists() and not exists:
@@ -835,28 +828,19 @@ def sync_worktree(
             repo_path, path if exists else repo_path, repo_config
         )
         if not exists:
-            guard = _prepare_worktree(project)
-            if not guard.ok:
-                entry.result = guard
-            else:
-                resolved = project.resolve_target(target)
-                entry.target_position = resolved
-                attach = resolved.follows and not wt_config.get("detach", False)
-                _create_worktree(
-                    repo_path,
-                    path,
-                    "branch" if attach else "commit",
-                    resolved.ref_name if attach else resolved.revision,
-                    {**wt_config, "detach": not attach},
-                    start_point=resolved.revision,
-                )
-                project = _worktree_project(repo_path, path, repo_config)
-        if entry.result is None:
-            execution_policy = policy if exists else SyncPolicy(dirty=policy.dirty)
+            entry.result = project.create_worktree(
+                path,
+                target=target,
+                detach=wt_config.get("detach", False),
+                lock=wt_config.get("lock", False),
+                lock_reason=wt_config.get("lock_reason"),
+                set_remotes=repo_config is not None,
+            )
+        else:
             entry.result = project.update_repo(
                 set_remotes=repo_config is not None,
                 target=target,
-                policy=execution_policy,
+                policy=policy,
                 detach=wt_config.get("detach", False),
             )
         result = entry.result
@@ -871,7 +855,11 @@ def sync_worktree(
             )
             entry.detail = entry.error
         else:
-            entry.target_position = project.resolve_target(target)
+            entry.target_position = (
+                project.resolve_target(target)
+                if exists
+                else _worktree_project(repo_path, path, repo_config).get_position()
+            )
             if entry.position is not None:
                 entry.drifted = (
                     entry.position.revision != entry.target_position.revision
@@ -904,127 +892,6 @@ def sync_worktree(
     return entry
 
 
-def _create_worktree(
-    repo_path: pathlib.Path,
-    worktree_path: pathlib.Path,
-    ref_type: str,
-    ref_value: str,
-    wt_config: WorktreeConfigDict,
-    *,
-    start_point: str | None = None,
-) -> None:
-    """Create a new worktree.
-
-    Parameters
-    ----------
-    repo_path : pathlib.Path
-        Path to the main repository.
-    worktree_path : pathlib.Path
-        Path for the new worktree.
-    ref_type : str
-        Type of reference: 'tag', 'branch', or 'commit'.
-    ref_value : str
-        The reference value.
-    wt_config : WorktreeConfigDict
-        Full worktree configuration.
-
-    Raises
-    ------
-    subprocess.CalledProcessError
-        If the git command fails (e.g., ref not found).
-    FileNotFoundError
-        If the repository path does not exist.
-
-    Examples
-    --------
-    This function requires a valid git repository. When called with an invalid
-    path, it raises FileNotFoundError:
-
-    >>> import pathlib
-    >>> _create_worktree(
-    ...     pathlib.Path("/nonexistent"),
-    ...     pathlib.Path("/tmp/wt"),
-    ...     "tag",
-    ...     "v1.0.0",
-    ...     {"dir": "../wt", "tag": "v1.0.0"},
-    ... )  # doctest: +ELLIPSIS
-    Traceback (most recent call last):
-        ...
-    FileNotFoundError: ...
-    """
-    cmd = ["git", "worktree", "add"]
-
-    # Determine if we should detach
-    detach = wt_config.get("detach")
-    if detach is None:
-        # Default: detach for tags and commits, not for branches
-        detach = ref_type in ("tag", "commit", "rev")
-
-    if detach:
-        cmd.append("--detach")
-
-    # Handle locking
-    # git worktree add --lock does NOT support --reason, so when lock_reason
-    # is specified, we skip --lock here and use "git worktree lock --reason" after
-    lock_reason = wt_config.get("lock_reason")
-    should_lock = wt_config.get("lock")
-    if should_lock and not lock_reason:
-        # Lock without reason - can use --lock flag directly
-        cmd.append("--lock")
-
-    if ref_type == "branch" and not detach and start_point is not None:
-        branch_exists = (
-            subprocess.run(
-                ["git", "show-ref", "--verify", "--quiet", f"refs/heads/{ref_value}"],
-                cwd=repo_path,
-                capture_output=True,
-                check=False,
-            ).returncode
-            == 0
-        )
-        if not branch_exists:
-            cmd.extend(["-b", ref_value])
-            ref_value = start_point
-    cmd.append(str(worktree_path))
-    cmd.append(ref_value)
-
-    subprocess.run(
-        cmd,
-        cwd=repo_path,
-        check=True,
-        capture_output=True,
-        text=True,
-    )
-
-    # Apply lock with reason via separate command
-    # This handles both cases:
-    # 1. lock=True with lock_reason - lock with reason
-    # 2. lock_reason without explicit lock=True - also locks with reason
-    if lock_reason:
-        lock_cmd = [
-            "git",
-            "worktree",
-            "lock",
-            "--reason",
-            lock_reason,
-            str(worktree_path),
-        ]
-        try:
-            subprocess.run(
-                lock_cmd,
-                cwd=repo_path,
-                check=True,
-                capture_output=True,
-                text=True,
-            )
-        except subprocess.CalledProcessError as e:
-            log.warning(
-                "Worktree created at %s but lock failed: %s",
-                worktree_path,
-                e.stderr.strip() if e.stderr else str(e),
-            )
-
-
 def _update_worktree(worktree_path: pathlib.Path, branch: str) -> None:
     """Follow a branch with native fast-forward and dirty-abort safeguards.
 
 
@@ -2917,9 +2917,9 @@ def test_sync_worktree_oserror_exception(
 
     wt_config: WorktreeConfigDict = {"dir": str(worktree_path), "tag": "v-oserror-test"}
 
-    # Mock _create_worktree to raise OSError
+    # Fail the native creation boundary to verify CLI error conversion.
     mocker.patch(
-        "vcspull._internal.worktree_sync._create_worktree",
+        "libvcs.sync.git.GitSync.create_worktree",
         side_effect=OSError("Mocked OSError: permission denied"),
     )
 
@@ -3359,50 +3359,76 @@ def test_sync_exit_on_error_worktree_failures(
         )
 
 
-def test_sync_worktree_lock_failure_still_creates(
+def test_sync_worktree_lock_failure_reports_partial_creation(
     git_repo: GitSync,
     tmp_path: pathlib.Path,
-    mocker: MockerFixture,
+    monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    """Test worktree creation succeeds even if lock fails.
+    """A failed requested lock retains the completed creation and reports failure."""
+    from libvcs.cmd.git import Git
 
-    Regression test: lock failure after successful creation marked the entire
-    operation as ERROR. Lock is non-critical — the worktree is still usable.
-    """
-    workspace_root = git_repo.path.parent
-    worktree_path = workspace_root / "lock-fail-test-wt"
+    path = tmp_path / "lock-failed"
+    original_run = Git.run
 
-    # Create a tag
-    subprocess.run(
-        ["git", "tag", "v-lock-fail-test"],
-        cwd=git_repo.path,
-        check=True,
-        capture_output=True,
-    )
+    def fail_lock(command: Git, args: list[str], **kwargs: t.Any) -> str:
+        if args[:2] == ["worktree", "lock"]:
+            message = "worktree lock failed"
+            raise OSError(message)
+        return original_run(command, args, **kwargs)
 
-    wt_config: WorktreeConfigDict = {
-        "dir": str(worktree_path),
-        "tag": "v-lock-fail-test",
-        "lock": True,
-        "lock_reason": "This lock will fail",
-    }
+    # Fail only lock metadata after native worktree creation has completed.
+    monkeypatch.setattr(Git, "run", fail_lock)
+    entry = sync_worktree(
+        git_repo.path,
+        {"dir": str(path), "commit": "HEAD", "lock": True},
+        tmp_path,
+    )
+    assert entry.action == WorktreeAction.ERROR
+    assert path.is_dir()
+    assert entry.result is not None and entry.result.update_state == "completed"
+    assert entry.result.errors[0].step == "worktree-lock"
 
-    # Mock only the lock command to fail (let creation succeed)
-    original_run = subprocess.run
 
-    def mock_run(*args: t.Any, **kwargs: t.Any) -> t.Any:
-        cmd = args[0] if args else kwargs.get("args", [])
-        if isinstance(cmd, list) and "lock" in cmd:
-            raise subprocess.CalledProcessError(1, cmd, stderr="lock failed")
-        return original_run(*args, **kwargs)
+def test_worktree_creation_fetches_configured_remote(
+    policy_worktree: tuple[GitSync, pathlib.Path, str, str],
+) -> None:
+    """Creation establishes a branch that exists only in a configured remote."""
+    from libvcs.sync.git import GitSync
 
-    mocker.patch("vcspull._internal.worktree_sync.subprocess.run", side_effect=mock_run)
+    repo, existing, _, target = policy_worktree
+    upstream = GitSync(url=str(repo.path), path=existing.parent / "new-upstream")
+    upstream.obtain()
+    upstream.cmd.run(["branch", "new-remote-branch", target], check_returncode=True)
+    path = existing.parent / "new-remote-worktree"
+    entry = sync_worktree(
+        repo.path,
+        {"dir": str(path), "branch": "new-remote-branch", "remote": "upstream"},
+        path.parent,
+        repo_config={"url": repo.url, "remotes": {"upstream": str(upstream.path)}},
+    )
+    assert entry.action == WorktreeAction.CREATE, entry.error
+    assert entry.result is not None and entry.result.ok
+    assert entry.target_position is not None
+    assert entry.target_position.revision == target
+    assert repo.cmd.run(["-C", str(path), "symbolic-ref", "HEAD"]).strip() == (
+        "refs/heads/new-remote-branch"
+    )
 
-    entry = sync_worktree(git_repo.path, wt_config, workspace_root)
 
-    # Creation should succeed despite lock failure
-    assert entry.action == WorktreeAction.CREATE
-    assert worktree_path.exists()
+def test_worktree_creation_reports_resolved_relative_revision(
+    policy_worktree: tuple[GitSync, pathlib.Path, str, str],
+) -> None:
+    """Reporting cannot resolve HEAD~1 again against the new detached checkout."""
+    repo, existing, base, _ = policy_worktree
+    path = existing.parent / "relative-worktree"
+    entry = sync_worktree(
+        repo.path, {"dir": str(path), "commit": "HEAD~1"}, path.parent
+    )
+    assert entry.action == WorktreeAction.CREATE, entry.error
+    assert entry.result is not None and entry.result.ok
+    assert entry.target_position is not None
+    assert entry.target_position.revision == base
+    assert repo.cmd.run(["-C", str(path), "rev-parse", "HEAD"]).strip() == base
 
 
 def test_sync_worktree_empty_plan_returns_error(