1 Introduction↩︎

Learning robot manipulation skills from human demonstrations is a promising paradigm that enables robots to operate in unstructured environments [1], [2]. However, many real-world tasks, such as insertion, fastening and unlocking, are inherently contact-rich and governed by geometric constraints. These tasks involve intermittent contact, changes in motion direction, and tight tolerances, which significantly challenge learning from demonstration methods.

Most existing LfD methods require multiple complete demonstrations to capture task variability. However, in contact-rich manipulation, such data can be expensive to collect, and demonstrations are frequently limited to single trial and may be unfinished due to safety constraints, physical limitation, or the repetitive sub-motions. Furthermore, skill learning is typically directional, preventing robots from learning reverse skills (e.g. learning locking from unlocking) without giving the additional demonstrations. These limitations motivate a one-shot framework that could learn from a potentially unfinished demonstration that supports both forward and reverse execution.

However, enabling such one-shot learning in contact-rich settings is challenging due to its strong geometric constraints. While free-space motion can usually be effectively encoded using a trajectory-based method such as Dynamic Movement Primitives (DMP) [3], [4], contact motion exhibits structured geometric behavior that is poorly captured alone by those methods. Classic control approaches address this through impedance or force-based control [5]–[7], but typically require task-specific modeling, limiting their learning efficiency and generalizability across diverse tasks.

We observe that many contact-rich manipulation tasks can be naturally decomposed into sequences of constrained motions exhibiting consistent screw-like motion behavior, such as insertion, rotation and coupled translation-rotation (see Fig. 1). These geometric structures are invariant to the execution length and provide a principled basis for generalization beyond the demonstrated trajectory.

Leveraging this insight, we propose a unified one-shot learning framework which decomposes the demonstration into non-contact and contact phases, with non-contact phase encoded with DMP; contact phase modeled as screw primitives [8]–[10] executed under wrench-aware control, enabling task completion learned from unfinished demonstration and supporting reverse execution without additional data. We validate the proposed framework on four representative contact-rich manipulation tasks: peg insertion, battery insertion, lock opening and screw driving as shown in Fig. 1. Across all tasks, our method achieves higher success rates compared to other one-shot trajectory-based baselines.

The contributions of this paper are:

• A unified one-shot learning framework for constrained contact-rich manipulation, enabling task completion and execution of both forward and reverse skills learned from a single demonstration.

• A geometry-driven twist-direction trajectory segmentation algorithm for contact phase decomposition.

• A screw-primitive representation with interaction-aware execution combining 6D admittance pose correction and 1D admittance progress control.

2 Related Works↩︎

2.1 Learning from Demonstration for Manipulation↩︎

Learning from demonstration has been widely studied for transferring manipulation skills from humans to robots [1], [2]. Recent vision-based and multimodal learning approaches  [11]–[13] have shown powerful performance, but typically rely on large-scale datasets or extensive pretraining. In contrast, kinesthetic representations such as Dynamic movement primitives (DMP) and Gaussian Mixture Models (GMM) [3], [4], [14]–[17] enable smooth trajectory reproduction and generalization in free-space manipulation tasks learning from a single demonstration. However, these methods usually struggle in contact-rich tasks, where motion is governed by geometric constraints, and generally assume complete demonstrations without supporting reverse execution. Reverse execution has been studied at higher levels of abstraction, including reversible robot programs for error recovery [18] and assembly-by-disassembly over part-level sequences [19], while reversibility of continuous skills learned from a single demonstration remains less explored.

2.2 Contact-Rich Manipulation and Force-Based Control↩︎

Classical force and impedance control methods [5]–[7] enable robust physical interaction in constrained tasks such as peg-in-hole and surface following [20]–[24]. However, these methods typically rely on task-specific constraint definitions or prior geometric knowledge [20], and do not directly infer the contact motion structure from demonstrations. As a result, they are not sufficient themselves alone for one-shot learning of general contact-rich skills.

2.3 Screw Motion Primitives and Geometric Representations↩︎

Screw theory [25], [26] provides compact representations of rigid-body motion suitable for most constrained tasks. However, existing screw-based approaches typically focus on free-space motion reproduction [10], [27], [28], or representing the entire motion as a single global screw motion [9], [29]. Such formulations do not fully capture multi-phase contact-rich manipulation involving sequential geometric constraints.

