diff --git a/docs/superpowers/plans/2026-08-05-sync-base.md b/docs/superpowers/plans/2026-08-05-sync-base.md
new file mode 100644
index 0000000..909e683
--- /dev/null
+++ b/docs/superpowers/plans/2026-08-05-sync-base.md
@@ -0,0 +1,1198 @@
+# E2 — `ccam lanes sync-base` Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** `ccam lanes sync-base` exists as a real, working command — the migration-collision preflight (`--check`), the one sanctioned merge (`origin/development` into a feature branch), and its conflict-resolution follow-up (`--continue`) — so `.claude/skills/ship-feature-lane/SKILL.md`'s Stage 2/8/12 references to it stop being "later task" placeholders.
+
+**Architecture:** One new core module (`server/lib/lane-sync.js`, pure git operations via `worktree.js`'s existing `git()` helper), two new profile declarations (`MIGRATIONS_DIR`, `GENERATED_MERGE_PATHS`), one new synchronous route (`POST /:id/sync-base`), one new CLI subcommand, and a `SKILL.md` edit that turns three "if it exists yet" conditionals into real instructions.
+
+**Tech Stack:** Existing git helper (`server/lib/worktree.js`'s `git(cwd, args)`, execFile-based), existing profile system (`server/lib/lane-profile.js`), existing hook runner (`runHook`, already used for `regen`), existing lane lock (`server/lib/lane-lock.js`).
+
+## Global Constraints
+
+- Every applicable source file MUST start with the project's authorship header — verify with `bash .claude/skills/file-headers/scripts/check-headers.sh`.
+- **Never build a git command as a shell string.** Every git call in `lane-sync.js` goes through `worktree.js`'s `git(cwd, args)` (execFile with an argument array). This is a binding project rule, not a style preference.
+- **`sync-base` never writes a lane's `stage`, `status`, or `notes`.** It returns a structured result; the caller (the skill, or a human via the CLI) decides what a collision or conflict means for the lane's declared stage.
+- `MIGRATIONS_DIR` and `GENERATED_MERGE_PATHS` are off-by-default declarations — a profile that never declares them sees zero behavior change, same pattern every other optional `DEFAULTS` entry in `lane-profile.js` already follows.
+- The integration branch is hardcoded to `"development"` (a module-level constant in `lane-sync.js`, not a new profile setting) — `SKILL.md`'s whole pipeline already hardcodes this branch name throughout; making it configurable here would be scope creep this task doesn't need.
+- Run `npm run test:server` (full suite) plus `bash .claude/skills/file-headers/scripts/check-headers.sh` before every commit.
+- Never use `git add -A`. Stage exactly the files each task names.
+- This repo's existing route tests for `server/routes/lanes.js` are all exercised at the `server/lib/*` layer (no HTTP-level test harness for lane routes exists anywhere in this repo) — Task 2's unit tests are the verification for the route's logic; Task 3 adds only what the route layer itself does that the lib doesn't (request parsing, lock acquisition, error-code mapping), covered by targeted assertions against the route handler, not a spun-up HTTP server.
+
+---
+
+### Task 1: Profile declarations — `MIGRATIONS_DIR`, `GENERATED_MERGE_PATHS`
+
+**Files:**
+- Modify: `server/lib/lane-profile.js` (`DEFAULTS`, `resolveProfile`)
+- Test: `server/__tests__/lane-profile.test.js`
+
+**Interfaces:**
+- Produces: `resolveProfile(lane).generatedMergePaths` — `string[]`, parsed from `GENERATED_MERGE_PATHS` the same way `ports`/`laneDirs` are already parsed (via the existing `splitList` helper). `resolveProfile(lane).env.MIGRATIONS_DIR` — plain string, used as-is (not a list).
+
+- [ ] **Step 1: Write the failing test**
+
+Add to `server/__tests__/lane-profile.test.js` (it already has `writeProfile`/`makeLane` helpers — reuse them, don't redefine):
+
+```js
+describe("resolveProfile — E2 declarations", () => {
+  it("defaults MIGRATIONS_DIR to empty and GENERATED_MERGE_PATHS to an empty array", () => {
+    const lane = makeLane();
+    writeProfile(lane.cwd, "PORTS=api\n");
+    const profile = profileLib.resolveProfile(lanesLib.getLane(lane.id));
+    assert.equal(profile.env.MIGRATIONS_DIR, "");
+    assert.deepEqual(profile.generatedMergePaths, []);
+  });
+
+  it("parses declared MIGRATIONS_DIR and GENERATED_MERGE_PATHS", () => {
+    const lane = makeLane();
+    writeProfile(
+      lane.cwd,
+      'PORTS=api\nMIGRATIONS_DIR="db/migrations"\nGENERATED_MERGE_PATHS="api/openapi.json api/client.ts"\n'
+    );
+    const profile = profileLib.resolveProfile(lanesLib.getLane(lane.id));
+    assert.equal(profile.env.MIGRATIONS_DIR, "db/migrations");
+    assert.deepEqual(profile.generatedMergePaths, ["api/openapi.json", "api/client.ts"]);
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `node --test server/__tests__/lane-profile.test.js`
+Expected: FAIL — `profile.generatedMergePaths` is `undefined` (deepEqual against `[]` fails), and `MIGRATIONS_DIR`/`GENERATED_MERGE_PATHS` aren't recognized declarations yet (they parse fine as arbitrary keys via `parseEnvFile`, but the *default* for an undeclared `MIGRATIONS_DIR` won't exist in `DEFAULTS` — the first assertion in test 1 fails with `undefined !== ""`).
+
+- [ ] **Step 3: Implement**
+
+In `server/lib/lane-profile.js`, add to `DEFAULTS` (after the existing `QC_BOOT_ENV` entry, `lane-profile.js:78`):
+
+```js
+  QC_BOOT_ENV: "",
+  // E2: repo-relative path to a numbered-migrations directory (e.g.
+  // "db/migrations"), consumed by sync-base's collision preflight. Empty =
+  // off, same DEFAULTS pattern as every declaration above.
+  MIGRATIONS_DIR: "",
+  // E2: space-separated repo-relative paths given a keep-ours merge driver
+  // by sync-base's merge mode and regenerated post-merge by the profile's
+  // `regen` hook (e.g. an OpenAPI contract + its generated client). Empty =
+  // off — no driver installed, no regen fold-in attempted.
+  GENERATED_MERGE_PATHS: "",
+});
+```
+
+In `resolveProfile`'s return object (`lane-profile.js:170-176`), add `generatedMergePaths` alongside the existing `ports`/`laneDirs`:
+
+```js
+    return {
+      dir,
+      env,
+      hooks,
+      ports: splitList(env.PORTS),
+      laneDirs: splitList(env.LANE_DIRS),
+      generatedMergePaths: splitList(env.GENERATED_MERGE_PATHS),
+    };
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `node --test server/__tests__/lane-profile.test.js`
+Expected: PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add server/lib/lane-profile.js server/__tests__/lane-profile.test.js
+git commit -m "feat(lanes): add MIGRATIONS_DIR + GENERATED_MERGE_PATHS profile declarations (E2)"
+```
+
+---
+
+### Task 2: `server/lib/lane-sync.js` — the git core
+
+**Files:**
+- Create: `server/lib/lane-sync.js`
+- Test: `server/__tests__/lane-sync.test.js`
+- Modify (read-only reference, no changes needed): `server/lib/worktree.js` (`git` is already exported — confirmed at `worktree.js:642-660`, nothing to add there)
+
+**Interfaces:**
+- Consumes: `git(cwd, args) => Promise<{stdout, stderr}>` from `require("./worktree")`; `runHook(lane, profile, name, args, options) => Promise<{code, output}>` from `require("./lane-profile")` (never throws on a non-zero hook exit).
+- Produces:
+  - `checkSync(lane, profile, branch?) => Promise<{code: 0|5, devDelta?: string[]|null, overlap?: string[]|null, collisions?: Array<{file, collidesWith, suggestion}>}>`
+  - `mergeSync(lane, profile, branch?) => Promise<{code: 0|4|5, conflictedFiles?: string[], collisions?: Array<{file, collidesWith, suggestion}>}>`
+  - `continueSync(lane, profile, branch?) => Promise<{code: 0}>` (throws `EBADBRANCH`/`EUNRESOLVED`/`EMERGEUNCOMMITTED` on a precondition violation)
+  - All three accept `lane` as `{cwd, ...}` (only `cwd` is read) and `profile` as `resolveProfile()`'s return shape (`env`, `hooks`, `generatedMergePaths`).
+  - Thrown errors carry `.code` — `EBADBRANCH` (branch is `development`/`main`, or doesn't exist).
+
+- [ ] **Step 1: Write the failing tests — fixture + branch guard + collision check**
+
+Create `server/__tests__/lane-sync.test.js`:
+
+```js
+/**
+ * @file Tests for server/lib/lane-sync.js against a REAL git fixture: a bare
+ * "origin", a lane clone, and a second clone acting as another lane that
+ * pushes to origin/development independently. Mirrors the fixture shape of
+ * Shipyard's own lane-sync-dev.sh test (test_sync_dev.sh) — collision
+ * detection, clean merges, and conflicts are git's own behavior, so a mocked
+ * git would only test our idea of git.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+const { describe, it, before, after, beforeEach } = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { execFileSync } = require("node:child_process");
+
+const ROOT = fs.mkdtempSync(path.join(os.tmpdir(), "ccam-sync-"));
+
+const laneSync = require("../lib/lane-sync");
+
+const ORIGIN = path.join(ROOT, "origin.git");
+const LANE_DIR = path.join(ROOT, "lane");
+const PUSHER_DIR = path.join(ROOT, "pusher");
+
+const g = (cwd, ...args) => {
+  const env = { ...process.env };
+  delete env.GIT_DIR;
+  delete env.GIT_WORK_TREE;
+  delete env.GIT_INDEX_FILE;
+  delete env.GIT_COMMON_DIR;
+  delete env.GIT_OBJECT_DIRECTORY;
+  delete env.GIT_ALTERNATE_OBJECT_DIRECTORIES;
+  delete env.GIT_PREFIX;
+  delete env.GIT_NAMESPACE;
+  delete env.GIT_CONFIG_PARAMETERS;
+  env.GIT_TERMINAL_PROMPT = "0";
+  return execFileSync("git", args, { cwd, encoding: "utf8", env });
+};
+const gc = (cwd, ...args) => g(cwd, "-c", "user.email=t@h", "-c", "user.name=t", ...args);
+
+function freshFixture() {
+  fs.rmSync(ROOT, { recursive: true, force: true });
+  fs.mkdirSync(ROOT, { recursive: true });
+  g(ROOT, "init", "-q", "--bare", ORIGIN);
+
+  const seed = path.join(ROOT, "seed");
+  g(ROOT, "init", "-q", "-b", "development", seed);
+  fs.mkdirSync(path.join(seed, "db", "migrations"), { recursive: true });
+  fs.writeFileSync(path.join(seed, "db", "migrations", "001_init.sql"), "create table a;\n");
+  fs.writeFileSync(path.join(seed, "README.md"), "hello\n");
+  gc(seed, "add", "-A");
+  gc(seed, "commit", "-qm", "init");
+  gc(seed, "remote", "add", "origin", ORIGIN);
+  gc(seed, "push", "-q", "origin", "development");
+  g(ORIGIN, "symbolic-ref", "HEAD", "refs/heads/development");
+
+  g(ROOT, "clone", "-q", ORIGIN, LANE_DIR);
+  g(ROOT, "clone", "-q", ORIGIN, PUSHER_DIR);
+
+  gc(LANE_DIR, "checkout", "-qb", "feat/thing");
+}
+
+function lane() {
+  return { cwd: LANE_DIR };
+}
+
+function profile(over = {}) {
+  return {
+    env: { MIGRATIONS_DIR: "db/migrations", GENERATED_MERGE_PATHS: "" },
+    generatedMergePaths: [],
+    hooks: new Set(),
+    ...over,
+  };
+}
+
+before(freshFixture);
+after(() => fs.rmSync(ROOT, { recursive: true, force: true }));
+
+describe("lane-sync guards", () => {
+  it("refuses to run on development or main", async () => {
+    await assert.rejects(
+      () => laneSync.checkSync(lane(), profile(), "development"),
+      (e) => e.code === "EBADBRANCH" && /feature branch/.test(e.message)
+    );
+    await assert.rejects(() => laneSync.mergeSync(lane(), profile(), "main"), {
+      code: "EBADBRANCH",
+    });
+  });
+
+  it("refuses a branch that doesn't exist", async () => {
+    await assert.rejects(() => laneSync.checkSync(lane(), profile(), "feat/nope"), {
+      code: "EBADBRANCH",
+    });
+  });
+});
+
+describe("lane-sync --check: migration collision", () => {
+  it("detects a collision and suggests the next free number", () => {
+    fs.writeFileSync(
+      path.join(LANE_DIR, "db", "migrations", "002_a.sql"),
+      "create table x;\n"
+    );
+    gc(LANE_DIR, "add", "-A");
+    gc(LANE_DIR, "commit", "-qm", "feat: add x");
+
+    fs.writeFileSync(
+      path.join(PUSHER_DIR, "db", "migrations", "002_b.sql"),
+      "create table y;\n"
+    );
+    gc(PUSHER_DIR, "add", "-A");
+    gc(PUSHER_DIR, "commit", "-qm", "other lane");
+    gc(PUSHER_DIR, "push", "-q", "origin", "development");
+
+    return laneSync.checkSync(lane(), profile(), "feat/thing").then((result) => {
+      assert.equal(result.code, 5);
+      assert.equal(result.collisions.length, 1);
+      assert.match(result.collisions[0].file, /002_a\.sql$/);
+      assert.match(result.collisions[0].suggestion, /^003_a\.sql$/);
+    });
+  });
+
+  it("passes clean after the renumber and reports the upstream delta", async () => {
+    gc(LANE_DIR, "mv", "db/migrations/002_a.sql", "db/migrations/003_a.sql");
+    gc(LANE_DIR, "commit", "-qm", "renumber migration");
+
+    const result = await laneSync.checkSync(lane(), profile(), "feat/thing");
+    assert.equal(result.code, 0);
+    assert.equal(result.devDelta.length, 1);
+    assert.match(result.devDelta[0], /002_b\.sql$/);
+    assert.deepEqual(result.overlap, []);
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `node --test server/__tests__/lane-sync.test.js`
+Expected: FAIL — `require("../lib/lane-sync")` throws `MODULE_NOT_FOUND`.
+
+- [ ] **Step 3: Implement `lane-sync.js` — guards, collision check, dev-delta report, `checkSync`**
+
+Create `server/lib/lane-sync.js`:
+
+```js
+/**
+ * @file The dev-based-flow safety primitive: the ONE sanctioned merge in the
+ * ship-feature-lane pipeline, origin/development INTO a lane's feature
+ * branch, gated by a migration-number collision preflight. Port of
+ * Shipyard's lane-sync-dev.sh. Pure git — every operation goes through
+ * worktree.js's git() execFile wrapper, never a shell string.
+ * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { git } = require("./worktree");
+const { runHook } = require("./lane-profile");
+
+/** The PR base branch. Hardcoded — the whole ship-feature-lane pipeline
+ *  already hardcodes this name throughout SKILL.md; a configurable version
+ *  would be scope this task doesn't need. */
+const INTEGRATION_BRANCH = "development";
+
+function badBranch(message) {
+  return Object.assign(new Error(message), { code: "EBADBRANCH" });
+}
+
+/** The branch to operate on: the caller's explicit choice, or the lane's
+ *  current HEAD when omitted (mirrors the source script's own fallback). */
+async function resolveBranch(cwd, branch) {
+  if (branch) return branch;
+  const result = await git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  return result.stdout.trim();
+}
+
+function assertFeatureBranch(branch) {
+  if (branch === INTEGRATION_BRANCH || branch === "main") {
+    throw badBranch(
+      `branch is '${branch}' — sync-base works on a feature branch (pass it explicitly)`
+    );
+  }
+}
+
+async function assertBranchExists(cwd, branch) {
+  try {
+    await git(cwd, ["rev-parse", "--verify", "--quiet", branch]);
+  } catch {
+    throw badBranch(`feature branch '${branch}' not found`);
+  }
+}
+
+/**
+ * Migration-number collision guard: two lanes independently add NNN_* files
+ * with the same number under MIGRATIONS_DIR — git merges both without
+ * conflict, and the collision only surfaces as red CI on development AFTER a
+ * human merges the PR. Detected from refs alone, before anything is merged.
+ */
+async function collisionCheck(cwd, migrationsDir, branch) {
+  if (!migrationsDir) return [];
+
+  const addedResult = await git(cwd, [
+    "diff",
+    "--name-only",
+    "--diff-filter=A",
+    `origin/${INTEGRATION_BRANCH}...${branch}`,
+    "--",
+    migrationsDir,
+  ]);
+  const added = addedResult.stdout
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+  if (!added.length) return [];
+
+  const treeResult = await git(cwd, [
+    "ls-tree",
+    "-r",
+    "--name-only",
+    `origin/${INTEGRATION_BRANCH}`,
+    "--",
+    migrationsDir,
+  ]);
+  const devMigrations = treeResult.stdout
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => /\/\d+_[^/]+$/.test(line));
+
+  let maxNum = 0;
+  for (const file of devMigrations) {
+    const m = /\/(\d+)_[^/]+$/.exec(file);
+    if (m) maxNum = Math.max(maxNum, parseInt(m[1], 10));
+  }
+  let nextNum = maxNum + 1;
+
+  const collisions = [];
+  for (const file of added) {
+    const base = path.basename(file);
+    const m = /^(\d+)_/.exec(base);
+    if (!m) continue;
+    const num = m[1];
+    const clash = devMigrations.find((f) => f.includes(`/${num}_`));
+    if (!clash) continue;
+    const suggestion = `${String(nextNum).padStart(3, "0")}_${base.replace(/^\d+_/, "")}`;
+    collisions.push({ file, collidesWith: clash, suggestion });
+    nextNum += 1;
+  }
+  return collisions;
+}
+
+/** What moved on origin/development since branch's merge-base, and whether
+ *  that delta touches branch's own changed files. Informational. */
+async function devDeltaReport(cwd, branch, generatedPaths) {
+  let mergeBase = "";
+  try {
+    const result = await git(cwd, ["merge-base", `origin/${INTEGRATION_BRANCH}`, branch]);
+    mergeBase = result.stdout.trim();
+  } catch {
+    mergeBase = "";
+  }
+  if (!mergeBase) return { devDelta: null, overlap: null };
+
+  const filterGenerated = (files) =>
+    generatedPaths.length ? files.filter((f) => !generatedPaths.includes(f)) : files;
+  const namesOnly = (stdout) =>
+    stdout
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean);
+
+  const devDiff = await git(cwd, ["diff", "--name-only", mergeBase, `origin/${INTEGRATION_BRANCH}`]);
+  const delta = filterGenerated(namesOnly(devDiff.stdout));
+
+  const featDiff = await git(cwd, ["diff", "--name-only", mergeBase, branch]);
+  const featFiles = new Set(filterGenerated(namesOnly(featDiff.stdout)));
+
+  const overlap = delta.filter((f) => featFiles.has(f));
+  return { devDelta: delta, overlap };
+}
+
+/** Read-only preflight: fetch + collision check + dev-delta report. Merges
+ *  nothing. */
+async function checkSync(lane, profile, branchArg) {
+  const branch = await resolveBranch(lane.cwd, branchArg);
+  assertFeatureBranch(branch);
+  await assertBranchExists(lane.cwd, branch);
+  await git(lane.cwd, ["fetch", "origin", "--prune"]);
+
+  const collisions = await collisionCheck(lane.cwd, profile.env.MIGRATIONS_DIR, branch);
+  if (collisions.length) return { code: 5, collisions };
+
+  const { devDelta, overlap } = await devDeltaReport(lane.cwd, branch, profile.generatedMergePaths);
+  return { code: 0, devDelta, overlap };
+}
+
+module.exports = {
+  INTEGRATION_BRANCH,
+  checkSync,
+};
+```
+
+(`mergeSync`/`continueSync` are added in Steps 5–8 below — this step only needs `checkSync` to make the current tests pass.)
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `node --test server/__tests__/lane-sync.test.js`
+Expected: PASS (all 4 tests so far — the two guard tests and the two `--check` tests).
+
+- [ ] **Step 5: Write the failing tests — clean merge, merge-driver setup, regen fold-in**
+
+Append to `server/__tests__/lane-sync.test.js`:
+
+```js
+describe("lane-sync merge: clean merge lands upstream on the feature branch", () => {
+  it("merges origin/development into the feature branch as a merge commit", async () => {
+    const result = await laneSync.mergeSync(lane(), profile(), "feat/thing");
+    assert.equal(result.code, 0);
+    assert.equal(g(LANE_DIR, "rev-parse", "--abbrev-ref", "HEAD").trim(), "feat/thing");
+    assert.doesNotThrow(() => g(LANE_DIR, "rev-parse", "-q", "--verify", "HEAD^2"));
+    assert.ok(fs.existsSync(path.join(LANE_DIR, "db", "migrations", "002_b.sql")));
+  });
+});
+
+describe("lane-sync merge: generated-file merge driver + regen fold-in", () => {
+  const GEN_DIR = path.join(ROOT, "gen-fixture");
+  const GEN_ORIGIN = path.join(ROOT, "gen-origin.git");
+  const GEN_LANE = path.join(ROOT, "gen-lane");
+  const GEN_PUSHER = path.join(ROOT, "gen-pusher");
+
+  before(() => {
+    fs.mkdirSync(GEN_DIR, { recursive: true });
+    g(GEN_DIR, "init", "-q", "--bare", GEN_ORIGIN);
+    const seed = path.join(GEN_DIR, "seed");
+    g(GEN_DIR, "init", "-q", "-b", "development", seed);
+    fs.writeFileSync(path.join(seed, "api", "openapi.json"), '{"v":1}\n', { flag: "w" });
+    fs.mkdirSync(path.join(seed, "api"), { recursive: true });
+    fs.writeFileSync(path.join(seed, "api", "openapi.json"), '{"v":1}\n');
+    gc(seed, "add", "-A");
+    gc(seed, "commit", "-qm", "init");
+    gc(seed, "remote", "add", "origin", GEN_ORIGIN);
+    gc(seed, "push", "-q", "origin", "development");
+    g(GEN_ORIGIN, "symbolic-ref", "HEAD", "refs/heads/development");
+
+    g(GEN_DIR, "clone", "-q", GEN_ORIGIN, GEN_LANE);
+    g(GEN_DIR, "clone", "-q", GEN_ORIGIN, GEN_PUSHER);
+    gc(GEN_LANE, "checkout", "-qb", "feat/gen");
+
+    // The lane's own change to the generated file (would conflict without
+    // the keep-ours driver).
+    fs.writeFileSync(path.join(GEN_LANE, "api", "openapi.json"), '{"v":2,"branch":"feat"}\n');
+    gc(GEN_LANE, "add", "-A");
+    gc(GEN_LANE, "commit", "-qm", "feat: touches the contract");
+
+    // Upstream's own change to the same generated file.
+    fs.writeFileSync(path.join(GEN_PUSHER, "api", "openapi.json"), '{"v":2,"branch":"dev"}\n');
+    gc(GEN_PUSHER, "add", "-A");
+    gc(GEN_PUSHER, "commit", "-qm", "dev: also touches the contract");
+    gc(GEN_PUSHER, "push", "-q", "origin", "development");
+
+    // A regen hook the fold-in step will run.
+    const profileDir = path.join(GEN_LANE, ".ccam", "profile");
+    fs.mkdirSync(path.join(profileDir, "hooks"), { recursive: true });
+    fs.writeFileSync(path.join(profileDir, "profile.env"), "PORTS=api\n");
+    fs.writeFileSync(
+      path.join(profileDir, "hooks", "regen.sh"),
+      '#!/usr/bin/env bash\nset -euo pipefail\necho \'{"v":3,"regenerated":true}\' > "$LANE_DIR/api/openapi.json"\n'
+    );
+    fs.chmodSync(path.join(profileDir, "hooks", "regen.sh"), 0o755);
+  });
+
+  function genProfile() {
+    return {
+      env: { MIGRATIONS_DIR: "", GENERATED_MERGE_PATHS: "api/openapi.json" },
+      generatedMergePaths: ["api/openapi.json"],
+      hooks: new Set(["regen"]),
+      dir: path.join(GEN_LANE, ".ccam", "profile"),
+    };
+  }
+
+  it("installs a keep-ours driver so the generated file never conflicts, then folds regen output into the merge commit", async () => {
+    const result = await laneSync.mergeSync({ cwd: GEN_LANE, slot: 999, id: 999 }, genProfile(), "feat/gen");
+    assert.equal(result.code, 0);
+    const contents = fs.readFileSync(path.join(GEN_LANE, "api", "openapi.json"), "utf8");
+    assert.match(contents, /"regenerated":true/);
+    // The regen output landed IN the merge commit, not a separate one.
+    assert.doesNotThrow(() => g(GEN_LANE, "rev-parse", "-q", "--verify", "HEAD^2"));
+    const parents = g(GEN_LANE, "log", "-1", "--format=%P").trim().split(" ");
+    assert.equal(parents.length, 2);
+  });
+});
+```
+
+- [ ] **Step 6: Run tests to verify they fail**
+
+Run: `node --test server/__tests__/lane-sync.test.js`
+Expected: FAIL — `laneSync.mergeSync is not a function`.
+
+- [ ] **Step 7: Implement `mergeSync` + the merge-driver setup + regen fold-in**
+
+Append to `server/lib/lane-sync.js`, before `module.exports`:
+
+```js
+/** The worktree-private git dir (HEAD, index, MERGE_HEAD live here — distinct
+ *  from the shared common dir below). Resolved fresh each call: cheap, and a
+ *  cached value would go stale the moment a lane's slot/worktree changes. */
+async function gitDir(cwd) {
+  const result = await git(cwd, ["rev-parse", "--git-dir"]);
+  const dir = result.stdout.trim();
+  return path.isAbsolute(dir) ? dir : path.join(cwd, dir);
+}
+
+/** The dir shared across every worktree of a repo — where info/attributes
+ *  and git config live. For a plain (non-worktree) clone this is the same
+ *  as gitDir(); for a `git worktree add` lane it is the source repo's own
+ *  .git, so the merge driver is configured once per repository, not once
+ *  per lane. */
+async function commonGitDir(cwd) {
+  const result = await git(cwd, ["rev-parse", "--git-common-dir"]);
+  const dir = result.stdout.trim();
+  return path.isAbsolute(dir) ? dir : path.join(cwd, dir);
+}
+
+async function unmergedFiles(cwd) {
+  const result = await git(cwd, ["ls-files", "-u"]);
+  const files = new Set();
+  for (const line of result.stdout.split("\n")) {
+    const tab = line.indexOf("\t");
+    if (tab > -1) files.add(line.slice(tab + 1));
+  }
+  return [...files];
+}
+
+/** Generated artifacts (an OpenAPI contract, its generated client, ...) must
+ *  never be hand-merged: a keep-ours driver (`true` exits 0 -> keep our
+ *  side, no conflict) via the clone-local attributes file, idempotent every
+ *  call — same "idempotent, never automatic" shape this repo's proof-link
+ *  already established. */
+async function setupMergeDriver(cwd, generatedPaths) {
+  if (!generatedPaths.length) return;
+  await git(cwd, ["config", "merge.ccam-generated.driver", "true"]);
+  await git(cwd, [
+    "config",
+    "merge.ccam-generated.name",
+    "keep ours; regenerated post-merge by the profile regen hook",
+  ]);
+
+  const infoDir = path.join(await commonGitDir(cwd), "info");
+  fs.mkdirSync(infoDir, { recursive: true });
+  const attrPath = path.join(infoDir, "attributes");
+  const existing = fs.existsSync(attrPath) ? fs.readFileSync(attrPath, "utf8") : "";
+  const lines = new Set(existing.split("\n").filter(Boolean));
+  let changed = false;
+  for (const gp of generatedPaths) {
+    const line = `${gp} merge=ccam-generated`;
+    if (!lines.has(line)) {
+      lines.add(line);
+      changed = true;
+    }
+  }
+  if (changed) fs.writeFileSync(attrPath, [...lines].join("\n") + "\n");
+}
+
+/** Regenerate generated artifacts from the just-synced tree and fold them
+ *  into the merge commit (or, on the --continue path, a follow-up commit).
+ *  A no-op when nothing changed. */
+async function regenFold(lane, profile, generatedPaths) {
+  if (!generatedPaths.length || !profile.hooks.has("regen")) return;
+  await runHook(lane, profile, "regen", []);
+  try {
+    await git(lane.cwd, ["add", "--", ...generatedPaths]);
+  } catch {
+    // A generated path that doesn't exist yet on this branch is fine —
+    // nothing to stage for it.
+  }
+  const staged = await git(lane.cwd, ["diff", "--cached", "--name-only"]);
+  if (!staged.stdout.trim()) return;
+
+  let isMergeCommit = true;
+  try {
+    await git(lane.cwd, ["rev-parse", "-q", "--verify", "HEAD^2"]);
+  } catch {
+    isMergeCommit = false;
+  }
+  if (isMergeCommit) {
+    await git(lane.cwd, ["commit", "--amend", "--no-edit"]);
+  } else {
+    await git(lane.cwd, ["commit", "-m", "chore: regenerate artifacts after dev sync"]);
+  }
+}
+
+/** The one sanctioned merge: origin/development INTO the feature branch. */
+async function mergeSync(lane, profile, branchArg) {
+  const branch = await resolveBranch(lane.cwd, branchArg);
+  assertFeatureBranch(branch);
+  await assertBranchExists(lane.cwd, branch);
+  await git(lane.cwd, ["fetch", "origin", "--prune"]);
+
+  const generatedPaths = profile.generatedMergePaths;
+  await setupMergeDriver(lane.cwd, generatedPaths);
+
+  const collisions = await collisionCheck(lane.cwd, profile.env.MIGRATIONS_DIR, branch);
+  if (collisions.length) return { code: 5, collisions };
+
+  await git(lane.cwd, ["checkout", "--quiet", branch]);
+
+  try {
+    await git(lane.cwd, ["merge", "--no-edit", `origin/${INTEGRATION_BRANCH}`]);
+  } catch (err) {
+    const conflicted = await unmergedFiles(lane.cwd);
+    const mergeHeadPath = path.join(await gitDir(lane.cwd), "MERGE_HEAD");
+    if (conflicted.length && fs.existsSync(mergeHeadPath)) {
+      return { code: 4, conflictedFiles: conflicted };
+    }
+    throw err;
+  }
+
+  // rerere may have auto-resolved every conflict but left the merge
+  // uncommitted — finish it.
+  const mergeHeadPath = path.join(await gitDir(lane.cwd), "MERGE_HEAD");
+  if (fs.existsSync(mergeHeadPath) && !(await unmergedFiles(lane.cwd)).length) {
+    await git(lane.cwd, ["commit", "--no-edit"]);
+  }
+
+  await regenFold(lane, profile, generatedPaths);
+  return { code: 0 };
+}
+```
+
+Update `module.exports` at the bottom of `lane-sync.js`:
+
+```js
+module.exports = {
+  INTEGRATION_BRANCH,
+  checkSync,
+  mergeSync,
+};
+```
+
+- [ ] **Step 8: Run tests to verify they pass**
+
+Run: `node --test server/__tests__/lane-sync.test.js`
+Expected: PASS.
+
+- [ ] **Step 9: Write the failing tests — conflict left in place, `--continue`**
+
+Append to `server/__tests__/lane-sync.test.js`:
+
+```js
+describe("lane-sync merge: conflict is left in place, --continue finishes it", () => {
+  it("exits with code 4 and leaves MERGE_HEAD in place on a real conflict", async () => {
+    fs.writeFileSync(path.join(LANE_DIR, "README.md"), "feature words\n");
+    gc(LANE_DIR, "add", "-A");
+    gc(LANE_DIR, "commit", "-qm", "feat: readme");
+
+    fs.writeFileSync(path.join(PUSHER_DIR, "README.md"), "upstream words\n");
+    gc(PUSHER_DIR, "add", "-A");
+    gc(PUSHER_DIR, "commit", "-qm", "other readme");
+    gc(PUSHER_DIR, "push", "-q", "origin", "development");
+
+    const result = await laneSync.mergeSync(lane(), profile(), "feat/thing");
+    assert.equal(result.code, 4);
+    assert.deepEqual(result.conflictedFiles, ["README.md"]);
+    assert.ok(fs.existsSync(path.join(LANE_DIR, ".git", "MERGE_HEAD")));
+  });
+
+  it("--continue refuses while conflicts are unresolved", async () => {
+    await assert.rejects(() => laneSync.continueSync(lane(), profile(), "feat/thing"), {
+      code: "EUNRESOLVED",
+    });
+  });
+
+  it("--continue refuses while the merge is resolved but not committed", async () => {
+    fs.writeFileSync(path.join(LANE_DIR, "README.md"), "merged words\n");
+    gc(LANE_DIR, "add", "README.md");
+    await assert.rejects(() => laneSync.continueSync(lane(), profile(), "feat/thing"), {
+      code: "EMERGEUNCOMMITTED",
+    });
+  });
+
+  it("--continue finishes after the conflict is resolved and committed", async () => {
+    gc(LANE_DIR, "commit", "-q", "--no-edit");
+    const result = await laneSync.continueSync(lane(), profile(), "feat/thing");
+    assert.equal(result.code, 0);
+    assert.equal(g(LANE_DIR, "rev-parse", "--abbrev-ref", "HEAD").trim(), "feat/thing");
+  });
+});
+```
+
+- [ ] **Step 10: Run tests to verify they fail**
+
+Run: `node --test server/__tests__/lane-sync.test.js`
+Expected: FAIL — `laneSync.continueSync is not a function`.
+
+- [ ] **Step 11: Implement `continueSync`**
+
+Append to `server/lib/lane-sync.js`, before `module.exports`:
+
+```js
+/** Finish a sync after the session resolved a conflicted merge and
+ *  committed it. Stateless — reads the lane's own git state directly rather
+ *  than trusting a separate flag, so it can never disagree with reality. */
+async function continueSync(lane, profile, branchArg) {
+  const branch = await resolveBranch(lane.cwd, branchArg);
+
+  const current = (await git(lane.cwd, ["rev-parse", "--abbrev-ref", "HEAD"])).stdout.trim();
+  if (current !== branch) {
+    throw badBranch(`--continue: lane is not on '${branch}' (currently on '${current}')`);
+  }
+
+  const unresolved = await unmergedFiles(lane.cwd);
+  if (unresolved.length) {
+    throw Object.assign(
+      new Error(`--continue: unresolved conflicts remain: ${unresolved.join(", ")}`),
+      { code: "EUNRESOLVED" }
+    );
+  }
+
+  const mergeHeadPath = path.join(await gitDir(lane.cwd), "MERGE_HEAD");
+  if (fs.existsSync(mergeHeadPath)) {
+    throw Object.assign(
+      new Error("--continue: merge not committed yet — git commit --no-edit"),
+      { code: "EMERGEUNCOMMITTED" }
+    );
+  }
+
+  await regenFold(lane, profile, profile.generatedMergePaths);
+  return { code: 0 };
+}
+```
+
+Update `module.exports`:
+
+```js
+module.exports = {
+  INTEGRATION_BRANCH,
+  checkSync,
+  mergeSync,
+  continueSync,
+};
+```
+
+- [ ] **Step 12: Run tests to verify they pass**
+
+Run: `node --test server/__tests__/lane-sync.test.js`
+Expected: PASS — every test in the file.
+
+- [ ] **Step 13: Verify against a REAL worktree lane (not just plain clones)**
+
+The merge-driver setup and `MERGE_HEAD` detection use `--git-common-dir` vs `--git-dir` specifically because a `git worktree add` lane's `.git` is a FILE pointing at a private per-worktree dir, while `info/attributes` lives in the shared common dir. The tests above use plain clones (where both resolve to the same `.git`), which would pass even if this distinction were implemented backwards. Add one more test using this repo's own `worktree.js` to catch that class of bug:
+
+```js
+describe("lane-sync against a real git-worktree lane", () => {
+  it("resolves MERGE_HEAD and info/attributes correctly under git worktree add", async () => {
+    const wt = require("../lib/worktree");
+    const WT_ROOT = path.join(ROOT, "wt-fixture");
+    fs.mkdirSync(WT_ROOT, { recursive: true });
+    const src = path.join(WT_ROOT, "src");
+    g(WT_ROOT, "init", "-q", "-b", "development", src);
+    fs.writeFileSync(path.join(src, "README.md"), "hello\n");
+    gc(src, "add", "-A");
+    gc(src, "commit", "-qm", "init");
+    gc(src, "remote", "add", "origin", src); // self-origin: fetch is a same-repo no-op, good enough here
+    gc(src, "branch", "-f", "refs/remotes/origin/development", "development");
+
+    const wtDir = path.join(WT_ROOT, "wt-lane");
+    await wt.addWorktree({ sourceRepo: src, dir: wtDir, branch: "feat/wt", base: "development" });
+
+    // Simulate upstream moving, so devDeltaReport / collisionCheck have
+    // something to resolve against without a real remote. `src` is still on
+    // "development" here — addWorktree only checks out feat/wt in the NEW
+    // worktree dir; checking out feat/wt on src too would collide with the
+    // worktree (git refuses the same branch checked out twice).
+    fs.writeFileSync(path.join(src, "README.md"), "upstream change\n");
+    gc(src, "add", "-A");
+    gc(src, "commit", "-qm", "upstream");
+    gc(src, "branch", "-f", "refs/remotes/origin/development", "development");
+
+    const wtProfile = { env: { MIGRATIONS_DIR: "", GENERATED_MERGE_PATHS: "" }, generatedMergePaths: [], hooks: new Set() };
+    const result = await laneSync.checkSync({ cwd: wtDir }, wtProfile, "feat/wt");
+    assert.equal(result.code, 0);
+    assert.equal(result.devDelta.length, 1);
+  });
+});
+```
+
+- [ ] **Step 14: Run full test file, verify pass**
+
+Run: `node --test server/__tests__/lane-sync.test.js`
+Expected: PASS — every test, including the worktree one.
+
+- [ ] **Step 15: Header check + full suite**
+
+```bash
+bash .claude/skills/file-headers/scripts/check-headers.sh
+npm run test:server
+```
+
+- [ ] **Step 16: Commit**
+
+```bash
+git add server/lib/lane-sync.js server/__tests__/lane-sync.test.js
+git commit -m "feat(lanes): add lane-sync core — check/merge/continue (E2)"
+```
+
+---
+
+### Task 3: `POST /api/lanes/:id/sync-base` route
+
+**Files:**
+- Modify: `server/routes/lanes.js`
+
+**Interfaces:**
+- Consumes: `checkSync`/`mergeSync`/`continueSync` from Task 2 (`require("../lib/lane-sync")`); `requireProfile` (already imported, `lane-runtime.js`); `withLaneLock` (already imported); `laneOr404`, `sendRuntimeError` (already defined in this file).
+- Produces: `POST /api/lanes/:id/sync-base` — body `{mode?: "check"|"merge"|"continue", branch?: string}` (`mode` defaults `"merge"`). `200` with the raw `checkSync`/`mergeSync`/`continueSync` result (including `code: 4` and `code: 5` — those are documented outcomes, not HTTP errors). `400`/`404`/`409` with `{error: {code, message}}` on a genuine fault (no lane, no profile, bad branch, unresolved `--continue`).
+
+- [ ] **Step 1: Add the `lane-sync` import**
+
+In `server/routes/lanes.js`, add near the other `lib` requires (after `const { withLaneLock } = require("../lib/lane-lock");` at line 34):
+
+```js
+const { checkSync, mergeSync, continueSync } = require("../lib/lane-sync");
+```
+
+- [ ] **Step 2: Extend `sendRuntimeError`'s bad-request code list**
+
+`lane-sync.js`'s only thrown error code is `EBADBRANCH`; `continueSync` also throws `EUNRESOLVED`/`EMERGEUNCOMMITTED`. All three are caller mistakes (bad branch name, calling `--continue` too early), not server faults — they belong with the existing 400 group. In `sendRuntimeError` (`server/routes/lanes.js:566`):
+
+```js
+function sendRuntimeError(res, err) {
+  const badRequest = [
+    "ENOPROFILE",
+    "ENOHOOK",
+    "EBADLANEDIR",
+    "EBADSVC",
+    "EBADBRANCH",
+    "EUNRESOLVED",
+    "EMERGEUNCOMMITTED",
+  ];
+```
+
+- [ ] **Step 3: Add the route**
+
+Insert directly after the `/:id/hook/:name` route's closing `});` (`server/routes/lanes.js:760`, right before the `/:id/:action` catch-all comment block) — route order matters here, since the catch-all would otherwise 400 an unmatched path:
+
+```js
+/**
+ * The ONE sanctioned merge in the ship-feature-lane pipeline: origin/development
+ * INTO a feature branch, gated by a migration-number collision preflight.
+ * Synchronous — a fetch + collision-check + merge is seconds of git work, not
+ * the minutes a build/test hook can take, so this follows GET /:id/git's
+ * pattern rather than the hook route's 202-and-broadcast.
+ *
+ * Returns 200 with {code: 0|4|5, ...} for every DOCUMENTED outcome — a
+ * migration collision or a left-in-place conflict is an expected result, not
+ * an HTTP error. A malformed request, a missing profile, or an out-of-order
+ * --continue is the only case that answers with an `error` body.
+ *
+ * Never writes stage/status/notes — same boundary the hook and runtime
+ * routes already keep; the caller decides what a collision or conflict means
+ * for the lane's declared stage.
+ */
+router.post("/:id/sync-base", sameOriginGuard, async (req, res) => {
+  const lane = laneOr404(req, res);
+  if (!lane) return;
+  let profile;
+  try {
+    profile = requireProfile(lane);
+  } catch (err) {
+    return sendRuntimeError(res, err);
+  }
+
+  const mode = ["check", "merge", "continue"].includes(req.body?.mode) ? req.body.mode : "merge";
+  const branch =
+    typeof req.body?.branch === "string" && req.body.branch ? req.body.branch : undefined;
+
+  try {
+    const result = await withLaneLock(lane.id, () => {
+      const current = lanesLib.getLane(lane.id);
+      if (mode === "check") return checkSync(current, profile, branch);
+      if (mode === "continue") return continueSync(current, profile, branch);
+      return mergeSync(current, profile, branch);
+    });
+    res.json(result);
+  } catch (err) {
+    sendRuntimeError(res, err);
+  }
+});
+```
+
+- [ ] **Step 4: Verify with a quick manual smoke check**
+
+There's no HTTP-level test harness for lane routes in this repo (per the Global Constraints note) — Task 2's unit tests already cover `checkSync`/`mergeSync`/`continueSync` behavior directly. Confirm the route itself is wired correctly by starting the dev server and hitting it against a real profile-having lane:
+
+```bash
+npm run dev &
+sleep 3
+# Replace 1 with a real lane id that has a .ccam/profile and a feature branch.
+curl -s -X POST http://localhost:4820/api/lanes/1/sync-base \
+  -H 'Content-Type: application/json' \
+  -d '{"mode":"check","branch":"feat/some-branch"}' | node -e "process.stdin.pipe(require('node:fs').createWriteStream('/dev/stdout'))"
+```
+
+Expected: a JSON body with a `code` field (0 or 5), not an Express 404/500 HTML page. Stop the dev server afterward.
+
+- [ ] **Step 5: Run the full suite + header check**
+
+```bash
+bash .claude/skills/file-headers/scripts/check-headers.sh
+npm run test:server
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add server/routes/lanes.js
+git commit -m "feat(lanes): add POST /:id/sync-base route (E2)"
+```
+
+---
+
+### Task 4: `ccam lanes sync-base` CLI
+
+**Files:**
+- Modify: `bin/ccam.js`
+
+**Interfaces:**
+- Consumes: `POST /api/lanes/:id/sync-base` (Task 3); `resolveLaneArg(args)`, `post(path, body, options)` (both already defined in `bin/ccam.js`).
+- Produces: `ccam lanes sync-base [<id>] [--check|--continue] [branch]` — `process.exitCode` set to `0`/`4`/`5` matching the route's `code`, so `SKILL.md`'s documented exit-code contract holds when scripted.
+
+- [ ] **Step 1: Add the subcommand to `cmdLanesRuntime`**
+
+In `bin/ccam.js`, extend the `if (sub === "hook") { ... }` block (ends at `bin/ccam.js:1902`) with a new `sync-base` branch, inside the same `cmdLanesRuntime(sub, args)` function:
+
+```js
+  if (sub === "sync-base") {
+    const mode = laneArgs.includes("--check")
+      ? "check"
+      : laneArgs.includes("--continue")
+        ? "continue"
+        : "merge";
+    const branch = laneArgs.find((arg) => !arg.startsWith("--"));
+    const result = await post(
+      `/api/lanes/${laneId}/sync-base`,
+      { mode, branch },
+      { allowError: true }
+    );
+    if (result.status) {
+      console.error(`✖ sync-base → ${result.data?.error?.message || result.status}`);
+      process.exitCode = 1;
+      return;
+    }
+
+    if (result.code === 5) {
+      console.error(`✖ lane #${laneId} — MIGRATION NUMBER COLLISION (nothing merged):`);
+      for (const c of result.collisions) {
+        console.error(`  ${c.file} collides with ${c.collidesWith} — rename to ${c.suggestion}`);
+      }
+      process.exitCode = 5;
+      return;
+    }
+
+    if (result.code === 4) {
+      console.error(`✖ lane #${laneId} — MERGE CONFLICT (left in place).`);
+      console.error(`  conflicted: ${result.conflictedFiles.join(", ")}`);
+      console.error("  resolve, then: git add <resolved files> && git commit --no-edit");
+      console.error(
+        `  then: ccam lanes sync-base --continue ${branch ? branch + " " : ""}${laneId}`
+      );
+      process.exitCode = 4;
+      return;
+    }
+
+    if (mode === "check") {
+      if (result.devDelta === null) {
+        console.log("DEV_DELTA: unknown (no merge-base with origin/development)");
+      } else {
+        console.log(
+          `DEV_DELTA: ${result.devDelta.length} file(s) changed on origin/development since merge-base`
+        );
+        for (const f of result.devDelta) console.log(`  ${f}`);
+        if (result.overlap.length) {
+          console.log(
+            `DEV_OVERLAP: ${result.overlap.length} file(s) — the upstream delta touches the feature's files:`
+          );
+          for (const f of result.overlap) console.log(`  ${f}`);
+        } else {
+          console.log("DEV_OVERLAP: none");
+        }
+      }
+      console.log(`lane #${laneId} preflight vs origin/development: OK`);
+      return;
+    }
+
+    console.log(`lane #${laneId} — synced with origin/development (re-enter the pipeline at the gates)`);
+    return;
+  }
+```
+
+- [ ] **Step 2: Wire the subcommand into the dispatcher**
+
+`bin/ccam.js:3088` currently reads:
+
+```js
+      if (["up", "down", "runtime", "logs", "hook"].includes(rest[0])) {
+        return cmdLanesRuntime(rest[0], rest.slice(1));
+      }
+```
+
+Change to:
+
+```js
+      if (["up", "down", "runtime", "logs", "hook", "sync-base"].includes(rest[0])) {
+        return cmdLanesRuntime(rest[0], rest.slice(1));
+      }
+```
+
+- [ ] **Step 3: Add the help-catalog entry**
+
+In the command catalog array (`bin/ccam.js:2268`, right after the `lanes hook` entry), add:
+
+```js
+      [
+        "lanes sync-base",
+        "[<id>] [--check|--continue] [branch]",
+        "Fetch + migration-collision preflight, or merge origin/development into the feature branch (--check: read-only; --continue: finish after a resolved conflict; bare: merge, branch defaults to the lane's current branch)",
+      ],
+```
+
+- [ ] **Step 4: Manual smoke test against the running dashboard**
+
+```bash
+npm run dev &
+sleep 3
+node bin/ccam.js lanes sync-base --check feat/some-branch 1
+echo "exit: $?"
+```
+
+Expected: exit code `0` (clean) or `5` (collision) with readable output, not a stack trace. Stop the dev server afterward.
+
+- [ ] **Step 5: Run the full suite + header check**
+
+```bash
+bash .claude/skills/file-headers/scripts/check-headers.sh
+npm run test:server
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add bin/ccam.js
+git commit -m "feat(lanes): add ccam lanes sync-base CLI (E2)"
+```
+
+---
+
+### Task 5: `SKILL.md` edits + docs
+
+**Files:**
+- Modify: `.claude/skills/ship-feature-lane/SKILL.md`
+- Modify: `docs/LANES.md`
+- Modify: `docs/superpowers/plans/2026-08-03-shipyard-parity-lanes.md`
+
+**Interfaces:** none — documentation only, but every command referenced must now be real (this repo's docs-markdown rule: keep command examples executable and aligned with actual scripts).
+
+- [ ] **Step 1: Stage 2 — replace the "later task" paragraph**
+
+In `.claude/skills/ship-feature-lane/SKILL.md`, find (Stage 2, `### 2 — Pre-push CI gates + dev preflight`):
+
+```
+- `ccam lanes sync-base --check feat/<slug>` — the dev preflight: fetches and checks the branch against the CURRENT `origin/development` without merging anything. **This command is a LATER task, not yet built as of this skill's authoring** — until it exists, skip this preflight check and rely on Stage 12's conflict handling to catch a divergence at merge time; note this gap explicitly in your Stage 2 evidence (`ccam stage gates --evidence "sync-base preflight unavailable, skipped"`).
+  - Once built, its contract is: exit 5 on a migration-number collision (print the exact rename, do it on the feature branch, re-run Stage 2); informational `DEV_DELTA:`/`DEV_OVERLAP:` output otherwise (you do NOT sync the branch for it — GitHub merges non-conflicting histories fine).
+```
+
+Replace with:
+
+```
+- `ccam lanes sync-base --check feat/<slug>` — the dev preflight: fetches and checks the branch against the CURRENT `origin/development` without merging anything. Exit 5 on a migration-number collision: rename the printed file to the suggested number on the feature branch (`git mv`, update any in-file references), then re-run Stage 2. Exit 0 with `DEV_DELTA:`/`DEV_OVERLAP:` output otherwise — informational, you do NOT sync the branch for it (GitHub merges non-conflicting histories fine); a large overlapping delta is a heads-up that post-merge behavior may differ from what you test locally.
+```
+
+- [ ] **Step 2: Stage 8 — make the re-run unconditional**
+
+Find (Stage 8, around `SKILL.md:127`):
+
+```
+- Re-run the preflight if `ccam lanes sync-base` exists by the time you read this — development may have moved while you were in QC. If it doesn't exist yet, skip straight to the push (same gap noted in Stage 2).
+```
+
+Replace with:
+
+```
+- Re-run the preflight: `ccam lanes sync-base --check feat/<slug>` — development may have moved while you were in QC. A migration collision here (exit 5) sends you back to Stage 2 with the rename; a clean result (exit 0) proceeds to the push.
+```
+
+- [ ] **Step 3: Stage 12 — unconditional merge + the exit-4/`--continue` mechanics**
+
+Find (Stage 12, around `SKILL.md:155`):
+
+```
+  - `CONFLICTING` → the feature branch conflicts with `development`. Resolve it as real work:
+    - If `ccam lanes sync-base` exists by now: `ccam lanes sync-base feat/<slug>` (merges the latest `origin/development` INTO the feature branch — the only sanctioned merge). Resolve every conflict thoughtfully — keep `development`'s behavior for code unrelated to this feature, preserve the feature's intent where they overlap; when genuinely ambiguous, STOP and escalate (`--status blocked`, note the files) rather than guess. `git add` ONLY the conflicted files, `git commit --no-edit`.
+    - If it doesn't exist yet: `git fetch origin && git merge origin/development` directly on the feature branch, resolve conflicts the same way, commit.
+    - Re-enter the pipeline **from Stage 2 through Stage 8** (the push updates the PR), then return here and keep watching.
+```
+
+Replace with:
+
+```
+  - `CONFLICTING` → the feature branch conflicts with `development`. Resolve it as real work:
+    - `ccam lanes sync-base feat/<slug>` (merges the latest `origin/development` INTO the feature branch — the only sanctioned merge). A migration-number collision (exit 5) means nothing was merged — rename the printed file on the feature branch, re-run Stage 2, then retry this step.
+    - **Exit 4 — merge conflict, left in place on purpose.** Resolve every conflict thoughtfully on the feature branch — keep `development`'s behavior for code unrelated to this feature, preserve the feature's intent where they overlap; when genuinely ambiguous, STOP and escalate (`--status blocked`, note the files) rather than guess. Never hand-merge a generated contract/client file listed in the profile's `GENERATED_MERGE_PATHS` — the keep-ours driver + regen own them. `git add` ONLY the conflicted files, `git commit --no-edit`, then `ccam lanes sync-base --continue feat/<slug>` (folds any regenerated artifacts into a follow-up commit).
+    - Re-enter the pipeline **from Stage 2 through Stage 8** (the push updates the PR), then return here and keep watching.
+```
+
+- [ ] **Step 4: `docs/LANES.md` — add a sync-base subsection**
+
+In `docs/LANES.md`, under `## The ship-feature-lane skill (E1)` (`docs/LANES.md:967`), insert a new subsection after "### QC boot flag and profile integration" (ends around `docs/LANES.md:1005`) and before "### Pipeline template: ship-feature (16 node stages)":
+
+```markdown
+### Dev preflight and merge safety: sync-base
+
+`ccam lanes sync-base` is the ONE sanctioned merge in the pipeline — `origin/development` into a feature branch — used at Stages 2, 8, and 12. Three modes:
+
+```bash
+ccam lanes sync-base --check feat/<slug>      # read-only preflight: fetch + collision check + DEV_DELTA/DEV_OVERLAP
+ccam lanes sync-base feat/<slug>               # merge origin/development into the feature branch
+ccam lanes sync-base --continue feat/<slug>    # finish after a manually resolved conflict
+```
+
+Exit codes: `0` clean, `4` merge conflict (left in place — resolve, commit, then `--continue`), `5` migration-number collision (nothing merged — rename the printed file, re-run).
+
+Two profile declarations control it, both empty (off) by default:
+
+```bash
+# .ccam/profile/profile.env
+MIGRATIONS_DIR="db/migrations"
+GENERATED_MERGE_PATHS="api/openapi.json api/client.ts"
+```
+
+`MIGRATIONS_DIR` enables the collision preflight against a numbered-migrations directory. `GENERATED_MERGE_PATHS` gives the listed files a keep-ours merge driver (never hand-merged) and folds the profile's `regen` hook output into the sync commit — the single most common cross-lane conflict, for a repo that generates an API contract/client.
+```
+
+Also update the "Current status" bullets (`docs/LANES.md:983-999`) — the stages 0-8/10-12/14 list is unaffected (sync-base was already inside those stages' scope, just non-functional), so no change needed there; the new subsection above is the only addition.
+
+- [ ] **Step 5: Roadmap progress line**
+
+In `docs/superpowers/plans/2026-08-03-shipyard-parity-lanes.md`, find the `## E` section's `**Progress:**` line (`docs/superpowers/plans/2026-08-03-shipyard-parity-lanes.md:282`):
+
+```
+**Progress:** pipeline template + skill text (E1) done 2026-08-04 — see `docs/superpowers/specs/2026-08-04-ship-feature-skill-design.md`. Agents, `sync-base`, and F's integrations remain.
+```
+
+Replace with:
+
+```
+**Progress:** pipeline template + skill text (E1) done 2026-08-04 — see `docs/superpowers/specs/2026-08-04-ship-feature-skill-design.md`. `sync-base` (E2) done 2026-08-05 — see `docs/superpowers/specs/2026-08-05-sync-base-design.md`. Agents and F's integrations remain.
+```
+
+- [ ] **Step 6: Verify and commit**
+
+```bash
+bash .claude/skills/file-headers/scripts/check-headers.sh
+npm run test:server
+```
+
+```bash
+git add .claude/skills/ship-feature-lane/SKILL.md docs/LANES.md docs/superpowers/plans/2026-08-03-shipyard-parity-lanes.md
+git commit -m "docs(lanes): document ccam lanes sync-base (E2)"
+```