diff --git a/app/globals.css b/app/globals.css
index 92e4bc3..e23a8fb 100644
--- a/app/globals.css
+++ b/app/globals.css
@@ -747,6 +747,21 @@ button:disabled {
 .tour-layer-guided {
   pointer-events: auto;
 }
+.chart-svg.chart-svg-move {
+  cursor: crosshair;
+}
+.chart-increase-target {
+  fill: none;
+  stroke: #44936b;
+  stroke-width: 3px;
+}
+.increase-move-hint {
+  align-items: center;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin: 4px 16px 10px;
+}
 .yoke-tour-editor {
   background: var(--panel);
   inset: 0;
diff --git a/components/chart-grid.tsx b/components/chart-grid.tsx
index fb891ed..1bbb655 100644
--- a/components/chart-grid.tsx
+++ b/components/chart-grid.tsx
@@ -1,6 +1,7 @@
 "use client";
 
 import { PointerEvent, useRef } from "react";
+import type { ChartPoint } from "@/lib/yoke-move-increase";
 import {
   cellAspectRatio,
   CellSelection,
@@ -26,6 +27,9 @@ type Props = {
   onPaint: (row: number, column: number, flood: boolean) => void;
   yarnOnly?: boolean;
   onStrokeEnd?: () => void;
+  onCellPick?: (point: ChartPoint) => void;
+  onCellPoint?: (point: ChartPoint | null) => void;
+  moveTarget?: ChartPoint;
 };
 
 export function ChartGrid({
@@ -39,6 +43,9 @@ export function ChartGrid({
   onPaint,
   yarnOnly = false,
   onStrokeEnd,
+  onCellPick,
+  onCellPoint,
+  moveTarget,
 }: Props) {
   const svgRef = useRef<SVGSVGElement>(null);
   const drawing = useRef(false);
@@ -79,6 +86,10 @@ export function ChartGrid({
     const cell = cellFromPointer(event);
     if (!cell) return;
     event.currentTarget.setPointerCapture(event.pointerId);
+    if (onCellPick) {
+      onCellPick(cell);
+      return;
+    }
     if (tool === "select") {
       selecting.current = true;
       drawing.current = false;
@@ -99,6 +110,10 @@ export function ChartGrid({
   }
 
   function handlePointerMove(event: PointerEvent<SVGSVGElement>) {
+    if (onCellPick) {
+      if (event.pointerType !== "touch") onCellPoint?.(cellFromPointer(event));
+      return;
+    }
     if (drawing.current || selecting.current) event.preventDefault();
     if (selecting.current && selectionStart.current) {
       const cell = cellFromPointer(event);
@@ -170,7 +185,7 @@ export function ChartGrid({
           </div>
           <svg
             ref={svgRef}
-            className="chart-svg"
+            className={onCellPick ? "chart-svg chart-svg-move" : "chart-svg"}
             viewBox={`0 0 ${document.width * aspect} ${document.height}`}
             style={{
               aspectRatio: `${document.width * aspect} / ${document.height}`,
@@ -308,26 +323,39 @@ export function ChartGrid({
                 pointerEvents="none"
               />
             ) : null}
+            {moveTarget ? (
+              <rect
+                className="chart-increase-target"
+                x={moveTarget.column * aspect}
+                y={moveTarget.row}
+                width={aspect}
+                height={1}
+                vectorEffect="non-scaling-stroke"
+                pointerEvents="none"
+              />
+            ) : null}
           </svg>
         </div>
-        <p className="chart-hint">
-          {structureAction === "knit"
-            ? "Click and drag to remove stitch symbols, keeping yarn colours. With Fill, click a connected group of symbols to remove them."
-            : structureAction
-              ? tool === "fill"
-                ? `Click an area to fill it with ${stitchActionLabel(structureAction)}.`
-                : `Click and drag to mark cells as ${stitchActionLabel(structureAction)}${document.guides.symmetry !== "none" ? " with live symmetry" : ""}.`
-              : tool === "fill"
-                ? "Click an area to fill its yarn colour. Stitch symbols stay in place."
-                : tool === "select"
-                  ? yarnOnly
-                    ? "Drag a rectangle to fill, copy, cut, paste or move yarn colours."
-                    : "Drag a rectangle to fill, copy, cut, paste, move, or apply a stitch action."
-                  : `Click and drag to ${tool === "eraser" ? "erase the yarn colour" : "paint"}${document.guides.symmetry !== "none" ? " with live symmetry" : ""}.`}
-          {document.stitchActions && !structureAction && !yarnOnly
-            ? " Use Remove stitch to erase symbols without changing yarn colours."
-            : ""}
-        </p>
+        {!onCellPick ? (
+          <p className="chart-hint">
+            {structureAction === "knit"
+              ? "Click and drag to remove stitch symbols, keeping yarn colours. With Fill, click a connected group of symbols to remove them."
+              : structureAction
+                ? tool === "fill"
+                  ? `Click an area to fill it with ${stitchActionLabel(structureAction)}.`
+                  : `Click and drag to mark cells as ${stitchActionLabel(structureAction)}${document.guides.symmetry !== "none" ? " with live symmetry" : ""}.`
+                : tool === "fill"
+                  ? "Click an area to fill its yarn colour. Stitch symbols stay in place."
+                  : tool === "select"
+                    ? yarnOnly
+                      ? "Drag a rectangle to fill, copy, cut, paste or move yarn colours."
+                      : "Drag a rectangle to fill, copy, cut, paste, move, or apply a stitch action."
+                    : `Click and drag to ${tool === "eraser" ? "erase the yarn colour" : "paint"}${document.guides.symmetry !== "none" ? " with live symmetry" : ""}.`}
+            {document.stitchActions && !structureAction && !yarnOnly
+              ? " Use Remove stitch to erase symbols without changing yarn colours."
+              : ""}
+          </p>
+        ) : null}
       </div>
     </div>
   );
diff --git a/components/stitch-palette-panel.tsx b/components/stitch-palette-panel.tsx
index 7961f0f..8bee589 100644
--- a/components/stitch-palette-panel.tsx
+++ b/components/stitch-palette-panel.tsx
@@ -8,6 +8,7 @@ import {
   type StitchAction,
   type StitchPaletteAction,
 } from "@/lib/chart";
+const yokeStitchOptions = new Set<StitchAction>(["purl", "m1l", "m1r"]);
 type Props = {
   document: ChartDocument;
   structureAction: StitchAction | null;
@@ -34,6 +35,12 @@ export function StitchPalettePanel({
   removeStitchFromPalette,
   resetStitchColor,
 }: Props) {
+  const availableStitches = stitchActionOptions.filter(
+    (option): option is typeof option & { value: StitchPaletteAction } =>
+      option.value !== "knit" &&
+      (!document.yoke || yokeStitchOptions.has(option.value)) &&
+      !stitchPalette.includes(option.value),
+  );
   return (
     <details
       className="settings-group stitch-settings"
@@ -59,30 +66,16 @@ export function StitchPalettePanel({
           <div className="stitch-picker" aria-label="Stitch tools">
             <p>Add a stitch type to this chart’s palette.</p>
             <div>
-              {stitchActionOptions
-                .filter(
-                  (
-                    option,
-                  ): option is typeof option & {
-                    value: StitchPaletteAction;
-                  } =>
-                    option.value !== "knit" &&
-                    !stitchPalette.includes(
-                      option.value as StitchPaletteAction,
-                    ),
-                )
-                .map((option) => (
-                  <button
-                    key={option.value}
-                    title={option.help}
-                    onClick={() => addStitchToPalette(option.value)}
-                  >
-                    {option.shortLabel}
-                  </button>
-                ))}
-              {stitchPalette.length ===
-              stitchActionOptions.filter((option) => option.value !== "knit")
-                .length ? (
+              {availableStitches.map((option) => (
+                <button
+                  key={option.value}
+                  title={option.help}
+                  onClick={() => addStitchToPalette(option.value)}
+                >
+                  {option.shortLabel}
+                </button>
+              ))}
+              {!availableStitches.length ? (
                 <span>All stitch types have been added.</span>
               ) : null}
             </div>
diff --git a/components/use-yoke-increase-move.ts b/components/use-yoke-increase-move.ts
new file mode 100644
index 0000000..6d264a9
--- /dev/null
+++ b/components/use-yoke-increase-move.ts
@@ -0,0 +1,121 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { yokeChart } from "@/lib/yoke-chart";
+import {
+  prepareYokeIncreaseMove,
+  type ChartPoint,
+} from "@/lib/yoke-move-increase";
+import type { YokeProject } from "@/lib/yoke-project";
+import type { YokeRepeatScope } from "@/lib/yoke-repeat-scope";
+
+const same = (a: ChartPoint | null, b: ChartPoint | null) =>
+  a === b || (!!a && !!b && a.row === b.row && a.column === b.column);
+
+export function useYokeIncreaseMove(
+  project: YokeProject,
+  repeat: number,
+  scope: YokeRepeatScope,
+  enabled: boolean,
+  onCommit: (next: YokeProject) => void,
+) {
+  const context = `${repeat}/${scope}`;
+  const [picked, setPicked] = useState<{
+    project: YokeProject;
+    context: string;
+    point: ChartPoint;
+    prepare: ReturnType<typeof prepareYokeIncreaseMove>;
+  } | null>(null);
+  const [target, setTarget] = useState<ChartPoint | null>(null);
+  const [preview, setPreview] = useState<{
+    picked: NonNullable<typeof picked>;
+    target: ChartPoint;
+    project?: YokeProject;
+    chart?: ReturnType<typeof yokeChart>["document"];
+    error?: string;
+  } | null>(null);
+  const [error, setError] = useState("");
+  const active =
+    enabled && picked?.project === project && picked.context === context
+      ? picked
+      : null;
+  const result =
+    active && preview?.picked === active && same(preview.target, target)
+      ? preview
+      : null;
+
+  useEffect(() => {
+    if (!active || !target || same(active.point, target)) return;
+    const timer = window.setTimeout(() => {
+      try {
+        const next = active.prepare(target);
+        setPreview({
+          picked: active,
+          target,
+          project: next,
+          chart: yokeChart(next, repeat).document,
+        });
+      } catch (cause) {
+        setPreview({
+          picked: active,
+          target,
+          error:
+            cause instanceof Error
+              ? cause.message
+              : "Could not move this increase.",
+        });
+      }
+    }, 100);
+    return () => window.clearTimeout(timer);
+  }, [active, target, repeat]);
+
+  function cancel() {
+    setPicked(null);
+    setTarget(null);
+    setPreview(null);
+    setError("");
+  }
+  function apply() {
+    if (!result?.project) return;
+    onCommit(result.project);
+    cancel();
+  }
+  function pointAt(point: ChartPoint | null) {
+    if (active)
+      setTarget((current) => (same(current, point) ? current : point));
+  }
+  function click(point: ChartPoint) {
+    if (!enabled) return;
+    if (active) {
+      if (same(active.point, point)) cancel();
+      else if (result?.project && same(result.target, point)) apply();
+      else if (result?.error && same(result.target, point))
+        setError(result.error);
+      else pointAt(point);
+      return;
+    }
+    cancel();
+    try {
+      setPicked({
+        project,
+        context,
+        point,
+        prepare: prepareYokeIncreaseMove(project, repeat, scope, point),
+      });
+    } catch (cause) {
+      setError(
+        cause instanceof Error ? cause.message : "Choose an M1L or M1R.",
+      );
+    }
+  }
+  return {
+    click,
+    pointAt,
+    cancel,
+    apply,
+    source: active?.point,
+    target: result?.project ? result.target : undefined,
+    chart: result?.chart,
+    error: enabled ? error : "",
+  };
+}
diff --git a/components/use-yoke-tools.ts b/components/use-yoke-tools.ts
index c5fd1ff..54b6821 100644
--- a/components/use-yoke-tools.ts
+++ b/components/use-yoke-tools.ts
@@ -25,7 +25,7 @@ import { mirrorYokeRepeat } from "@/lib/yoke-repeat-mirror";
 import type { YokeRepeatScope } from "@/lib/yoke-repeat-scope";
 import { yokeRepeatNumber } from "@/lib/yoke-repeat-labels";
 
-export type YokeTool = Tool | "row-fill";
+export type YokeTool = Tool | "row-fill" | "move-increase";
 export function useYokeTools(
   project: YokeProject,
   view: YokeView,
diff --git a/components/yoke-drawing-tools.tsx b/components/yoke-drawing-tools.tsx
index cd6e727..b83e374 100644
--- a/components/yoke-drawing-tools.tsx
+++ b/components/yoke-drawing-tools.tsx
@@ -15,6 +15,7 @@ export function YokeDrawingTools({
   onErase,
   onFillSelection,
   selectionLabel,
+  moveIncreaseUnavailable,
 }: {
   tools: YokeTools;
   color: number;
@@ -28,6 +29,7 @@ export function YokeDrawingTools({
   onErase?: () => void;
   onFillSelection?: () => void;
   selectionLabel?: string;
+  moveIncreaseUnavailable?: string;
 }) {
   const { selection } = tools;
   return (
@@ -55,6 +57,22 @@ export function YokeDrawingTools({
               {label}
             </button>
           ))}
+          <button
+            aria-pressed={tools.tool === "move-increase"}
+            className={tools.tool === "move-increase" ? "active" : ""}
+            disabled={Boolean(moveIncreaseUnavailable)}
+            title={
+              moveIncreaseUnavailable ??
+              "Pick an M1L or M1R, then choose its new cell"
+            }
+            onClick={() => {
+              tools.setSelection(null);
+              tools.setTool("move-increase");
+              onErase?.();
+            }}
+          >
+            Move increase
+          </button>
           <button onClick={tools.clearAll}>Clear</button>
         </div>
         <span className="toolbar-divider" aria-hidden="true" />
diff --git a/components/yoke-editor.tsx b/components/yoke-editor.tsx
index 34de0f0..cdfd26c 100644
--- a/components/yoke-editor.tsx
+++ b/components/yoke-editor.tsx
@@ -17,6 +17,7 @@ import { StitchPalettePanel } from "./stitch-palette-panel";
 import { useYokeStitches, type YokeStitchDraft } from "./use-yoke-stitches";
 import { YokeStitchRevisionDialog } from "./yoke-stitch-revision-dialog";
 import { withYokeProgram } from "@/lib/yoke-program-state";
+import { useYokeIncreaseMove } from "./use-yoke-increase-move";
 
 export function YokeEditor({
   document,
@@ -53,6 +54,8 @@ export function YokeEditor({
   const target = calculateYokeTargets(project.measurements);
   function setView(next: YokeView) {
     tools.setSelection(null);
+    if (next !== "chart" && tools.tool === "move-increase")
+      tools.setTool("pencil");
     onViewChange(next);
   }
   const [selected, setSelected] = useState("yarn-1");
@@ -77,7 +80,8 @@ export function YokeEditor({
   }
   function selectStitch(action: import("@/lib/chart").StitchAction) {
     stitches.select(action);
-    if (tools.tool === "eraser") tools.setTool("pencil");
+    if (tools.tool === "eraser" || tools.tool === "move-increase")
+      tools.setTool("pencil");
   }
   const [zoom, setZoom] = useState(100);
   const [sideways, setSideways] = useState(false);
@@ -94,6 +98,20 @@ export function YokeEditor({
     if (remember) onStrokeStart();
     onChange(yokeDocument(next, document.name));
   }
+  const moveIncreaseUnavailable =
+    view !== "chart"
+      ? "Switch to Standard chart to move increases."
+      : stitches.draft.edits.length
+        ? "Apply or discard pending shaping changes first."
+        : undefined;
+  const moving = tools.tool === "move-increase";
+  const move = useYokeIncreaseMove(
+    project,
+    tools.repeat,
+    tools.scope,
+    moving && !moveIncreaseUnavailable,
+    change,
+  );
   return (
     <>
       <aside className="sidebar panel">
@@ -199,6 +217,7 @@ export function YokeEditor({
         <section className="editor panel yoke-editor-panel">
           <YokeDrawingTools
             tools={tools}
+            moveIncreaseUnavailable={moveIncreaseUnavailable}
             color={color}
             zoom={visibleZoom}
             minimumZoom={view === "chart" ? 100 : 1}
@@ -307,6 +326,27 @@ export function YokeEditor({
             count={project.measurements.repeats}
             tools={tools}
           />
+          {moving && (moveIncreaseUnavailable || move.source) ? (
+            <div className="increase-move-hint">
+              <span className="yoke-hint">
+                {moveIncreaseUnavailable ??
+                  "Point at a cell to preview, then click to place."}
+              </span>
+              {move.source ? (
+                <button onClick={move.cancel}>Cancel move</button>
+              ) : null}
+              {move.source ? (
+                <button disabled={!move.chart} onClick={move.apply}>
+                  Apply move
+                </button>
+              ) : null}
+            </div>
+          ) : null}
+          {move.error ? (
+            <p className="error-message increase-move-hint" role="alert">
+              {move.error}
+            </p>
+          ) : null}
           {stitches.error ? <p role="alert">{stitches.error}</p> : null}
           {tools.error ? (
             <p role="alert" className="error-message">
@@ -354,9 +394,31 @@ export function YokeEditor({
               project={project}
               zoom={visibleZoom}
               selectedColor={tools.tool === "eraser" ? 0 : color}
-              drawing={stitches.markedDrawing}
-              tool={tools.tool === "row-fill" ? "fill" : tools.tool}
-              selection={tools.selection}
+              drawing={
+                move.chart
+                  ? { ...stitches.markedDrawing, document: move.chart }
+                  : stitches.markedDrawing
+              }
+              tool={
+                tools.tool === "row-fill"
+                  ? "fill"
+                  : tools.tool === "move-increase"
+                    ? "pencil"
+                    : tools.tool
+              }
+              onCellPick={moving ? move.click : undefined}
+              onCellPoint={moving ? move.pointAt : undefined}
+              moveTarget={move.target}
+              selection={
+                move.source
+                  ? {
+                      startRow: move.source.row,
+                      endRow: move.source.row,
+                      startColumn: move.source.column,
+                      endColumn: move.source.column,
+                    }
+                  : tools.selection
+              }
               onSelectionChange={tools.setSelection}
               onPaint={(row, column) => tools.paint(row, column, color)}
               onChartPaint={
diff --git a/components/yoke-standard-chart.tsx b/components/yoke-standard-chart.tsx
index 4204e8d..97eaa73 100644
--- a/components/yoke-standard-chart.tsx
+++ b/components/yoke-standard-chart.tsx
@@ -4,6 +4,7 @@ import { ChartGrid } from "./chart-grid";
 import type { YokeProject } from "@/lib/yoke-project";
 import type { CellSelection, Tool } from "@/lib/chart";
 import { yokeDrawing } from "@/lib/yoke-editing";
+import type { ChartPoint } from "@/lib/yoke-move-increase";
 
 export function YokeStandardChart({
   project,
@@ -17,6 +18,9 @@ export function YokeStandardChart({
   onSelectionChange = () => {},
   onStrokeEnd,
   onChartPaint,
+  onCellPick,
+  onCellPoint,
+  moveTarget,
 }: {
   project: YokeProject;
   zoom: number;
@@ -29,6 +33,9 @@ export function YokeStandardChart({
   onSelectionChange?: (value: CellSelection | null) => void;
   onStrokeEnd?: () => void;
   onChartPaint?: (row: number, column: number) => void;
+  onCellPick?: (point: ChartPoint) => void;
+  onCellPoint?: (point: ChartPoint | null) => void;
+  moveTarget?: ChartPoint;
 }) {
   const fallback = useMemo(
     () => suppliedDrawing ?? yokeDrawing(project, 0),
@@ -48,6 +55,9 @@ export function YokeStandardChart({
         onSelectionChange={onSelectionChange}
         onStrokeStart={onStrokeStart}
         onStrokeEnd={onStrokeEnd}
+        onCellPick={onCellPick}
+        onCellPoint={onCellPoint}
+        moveTarget={moveTarget}
         onPaint={(chartRow, chartColumn) => {
           if (onChartPaint) {
             onChartPaint(chartRow, chartColumn);
diff --git a/e2e/editor.spec.ts b/e2e/editor.spec.ts
index c669cf7..d6ad5fa 100644
--- a/e2e/editor.spec.ts
+++ b/e2e/editor.spec.ts
@@ -100,6 +100,65 @@ test("first visit and Help offer the yoke tour and an editable example", async (
   ).toHaveCount(0);
 });
 
+test("placing a yoke increase previews placeholders and can be undone", async ({
+  page,
+}) => {
+  await page.goto("/");
+  await page.getByRole("button", { name: "Help and examples" }).click();
+  await page
+    .getByRole("article")
+    .filter({ hasText: "Tidal Fish Yoke" })
+    .getByRole("button", { name: "Open example" })
+    .click();
+  await page
+    .getByRole("button", { name: "Move increase", exact: true })
+    .click();
+  await page.getByLabel("Edit scope").selectOption("one");
+  const chart = page.locator(".yoke-standard-chart .chart-svg");
+  const from = chart
+    .locator("g")
+    .first()
+    .locator("rect")
+    .nth(16 * 41 + 5);
+  const to = chart
+    .locator("g")
+    .first()
+    .locator("rect")
+    .nth(15 * 41 + 5);
+  await from.click();
+  await to.hover();
+  await expect(chart.locator(".chart-increase-target")).toBeVisible();
+  await expect(from).toHaveClass("chart-no-stitch");
+  await to.click();
+  await expect(chart.locator(".chart-increase-target")).toHaveCount(0);
+  await expect(from).toHaveClass("chart-no-stitch");
+  await page.getByRole("button", { name: "Undo", exact: true }).click();
+  await expect(from).not.toHaveClass("chart-no-stitch");
+});
+
+test("yoke and regular charts offer different stitch choices", async ({
+  page,
+}) => {
+  await page.goto("/");
+  const add = page.getByRole("button", { name: "+ Add stitch", exact: true });
+  await add.click();
+  await expect(
+    page.getByRole("button", { name: "SSK", exact: true }),
+  ).toBeVisible();
+  await page.getByRole("button", { name: "Help and examples" }).click();
+  await page
+    .getByRole("article")
+    .filter({ hasText: "Tidal Fish Yoke" })
+    .getByRole("button", { name: "Open example" })
+    .click();
+  await add.click();
+  const choices = page.locator(".stitch-picker button");
+  expect(await choices.allTextContents()).toEqual(["Purl", "M1R"]);
+  await expect(
+    page.getByRole("button", { name: "Draw Make 1 left", exact: true }),
+  ).toBeVisible();
+});
+
 test("anonymous editor supports draw, undo, redo, and immediate save/reload", async ({
   page,
 }) => {
diff --git a/e2e/yoke-editor.spec.ts b/e2e/yoke-editor.spec.ts
index ccfefec..e18beef 100644
--- a/e2e/yoke-editor.spec.ts
+++ b/e2e/yoke-editor.spec.ts
@@ -57,6 +57,28 @@ async function create(page: Page) {
     .toBe(true);
 }
 
+// Older saved yokes may still have SSK in their palette. Keep exercising
+// those documents even though the new-stitch picker no longer offers it.
+async function seedLegacySsk(page: Page) {
+  const state = await saved(page);
+  const tab = state.tabs.find((tab) => tab.id === state.activeTabId)!;
+  tab.document = yokeDocument(
+    {
+      ...tab.document.yoke!,
+      stitchPalette: [...(tab.document.stitchPalette ?? []), "ssk"],
+    },
+    tab.document.name,
+  );
+  await page.evaluate(
+    ({ key, state }) => localStorage.setItem(key, JSON.stringify(state)),
+    { key, state },
+  );
+  await page.reload();
+  await expect(
+    page.getByRole("button", { name: "Draw Slip, slip, knit", exact: true }),
+  ).toBeVisible();
+}
+
 test("the planning preview fits on a small screen and can zoom while editing short rows", async ({
   page,
 }) => {
@@ -96,6 +118,7 @@ for (const custom of [false, true]) {
       route.fulfill({ path: resolve("public/textures/merino-relief.png") }),
     );
     await create(page);
+    if (custom) await seedLegacySsk(page);
     const before = await active(page);
     const original = before.document.yoke!;
     const round = original.cells.length;
@@ -121,9 +144,8 @@ for (const custom of [false, true]) {
     if (custom) {
       await page.getByLabel("Edit scope").selectOption("one");
       await page
-        .getByRole("button", { name: "+ Add stitch", exact: true })
+        .getByRole("button", { name: "Draw Slip, slip, knit", exact: true })
         .click();
-      await page.getByRole("button", { name: "SSK", exact: true }).click();
       await cells.nth(2).click();
       await page
         .getByRole("button", { name: "Review shaping changes", exact: true })
@@ -1184,9 +1206,11 @@ test("several shaping strokes wait for one review and remain pending across char
   page,
 }) => {
   await create(page);
+  await seedLegacySsk(page);
   await page.getByLabel("Edit scope").selectOption("one");
-  await page.getByRole("button", { name: "+ Add stitch", exact: true }).click();
-  await page.getByRole("button", { name: "SSK", exact: true }).click();
+  await page
+    .getByRole("button", { name: "Draw Slip, slip, knit", exact: true })
+    .click();
   const cells = page.locator(".chart-svg > g:first-child > rect");
   await cells.nth(2).click();
   await cells.nth(6).click();
@@ -1453,9 +1477,11 @@ test("reviewed shaping applies in place at eight tabs and supports undo, redo an
   for (let i = 0; i < 6; i++)
     await page.getByRole("button", { name: "Duplicate", exact: true }).click();
   await expect.poll(async () => (await saved(page)).tabs.length).toBe(8);
+  await seedLegacySsk(page);
   await page.getByLabel("Edit scope").selectOption("one");
-  await page.getByRole("button", { name: "+ Add stitch", exact: true }).click();
-  await page.getByRole("button", { name: "SSK", exact: true }).click();
+  await page
+    .getByRole("button", { name: "Draw Slip, slip, knit", exact: true })
+    .click();
   await expect
     .poll(async () =>
       (await active(page)).document.yoke!.stitchPalette?.includes("ssk"),
@@ -1532,9 +1558,11 @@ test("shaping one repeat previews, cancels safely, forks a revision and stays ed
   page,
 }) => {
   await create(page);
+  await seedLegacySsk(page);
   await page.getByLabel("Edit scope").selectOption("one");
-  await page.getByRole("button", { name: "+ Add stitch", exact: true }).click();
-  await page.getByRole("button", { name: "SSK", exact: true }).click();
+  await page
+    .getByRole("button", { name: "Draw Slip, slip, knit", exact: true })
+    .click();
   await expect
     .poll(async () =>
       (await active(page)).document.yoke!.stitchPalette?.includes("ssk"),
diff --git a/lib/yoke-move-increase.test.ts b/lib/yoke-move-increase.test.ts
new file mode 100644
index 0000000..0c55d11
--- /dev/null
+++ b/lib/yoke-move-increase.test.ts
@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { readChartDocument } from "./chart-schema";
+import { tutorialExampleDocument } from "./tutorial-examples";
+import { yokeDocument } from "./yoke-document";
+import { prepareYokeIncreaseMove } from "./yoke-move-increase";
+import { yokeChart } from "./yoke-chart";
+import { mirrorYokeRepeat } from "./yoke-repeat-mirror";
+import { yokeProgramFromProject } from "./yoke-program-from-project";
+import { withYokeProgram } from "./yoke-program-state";
+import { reviseYokeStitches } from "./yoke-stitch-revision";
+
+const original = tutorialExampleDocument("tidal-fish-yoke")!.document;
+const source = { row: 16, column: 5 };
+
+function projectWithPurl(row: number, column: number) {
+  const base = original.yoke!;
+  const program = yokeProgramFromProject(base);
+  const project = withYokeProgram(base, program);
+  const round = base.cells.length - 1 - row;
+  const chart = yokeChart(project, 0);
+  if (!("operationMaps" in chart))
+    throw new Error("Expected a stitch program.");
+  const operation = chart.operationMaps![round].get(column)!;
+  return withYokeProgram(
+    project,
+    reviseYokeStitches(program, [
+      { round, section: 0, operation, action: "purl" },
+    ]),
+  );
+}
+
+test("a sideways move carries a displaced purl to the newly live cell", () => {
+  const project = projectWithPurl(17, 2);
+  const before = yokeChart(project).document;
+  const next = prepareYokeIncreaseMove(
+    project,
+    0,
+    false,
+    source,
+  )({ row: 16, column: 2 });
+  const after = readChartDocument(yokeDocument(next));
+  assert.equal(before.stitchActions![17][2], "purl");
+  assert.equal(before.stitchActions![17][5], "no-stitch");
+  assert.equal(after.stitchActions![17][2], "no-stitch");
+  assert.equal(after.stitchActions![17][5], "purl");
+  assert.equal(after.cells[17][5], before.cells[17][2]);
+});
+
+test("a move that would replace a purl at its destination is rejected", () => {
+  const project = projectWithPurl(16, 2);
+  assert.throws(
+    () =>
+      prepareYokeIncreaseMove(
+        project,
+        0,
+        false,
+        source,
+      )({ row: 16, column: 2 }),
+    /this move would remove a purl/,
+  );
+  assert.equal(yokeChart(project).document.stitchActions![16][2], "purl");
+});
+
+for (const [label, target] of [
+  ["toward the hem", { row: 15, column: 5 }],
+  ["toward the neck", { row: 17, column: 5 }],
+  ["sideways", { row: 16, column: 2 }],
+] as const) {
+  test(`moving an increase ${label} rebuilds the no-stitch columns`, () => {
+    const project = prepareYokeIncreaseMove(
+      original.yoke!,
+      0,
+      true,
+      source,
+    )(target);
+    const next = readChartDocument(yokeDocument(project));
+    assert.equal(next.stitchActions![target.row][target.column], "m1l");
+    assert.equal(
+      next.stitchActions![target.row + 1][target.column],
+      "no-stitch",
+    );
+    assert.notEqual(next.stitchActions![source.row][source.column], "m1l");
+    assert.equal(original.stitchActions![source.row][source.column], "m1l");
+    assert.equal(project.cells[0].length, original.yoke!.cells[0].length);
+    assert.deepEqual(project.cells.at(-1), original.yoke!.cells.at(-1));
+    assert.equal(next.cells[0][20], original.cells[0][20]);
+  });
+}
+
+test("unsafe and out-of-bounds drops cannot change the plan", () => {
+  const project = original.yoke!;
+  const before = structuredClone(project);
+  const move = prepareYokeIncreaseMove(project, 0, true, source);
+  assert.throws(() => move({ row: 61, column: 5 }), /first round/);
+  assert.throws(() => move({ row: 16, column: 6 }), /already has an increase/);
+  assert.strictEqual(move(source), project);
+  assert.deepEqual(project, before);
+});
+
+test("moving in a selected group leaves other repeats untouched, including when mirrored", () => {
+  const project = mirrorYokeRepeat(original.yoke!, [1, 2]);
+  const target = { row: 15, column: 5 };
+  const next = prepareYokeIncreaseMove(project, 0, [0, 1], source)(target);
+  assert.equal(yokeChart(next, 0).document.stitchActions![15][5], "m1l");
+  assert.equal(yokeChart(next, 1).document.stitchActions![15][35], "m1r");
+  assert.deepEqual(yokeChart(next, 2).document, yokeChart(project, 2).document);
+  assert.deepEqual(yokeChart(next, 3).document, yokeChart(project, 3).document);
+  readChartDocument(yokeDocument(next));
+});
diff --git a/lib/yoke-move-increase.ts b/lib/yoke-move-increase.ts
new file mode 100644
index 0000000..33803b1
--- /dev/null
+++ b/lib/yoke-move-increase.ts
@@ -0,0 +1,152 @@
+import { yokeChart } from "./yoke-chart";
+import { isMirroredYokeSection } from "./yoke-mirror";
+import { yokeProgramFromProject } from "./yoke-program-from-project";
+import { withYokeProgram } from "./yoke-program-state";
+import { repeatTargets, type YokeRepeatScope } from "./yoke-repeat-scope";
+import { yokeRepeatNumber } from "./yoke-repeat-labels";
+import type { YokeProject } from "./yoke-project";
+import type { YokeOperation } from "./yoke-stitch-program";
+
+export type ChartPoint = { row: number; column: number };
+const isIncrease = (action: unknown): action is "m1l" | "m1r" =>
+  action === "m1l" || action === "m1r";
+
+/** A planned increase starts a new chart column. Only rebuild affected
+ * repeats, keeping surviving yarn colours at their original chart positions. */
+export function prepareYokeIncreaseMove(
+  project: YokeProject,
+  repeat: number,
+  scope: YokeRepeatScope,
+  from: ChartPoint,
+) {
+  const program = project.program ?? yokeProgramFromProject(project);
+  const count = program.startingCounts.length;
+  const sections = repeatTargets(scope, count, repeat);
+  if (!sections.length)
+    throw new Error("View a repeat in your edit selection.");
+  const height = program.rounds.length;
+  const revision = program.revision + 1;
+  const sourceMirrored = isMirroredYokeSection(program, repeat);
+  const sources = sections.map((section) => {
+    const label = `Repeat ${yokeRepeatNumber(section, count)}`;
+    const mirrored = isMirroredYokeSection(program, section);
+    const { document, maps } = yokeChart(project, section);
+    const columnAt = (column: number) =>
+      mirrored === sourceMirrored ? column : document.width - 1 - column;
+    const column = columnAt(from.column);
+    const actions = document.stitchActions!;
+    const action = actions[from.row]?.[column];
+    if (!isIncrease(action))
+      throw new Error(`${label} has no matching M1 at that position.`);
+    if (
+      program.rounds.some((row) =>
+        row[section].some(
+          (op) =>
+            op.action !== "knit" &&
+            op.action !== "purl" &&
+            !isIncrease(op.action),
+        ),
+      )
+    )
+      throw new Error(
+        `${label} has other shaping stitches. This tool currently moves increases in repeats with only knits, purls and M1s.`,
+      );
+    const birth = Array<number>(document.width).fill(0);
+    const directions = new Map<number, "m1l" | "m1r">();
+    actions.forEach((row, index) =>
+      row.forEach((symbol, c) => {
+        if (isIncrease(symbol)) {
+          birth[c] = height - 1 - index;
+          directions.set(c, symbol);
+        }
+      }),
+    );
+    const oldOps = maps.map(
+      (columns, round) =>
+        new Map(columns.map((c, i) => [c, program.rounds[round][section][i]])),
+    );
+    return {
+      section,
+      label,
+      column,
+      columnAt,
+      birth,
+      directions,
+      action,
+      oldOps,
+    };
+  });
+
+  return (to: ChartPoint) => {
+    if (to.row === from.row && to.column === from.column) return project;
+    const endRound = height - 1 - to.row;
+    if (endRound < 1 || endRound >= height)
+      throw new Error("Choose a cell above the first round.");
+    const rounds = program.rounds.map((round) => [...round]);
+    for (const source of sources) {
+      const { section, label, column, columnAt, oldOps, action } = source;
+      const target = columnAt(to.column);
+      if (target < 0 || target >= source.birth.length)
+        throw new Error(`${label} has no column at that position.`);
+      if (target !== column && source.birth[target] !== 0)
+        throw new Error(`${label} already has an increase in that column.`);
+      const birth = [...source.birth];
+      const directions = new Map(source.directions);
+      birth[column] = 0;
+      directions.delete(column);
+      birth[target] = endRound;
+      directions.set(target, action);
+      const moved = oldOps[height - 1 - from.row].get(column)!;
+      rounds.forEach((round, r) => {
+        const oldTarget = oldOps[r].get(target);
+        const displacedPurl =
+          r < endRound &&
+          column !== target &&
+          !oldOps[r].has(column) &&
+          oldTarget?.action === "purl"
+            ? oldTarget
+            : undefined;
+        if (r <= endRound && oldTarget?.action === "purl" && !displacedPurl)
+          throw new Error(
+            `Round ${r + 1}, ${label.toLowerCase()}: this move would remove a purl. Choose a different cell.`,
+          );
+        round[section] = birth.flatMap((firstRound, c): YokeOperation[] => {
+          if (firstRound > r) return [];
+          const old =
+            oldOps[r].get(c) ?? (c === column ? displacedPurl : undefined);
+          const donor =
+            old ?? (c === column ? oldOps[r].get(target) : undefined);
+          const isMoved = c === target && r === endRound;
+          const displayColor = isMoved ? moved.displayColor : old?.displayColor;
+          return [
+            {
+              id:
+                old?.id ??
+                `m${revision.toString(36)}.${r.toString(36)}.${section.toString(36)}.${c.toString(36)}`,
+              action:
+                firstRound > 0 && firstRound === r
+                  ? directions.get(c)!
+                  : old?.action === "purl"
+                    ? "purl"
+                    : "knit",
+              color: donor?.color ?? (isMoved ? moved.color : 0),
+              ...(displayColor ? { displayColor } : {}),
+            },
+          ];
+        });
+      });
+    }
+    const next = withYokeProgram(project, { ...program, revision, rounds });
+    for (const { section, columnAt, action, label } of sources) {
+      if (
+        yokeChart(next, section).document.stitchActions?.[to.row]?.[
+          columnAt(to.column)
+        ] !== action
+      )
+        throw new Error(
+          `${label}: the increase cannot be placed in that exact cell.`,
+        );
+    }
+    return next;
+  };
+}