2.4 Trajectory Segmentation and Skill Decomposition↩︎

Trajectory-based segmentation decomposes demonstrations into reusable skills with kinematic heuristics or probabilistic models such as GMM [10], [30], [31]. Segmentation methods with other modalities have also been applied widely to infer skill boundaries [32]–[34]. However, these approaches are often sensitive to occlusions and discontinuous behaviors such as dwell, which do not mark true task transitions. In contact-rich manipulation, however, motion segments are often short, where kinematic noise can be amplified and speed changes are unreliable indicators of skill boundaries, such approaches are less reliable.

In summary, prior work reveals a gap in contact-rich manipulation learning. Trajectory-based LfD methods are data-efficient but lack explicit geometric constraints understanding; force controllers enable robust interaction but require task-specific knowledge; screw-based methods usually model free-space motion or single global primitives; and reversible-execution methods mainly operate at the robot-program or part-sequence level. Together with the difficulty of segmenting short constrained motions, these limitations motivate our geometry-driven, wrench-aware framework for one-shot contact-rich manipulation.

3 Preliminaries: Screw Theory↩︎

Screw theory provides a unified geometric framework for representing rigid-body motion in three-dimensional space. According to the Mozzi–Chasles theorem [35], any instantaneous rigid-body motion can be represented as a rotation about, and a translation along, a single spatial line known as a screw axis. Such an instantaneous motion is represented by a twist \(\boldsymbol{\xi}=(\boldsymbol{\omega}, \mathbf{v})\in \mathbb{R}^6\), where \(\boldsymbol{\omega} \in \mathbb{R}^3\) denotes the angular velocity and \(\mathbf{v} \in \mathbb{R}^3\) denotes the linear velocity.

The matrix representation of the twist in the Lie algebra \(\mathfrak{se}(3)\) is given by \[\hat{\boldsymbol{\xi}}=\begin{bmatrix}[\boldsymbol{\omega}]_\times & \mathbf{v}\\\mathbf{0}^\top & 0\end{bmatrix},\] where \([\boldsymbol{\omega}]_\times\) is the skew-symmetric matrix.

In the general case where \(\boldsymbol{\omega} \neq \mathbf{0}\), the motion corresponds to a screw motion defined by a unit axis direction \(\hat{\mathbf{s}}\), a point \(\mathbf{q}\) on the axis, and a pitch \(h \in \mathbb{R}\), which specifies the translation along the axis per unit rotation. Let \(\dot{\theta}\) denote the rotational speed, the twist can be then written as \[\label{twist95equation} \boldsymbol{\xi} =\begin{bmatrix}\boldsymbol{\omega} \\ \mathbf{v}\end{bmatrix} =\begin{bmatrix}\dot{\theta}\,\hat{\mathbf{s}} \\ -\,\dot{\theta}\,\hat{\mathbf{s}} \times \mathbf{q} + h\,\dot{\theta}\,\hat{\mathbf{s}}\end{bmatrix}.\tag{1}\]

Pure translation is a special case with \(\boldsymbol{\omega} = \mathbf{0}\), which can be interpreted as a screw motion with infinite pitch (\(h \to \infty\)) and no rotation. Then the twist reduces to \(\boldsymbol{\xi}=(\mathbf{0}, \mathbf{v})\), and motion is fully modeled by the translation direction and magnitude.

Given a constant twist \(\boldsymbol{\xi}\) and a scalar motion magnitude \(\theta\), the corresponding finite rigid-body displacement is obtained through the exponential map: \[\mathbf{T}(\theta) = \exp(\hat{\boldsymbol{\xi}}\,\theta) \in SE(3),\] which yields a rotation of angle \(\theta\) about the screw axis together with a translation of magnitude \(h\theta\) along the same axis. In the case of pure translation, the exponential map reduces to a translational displacement with no rotation.

4 Method↩︎

4.1 Overview of the Learning and Execution Pipeline↩︎

We consider a single human-guided demonstration consisting of an end-effector trajectory from the robot’s initial grasp of the object until its final release. The proposed framework decomposes the demonstrated trajectory into non-contact and contact phases, and applies different learning and execution strategies to each phase (see Fig. 2).

The full demonstration trajectory is first encoded using a DMP, but is then only executed until contact is detected via wrench feedback. Then the demonstrated trajectory after this contact point is segmented using the proposed twist-direction-based method, which partitions motion based on the directional consistency in the twist space. Each segment is subsequently fitted with a screw motion primitive, generating a geometric representation of the constrained behavior.

At contact onset, the system checks whether local alignment is required by comparing short-window motion directions before and after the detected contact point in demonstration trajectory. If the directions remain consistent (i.e., high cosine similarity) while significant contact force is measured, the intended motion is considered blocked by misalignment. A basic sampled spiral search is then triggered after re-aligning the end-effector approach axis with the insertion direction while preserving rotation about that axis. This search is a common strategy in constrained tasks [22] and the implement details are available in the website.

After that, the learned screw primitives are executed sequentially under wrench-aware admittance control, allowing contact-phase motion to extend beyond the demonstrated trajectory length when required. For an unfinished demonstration, each task-critical contact phase must be at least partially observed; the method extrapolates observed primitives but does not infer absent phases.

Our framework also supports reverse execution from the same demonstration. Learned screw primitives are reused, auto-edited, and executed in reverse order to follow the same geometric constraints in the opposite direction without relearning. After completing the reversed contact phases, the remaining free-space motion is executed with a DMP relearned from the time-reversed forward demonstration trajectory. Transitions from contact to free space are determined via wrench-based contact release detection.

4.2 Twist-direction-based Trajectory Segmentation↩︎

We segment the contact-phase trajectory into a sequence of motion segments with constant twist directions. Unlike many segmentation methods that rely on time, velocity or dwell behavior, our segmentation uses only geometric motion directions, which is robust to short, noisy contact motions.

Prior to segmentation, the demonstrated pose trajectory is smoothed in \(SE(3)\) by filtering incremental twists.

4.2.1 Direction-only twist features↩︎

Given the smoothed trajectory \(\{\mathbf{T}_i\}^{N-1}_{i=0} \in SE(3)\), we compute the per-step relative motion \(\Delta \mathbf{T}_i = \mathbf{T}_i^{-1}\mathbf{T}_{i+1}\). And the corresponding twist is obtained using the logarithmic map \(\hat{\boldsymbol{\xi}}_i \Delta \theta_i = \log(\Delta \mathbf{T}_i)\), from which we extract the rotation axis direction \(\mathbf{d}^\omega_i\) and translation direction \(\mathbf{d}^v_i\), expressed in local frame, forming a 6D direction feature, \(\mathbf{f}_i = ( \mathbf{d}_i^{\omega}, \mathbf{d}_i^{v} ) \in \mathbb{R}^6\). Negligible rotations and translations are treated as directionless and set to zero.

4.2.2 Block-wise dominant direction estimation↩︎

Given the per-step direction features \(\mathbf{f}_i\), we partition the sequence into fixed-length blocks with length \(B\). Within each block, we estimate the dominant rotation axis \(\boldsymbol{\mu}^\omega\) and translation direction \(\boldsymbol{\mu}^v\) separately by computing the principal direction of the unit direction samples with PCA. The sign ambiguity of PCA eigenvectors is resolved by aligning their direction with reference directions computed from the block endpoints.

4.2.3 Block scanning and boundary detection↩︎

Blocks are scanned sequentially to form segments. For the current segment, dominant rotation and translation directions \((\mathbf{g}^\omega,\mathbf{g}^v)\) are estimated using the same procedure as for individual blocks. In each block \(j\), the block-level directions \((\boldsymbol{\mu}^\omega_j,\boldsymbol{\mu}^v_j)\) are compared to the current segment directions using cosine similarity \(\langle\cdot\rangle\). A candidate boundary is detected if either the rotation direction or translation direction deviates beyond predefined thresholds \(\tau_\omega\) and \(\tau_v\): \(\langle \boldsymbol{\mu}^\omega_j,\mathbf{g}^\omega\rangle < \tau_\omega \lor \langle \boldsymbol{\mu}^v_j,\mathbf{g}^v\rangle < \tau_v\). To suppress false positives caused by short-term fluctuations, we additionally require that the subsequent block \(j+1\) should not remain consistent dominant rotational and translational direction with the current segment: \(\neg(\langle \boldsymbol{\mu}^\omega_{j+1},\mathbf{g}^\omega\rangle > \tau_\omega \land \langle \boldsymbol{\mu}^v_{j+1},\mathbf{g}^v\rangle > \tau_v)\). If both conditions hold, block \(j\) is treated as a transition region; otherwise, it is absorbed into the current segment.

4.2.4 In-block boundary refinement↩︎

When a transition is detected, we refine the changepoint within the transition block to obtain a sample-level boundary. Let \((\mathbf{g}^{\omega},\mathbf{g}^{v})\) denote the dominant directions of the current segment, and let \((\boldsymbol{\mu}^{\omega}_{j+1}, \boldsymbol{\mu}^{v}_{j+1})\) denote those of the subsequent block. For each candidate split index \(k\) within the transition block, we minimize a direction-consistency cost that measures how well samples before \(k\) align with the current segmentation direction, and how well samples after \(k\) align with the new direction. The optimal boundary index \(k^\star\) is obtained by: \[k^\star = \mathop{\mathrm{arg\,min}}_{k \in \{0,\ldots,B-1\}} \sum_{i<k} \ell(\mathbf{f}_i;\mathbf{g}^{\omega},\mathbf{g}^{v}) + \sum_{i\ge k} \ell(\mathbf{f}_i;\boldsymbol{\mu}^{\omega}_{j+1},\boldsymbol{\mu}^{v}_{j+1}),\] where the per-sample cost \(\ell(\cdot)\) is defined as \[\ell(\mathbf{f}_i;\mathbf{a}^{\omega},\mathbf{a}^{v}) = w_\omega \big(1 - \langle \mathbf{d}^\omega_i, \mathbf{a}^{\omega} \rangle \big) + w_v \big(1 - \langle \mathbf{d}^v_i, \mathbf{a}^{v} \rangle \big),\] with weights \(w_\omega\) and \(w_v\) balancing the contributions of rotation and translation and \(\langle\cdot\rangle\) representing cosine similarity.

4.2.5 Global geometric refinement↩︎

Although block-level boundary detection produces locally consistent segments, short-term fluctuations in human demonstrations may introduce spurious boundaries. To enforce global geometric consistency, we compare each pair of adjacent segments by recomputing their dominant rotation and translation directions. If the cosine similarity of both rotational and translational directions exceeds the predefined same thresholds \(\tau_\omega\) and \(\tau_v\), the segments are merged.

4.2.6 Short-motion (dwell) cleanup↩︎

Human demonstrations often contain brief pauses or micro-corrections that generate segments with negligible net motion. Such segments do not represent meaningful contact-mode transitions. We therefore identify segments whose accumulated translation and rotation fall below predefined magnitude thresholds and merge them into adjacent segments. After this cleanup step, the segmentation algorithm outputs a set of segment indices \(\{(s_n, e_n)\}_{n=1}^{N}\) that partition the trajectory and are subsequently used for screw fitting.

4.3 Screw Primitive Learning↩︎

4.3.1 Screw primitive parameterization↩︎

Given a contact-motion segment \(\{\mathbf{T}_i\}^{N-1}_{i=0} \in SE(3)\) obtained from segmentation, we model the segment as a constant screw motion primitive. Let \(\mathbf{T}_0\) denote the first pose of the segment and then the relative pose of each sample is \(\mathbf{T}_i^{rel}=\mathbf{T}_0^{-1}\mathbf{T}_i\). The objective is to estimate a consistent twist \(\boldsymbol{\xi}\) together with scalar progress variables \(\theta_i\), such that: \[\mathbf{T}_i^{rel} \approx \exp(\hat{\boldsymbol{\xi}}\,\theta_i).\]

For the general screw case, we parameterize twist \(\boldsymbol{\xi}\) using screw coordinates \((\hat{\mathbf{s}}, \mathbf{q}, h)\) as defined in (1 ). Pure translation is treated as a special case described in sec. 4.3.3.

4.3.2 Screw parameters optimization↩︎

We estimate a screw primitive by minimizing residuals in Lie algebra \(\mathfrak{se}(3)\). For each sample \(i\), the residual is defined as the logarithm of the pose discrepancy between the predicted screw transformation and the demonstrated relative pose, mapped to a 6D twist error in tangent space: \[\mathbf{r}_i = \log\!\left( \exp\!\left( \hat{\boldsymbol{\xi}}\theta_i \right)^{-1} \mathbf{T}_i^{rel} \right) \in \mathbb{R}^6.\]

Each residual is decomposed into rotational and translational components \(\mathbf{r}_i^{\omega}\), \(\mathbf{r}_i^{v}\), respectively. We solve the following weighted least-squares problem: \[\min_{\hat{\mathbf{s}},\, \mathbf{q},\, h,\, \{\theta_i\}} \sum_{i=0}^{N-1} \rho \! \left(\left\lVert \begin{bmatrix} w_R \, \mathbf{r}_i^{\omega} \\ w_T \, \mathbf{r}_i^{v} \end{bmatrix} \right\rVert_2\right),\] where \(w_R\) and \(w_T\) balance rotational and translational errors, and \(\rho(\cdot)\) denotes Huber loss. Before optimization, each segment is resampled to achieve approximately uniform progress in \(SE(3)\) space to reduce the sensitivity of the spatial imbalance in demonstration data. Compared with averaging per-step twists, this optimization enforces global \(SE(3)\) consistency over the entire segment and jointly estimates the screw axis, pitch, and progress scale.

To ensure robustness and computational efficiency in one-shot setting, we adopt a reduced-parameter optimizing strategy. Instead of optimizing an independent progress variable \(\theta_i\) for each sample, we initialize a monotone progress sequence \(\theta_i^{*}\) with a global scale \(s\) such that \(\theta_i=s\theta_i^{*}\). This yields a low-dimensional optimization over \((\hat{\mathbf{s}}, \mathbf{q}, h, s)\), substantially improving the computational efficiency.

4.3.3 Pure translation segments↩︎

If the accumulated rotation within a segment is negligible, a direction \(\hat{\mathbf{d}}\) is estimated with PCA and the twist is defined as \(\boldsymbol{\omega}=\mathbf{0}, \mathbf{v}=\hat{\mathbf{d}}\). The progress \(\theta_i\) corresponds to the displacement along the axis \(\hat{\mathbf{d}}\). This case captures the insertion- or push-like geometric structures that are common in constrained tasks.

4.3.4 Primitive representation↩︎

Each segment is represented as a screw primitive \(\pi_n=\{\hat{\mathbf{s}}_n, \mathbf{q}_n, h_n, \theta_n^{end}\}\). The terminal progress value \(\theta_n^{end}\) is only used as a reference to initialize execution speed and is not used as a termination condition.

4.4 Execution with Admittance-Guided Screw Primitives↩︎

Each learned screw primitive \(\pi_n=\{\hat{\mathbf{s}}_n, \mathbf{q}_n, h_n, \theta_n^{end}\}\) defines a constrained motion parameterized by the progress variable \(\theta\) in the primitive’s local frame. At each control cycle, a nominal pose is generated as \[\mathbf{T}_{des}(\theta) = \mathbf{T}_0\exp(\hat{\boldsymbol{\xi}}_n\,\theta),\] where \(\mathbf{T}_0\) is the initial robot end-effector pose at the start of primitive and \(\hat{\boldsymbol{\xi}}_n\) is the twist associated with \(\pi_n\).

To enable robust interaction with the constrained environment, the nominal pose is modulated online with a 6D admittance correction defined in the end-effector (EE) frame. The small pose correction \(\Delta\mathbf{x}_{ee}=[\Delta\mathbf{p}_{ee}, \Delta\boldsymbol{\theta}_{ee}]\) is generated by the measured wrench \(\mathbf{w}_{ee} = [\mathbf{F}_{ee}, \boldsymbol{\tau}_{ee}]\) through standard admittance dynamics \[\mathbf{M}\Delta\ddot{\mathbf{x}}_{ee} + \mathbf{B}\Delta\dot{\mathbf{x}}_{ee} + \mathbf{K}\Delta\mathbf{x}_{ee}=\mathbf{w}_{ee}.\]

In addition to pose correction, wrench feedback is also used to regulate execution speed along the screw. Before that, the screw axis direction \(\hat{\mathbf{s}}_n\) and the point \(\mathbf{q}_n\) on this axis, originally from local frame \(\mathbf{T}_0\), are transformed into current EE frame as \(\hat{\mathbf{s}}_{ee}\) and \(\mathbf{q}_{ee}\). We decompose the measured wrench relative to the screw axis with axial components defined as \[F_{\parallel} = \mathbf{F}_{ee}^{\top} \hat{\mathbf{s}}_{ee}, \;\;\;\; \tau_{\parallel} = \left( \boldsymbol{\tau}_{ee} - \mathbf{q}_{ee} \times \mathbf{F}_{ee} \right)^{\top} \hat{\mathbf{s}}_{ee},\] and the perpendicular components defined as the magnitude of the residual wrench without their projections onto \(\hat{\mathbf{s}}_{ee}\), denoted as \(F_{\perp}\) and \(\tau_{\perp}\). A scalar load is then computed as \[L = k_F^{\parallel} F_{\parallel} + k_T^{\parallel} \tau_{\parallel} + k_F^{\perp} F_{\perp} + k_T^{\perp} \tau_{\perp}, \label{eq:load}\tag{2}\] where \(k_F^{\perp}, \,k_T^{\perp},\, k_F^{\parallel},\, k_T^{\parallel}\) are weight factors to balance each component. The scalar load \(L\) is then used to regulate the progress velocity \(\dot{\theta}\) through a 1D admittance model: \[M_{\theta}\dot{v}_{\theta} + B_{\theta}v_{\theta}=-L, \;\;\;\; \dot{\theta}=\dot{\theta}_0 + v_{\theta},\] where \(\dot{\theta}_0\) is the nominal execution speed assigned based on \(\theta_n^{end}\). As contact resistance increases, \(\dot{\theta}\) is smoothly reduced. A screw primitive is considered complete when the effective progress velocity remains below a threshold for a sustained duration, after which the next primitive is executed until all the screw primitives are finished.

Here axial terms are assigned significantly larger weights, i.e., \(k_F^{\perp}, k_T^{\perp} \ll k_F^{\parallel}, k_T^{\parallel}\), ensuring that speed regulation is primarily governed by resistance along the intended screw direction, while lateral interaction is mainly handled by 6D pose admittance.

4.5 Reverse Skill Learning and Execution↩︎

The proposed framework enables reverse task execution from a single forward demonstration. During forward learning, the contact phase is decomposed into an ordered sequence of screw primitives \(\{\pi_n\}_{n=1}^{N}\). Reverse execution directly reuses these learned primitives to obtain \(\tilde{\pi}_n\) by editing the learned screw parameters, i.e., \((\boldsymbol{\omega}, \mathbf{v}) \mapsto (-\boldsymbol{\omega}, -\mathbf{v})\). The reverse task is then executed by applying the sequence \(\{\tilde{\pi}_N, \ldots, \tilde{\pi}_1\}\) under the same admittance control.

Reverse execution begins in contact. For each reversed primitive \(\tilde{\pi}_n\), contact release is evaluated every short period using an active wrench-based probing test. Specifically, a small circular dither motion orthogonal to the screw axis is executed, and the load is monitored during this interval. The median absolute load is compared to a predefined threshold to determine whether the contact constraint has been released. Upon release, execution transitions to the next primitive or exits the contact phase. The remaining free-space motion is then reproduced using the DMP learned from the time-reversed trajectory of the forward demonstration.

5 Experiments and Results↩︎

5.1 Experimental Setup↩︎

All experiments are conducted on a Franka Emika Panda robot equipped with a wrist-mounted SCHUNK FT-AXIA80 force/torque sensor. Demonstrations are provided via kinesthetic teaching. For each task, only one single demonstration is used to learn both forward and reverse skills. During execution, only the end-effector pose and wrench measurements are used. AprilTags [36] are used solely for initial object pose estimation; no visual feedback is used during task execution. Wrench safety limits are enforced to all tasks. 4 methods are evaluated on 5 randomized trials per task in both forward and reverse settings learned from both complete and unfinished demonstrations. With 4 tasks, this results in 80 trials per method in total. Segmentation parameters are fixed across all tasks; only safety threshold and scalar load weight in Eq. 2 are task-dependent due to contact properties. Full values are listed on the website.

5.2 Tasks and Success Criteria↩︎

We evaluate four representative contact-rich manipulation tasks. Unfinished demonstrations are generated by directly truncating the contact phase of the full demonstration as shown in Fig. 5:

5.2.1 Peg-in-hole insertion↩︎

A rectangular peg is grasped and inserted into a fixed hole with approximately 1 mm dimensional clearance. Success criteria: (1) forward: insertion depth \(>\) 2.3cm (max 2.5cm); (2) reverse: complete extraction without exceeding wrench limits.

5.2.2 Battery insertion↩︎

The battery insertion involves three sequential contact phases as Fig. 3: (1) sliding along a spring channel; (2) tilting to contact the bottom surface; (3) final seating translation. Success criteria: (1) forward: \(\geq 75\%\) of the battery left surface lies inside the bed; (2) reverse: complete extraction.

5.2.3 Lock opening↩︎

A pre-grasped key is inserted and rotated until fully opening the fixed lock with less than 0.5 mm clearance. Success criteria: (1) forward: lock fully opened; (2) reverse: complete key extraction.

5.2.4 Screw driving↩︎

The screw is pre-inserted and partially threaded into the hole with approximately 1 mm clearance, and with two threads remaining before full tightening, and is then rotated until tight. During evaluation, trials are initialized with 1–3 threads remaining before full tightening. Execution begins directly in the contact phase.

Due to the wrist joint limits of the Panda robot, continuous rotation beyond a full revolution is not feasible without regrasping. During demonstration, human operator periodically releases, reorients and regrasps multiple times (see Fig. 3). To obtain a continuous \(SE(3)\) trajectory suitable for screw primitive fitting, grasped rotation segments are stitched by chaining relative motions across regrasp intervals: \[\Delta{\mathbf{T}_k}=\mathbf{T}_0^{-1}\mathbf{T}_k, \;\;\;\; \mathbf{T}'_k=\mathbf{T}'_{last}\Delta{\mathbf{T}_k},\] where \(\mathbf{T}_0\) is the first pose of the current grasp segment and \(\mathbf{T}'_{last}\) is the last pose of the previous stitched segment, \(\mathbf{T}_k\) and \(\mathbf{T}'_k\) are the raw pose and the stitched pose within the segments at index \(k\). The resulting stitched demonstration represents a single continuous screw-driving motion and is directly used for screw primitive fitting.

During execution, a similar regrasp-aware policy is adopted. We track the accumulated rotation about the learned screw axis. When the accumulated rotation exceeds approximately \(90^\circ\), the robot (1) opens the gripper, (2) rotates the tool back by \(90^\circ\) about the screw axis, (3) regrasps before continuing execution. This periodical execution enables arbitrary long screw rotations without violating the Panda robot’s wrist joint limits.

Success criteria: (1) forward: reach the screw tightening point, and stop by method’s own mechanism; (2) reverse: back out the screw until final thread where the screw loses self-supporting stability and can no longer remain upright without external support.

5.3 Baselines↩︎

We compare against three one-shot learning baselines to evaluate the contribution of geometric screw modeling and interaction-aware execution:

5.3.1 DMP only↩︎

The entire demonstrated trajectory (non-contact and contact), is reproduced using a single DMP. Contact detection, spiral search and wrench safety limits are identical to those used in our method.

5.3.2 DMP + admittance↩︎

The entire demonstrated trajectory is reproduced with a DMP under 6D Cartesian admittance correction, other settings are the same as DMP only.

5.3.3 DMP + twist + admittance↩︎

Non-contact phases apply DMP. Contact phases are segmented with our method, but each segment is represented by a constant twist computed from start–end displacement. Execution uses the same admittance correction and speed regulation as our method.

For reverse tasks, both our method and DMP + twist + admittance baseline assume that extraction must be achieved through contact-phase primitives; extraction achieved by DMP motion is not considered successful.

5.4 Task Performance with Complete Demonstrations↩︎

Table 1 reports task success rates for complete demonstrations. Our method achieves 20/20 success in both forward and reverse settings. DMP only performs well in insertion-dominant tasks but degrades in screw driving, where success depends on matching the demonstrated remaining thread length. DMP + Admittance improves some contact interaction but fails in highly constrained tasks such as lock opening and screw driving, where admittance-induced deviations can prevent the required geometric configurations to initialize next primitive. DMP + Twist + Admittance performs competitively in peg and battery tasks but fails in screw driving and reverse lock opening because start–end twists do not capture accumulated rotational structure or the correct reverse extraction geometry. These results highlight the importance of explicit screw primitive fitting for maintaining geometric consistency in constrained manipulation.

2.5pt

5.5 Task Performance with Unfinished Demonstrations↩︎

Table 2 evaluates truncated demonstrations. Fig. 4 shows lock opening learned from an unfinished demonstration, where wrench feedback regulates insertion and rotation progress through 1D admittance. DMP only and DMP + Admittance terminate at the demonstrated endpoint, lacking the mechanism to extend forward contact motion. DMP + Twist + Admittance extends motion but degrades in screw and reverse tasks due to the same geometric inconsistencies observed with complete demonstrations.

Our method achieves 18/20 success in both forward and reverse settings. Failures occur only in screw driving and are mainly caused by initial pose errors and pitch deviations from trajectory stitching, which accumulate over multiple rotations and lead to axis misalignment. Overall, results demonstrate that screw primitive modeling enables reliable task completion from partial demonstrations under geometric constraints.

2.5pt

5.6 Segmentation Evaluation↩︎

For segmentation evaluation, 5 demonstrations are collected for each task, resulting in 20 trajectories in total. Fig. 5 shows representative segmentation results for the four tasks used in execution experiments. For screw task, the segmentation is applied to each grasped rotation segment before stitching.

We compare our twist-direction segmentation against Human-Guided Screw Planning (HGS) [10], Kernel Temporal Segmentation (KTS) [33], and Automatic Waypoint Extraction (AWE) [31], which are based on screw-motion reconstruction error, temporal signal variation, and waypoint reconstruction error, respectively.

Performance is evaluated using boundary F1 score [34] at tolerances \(\tau \in {0.2, 0.5, 0.8s}\), Variation of Information (VI) [37], and segment count error (Cnt.). For fair comparison, all methods are applied with dwell clean-up to remove spurious micro-segments (see Sec. 4.2.6).

Table 3 reports segmentation performance on four tasks. Our method achieves an overall better performance. AWE relies primarily on waypoints reconstruction error, making it brittle in rotation-dominant scenarios. HGS incorporates screw-geometry reasoning and is therefore more aligned with geometric interpretation, achieving the lowest segment count error, but is less stable in boundary detection. KTS achieves the best performance among all three baselines, yet still underperforms compared to ours. In contrast, our method detects transitions based on twist-direction consistency in SE(3), considering both local directional changes and global twist coherence, yielding more stable boundaries for short and highly constrained motions.

3pt

5.7 Generalization to Novel Objects↩︎

We further applied our learned screw primitives to a novel object with different dimension as shown in Fig 6 for each task. All four tasks are successfully completed with the screw primitives learned from previous same demonstration but only provided a target position under admittance control, which indicates that our proposed method captures task-consistent motion structure and exhibits transferability across objects with similar constraints.

6 Conclusions↩︎

In this paper, we present a unified one-shot learning framework for constrained, contact-rich manipulation that enables both forward and reverse task execution from a single, potentially unfinished demonstration. By decomposing motion into non-contact DMP reproduction and contact-phase screw primitives, the proposed approach captures geometric constraints while regulating execution through wrench-aware admittance control.

We introduce a twist-direction-based segmentation that enables task-agnostic decomposition of contact motion, from which screw primitives are learned to allow interaction-driven progress and termination beyond the demonstrated trajectory length. Experimental results across four real-world manipulation tasks demonstrate improved robustness and generalization compared to trajectory-based one-shot baselines.

Execution speed was not optimized and could be improved with faster alignment and primitive-speed selection. Remaining limitations include possible axis/pitch misalignment from sustained Cartesian admittance offsets during screw-driving motions with regrasping, and generalization mainly to objects with similar contact topology; future work will explore screw-aware admittance and online primitive adaptation.

Overall, this work highlights the benefits of integrating geometric screw representations with interaction-aware execution, providing a practical and data-efficient solution for constrained robot manipulation task learning.

References↩︎

---

1. \(^{1}\)Yexin Hu, Haoyi Zheng, Johannes Heidersberger and Dongheui Lee are with the Autonomous Systems Lab, Technische Universität Wien (TU Wien), Austria. Emails: {yexin.hu, haoyi.zheng, johannes.heidersberger, dongheui.lee}tuwien.ac.at?↩︎

2. \(^{2}\)Dongheui Lee is with the Institute of Robotics and Mechatronics, German Aerospace Center (DLR), Germany.↩︎

3. This work was partially supported by the European Union project INVERSE under grant agreement No. 101136067.↩︎