diff --git a/.claude/hooks/block-push.mjs b/.claude/hooks/block-push.mjs
index 51583678..57ccd720 100644
--- a/.claude/hooks/block-push.mjs
+++ b/.claude/hooks/block-push.mjs
@@ -3,22 +3,28 @@
 // for explicit approval instead of letting agents run them silently.
 // Emits the documented `permissionDecision: "ask"` shape so Claude Code
 // shows the standard tool-permission prompt; the user approves or denies.
+//
+// `main` moves only via scripts/finalize-isolated-clone.sh and
+// scripts/push-main.sh — never by hand.
 
 import { readFileSync } from "node:fs";
 
-// `main` matched as a whole bookmark token (not e.g. `main-feature`):
+// `main` matched as a whole branch token (not e.g. `main-feature`):
 // `(?:\s+\S+)*\s+main(?:\s|$)` — any number of preceding args, then `main`
-// at a whitespace boundary.
+// (bare or as a `<src>:main` refspec) at a whitespace boundary.
 const PATTERNS = [
   {
-    re: /^\s*jj\s+bookmark\s+(?:set|move|create|delete|forget|rename|track|untrack)\b(?:\s+\S+)*\s+main(?:\s|$)/,
-    why: "modifies the main bookmark",
+    re: /^\s*git\s+branch\s+(?:-f|--force)\b(?:\s+\S+)*\s+main(?:\s|$)/,
+    why: "force-moves the main branch by hand",
   },
   {
-    re: /^\s*jj\s+op\s+(?:restore|undo|abandon)\b/,
-    why: "rewinds jj operation history (can move main as a side effect)",
+    re: /^\s*git\s+reset\s+--hard\b/,
+    why: "hard-resets the current branch (moves main if it's checked out)",
+  },
+  {
+    re: /^\s*git\s+push\b(?:\s+\S+)*\s+(?:\S*:)?main(?:\s|$)/,
+    why: "pushes a ref targeting main by hand",
   },
-  { re: /^\s*jj\s+git\s+push\b/, why: "pushes via jj" },
   { re: /^\s*git\s+push\b/, why: "bare git push" },
 ];
 
diff --git a/.claude/hooks/require-jj-new.mjs b/.claude/hooks/require-jj-new.mjs
deleted file mode 100644
index 52c9fcec..00000000
--- a/.claude/hooks/require-jj-new.mjs
+++ /dev/null
@@ -1,59 +0,0 @@
-#!/usr/bin/env node
-// PreToolUse hook for Edit/Write/MultiEdit/NotebookEdit.
-//
-// Blocks file mutations when `@` already has a description — that means it
-// was finalized and the next edit would silently amend the finished commit.
-// The fix is `jj new` first to create a fresh working commit.
-//
-// Override: set JJ_AMEND=1 in the environment to bypass (e.g. intentional
-// amend, or describe-first workflow where description is set up front).
-
-import { readFileSync } from "node:fs";
-import { execFileSync } from "node:child_process";
-import { dirname } from "node:path";
-
-if (process.env.JJ_AMEND === "1") process.exit(0);
-
-let input;
-try {
-  input = JSON.parse(readFileSync(0, "utf-8"));
-} catch {
-  process.exit(0);
-}
-
-const filePath = input?.tool_input?.file_path;
-if (typeof filePath !== "string" || !filePath) process.exit(0);
-
-const dir = dirname(filePath);
-
-function jj(...args) {
-  try {
-    return execFileSync("jj", args, {
-      cwd: dir,
-      stdio: ["ignore", "pipe", "ignore"],
-      encoding: "utf-8",
-      timeout: 2000,
-    });
-  } catch {
-    return null;
-  }
-}
-
-const description = jj("log", "-r", "@", "-T", "description", "--no-graph");
-if (description === null) process.exit(0); // not in a jj repo
-
-const trimmed = description.trim();
-if (!trimmed) process.exit(0); // empty description — working commit, fine
-
-const firstLine = trimmed.split("\n")[0];
-process.stdout.write(
-  JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: "PreToolUse",
-      permissionDecision: "deny",
-      permissionDecisionReason:
-        `mpeek policy: @ is the finished commit "${firstLine}" with a clean working copy. Run \`jj new\` to start a fresh commit before editing — otherwise this edit silently amends the finished commit. Override: set JJ_AMEND=1.`,
-    },
-  }),
-);
-process.exit(0);
diff --git a/.claude/settings.json b/.claude/settings.json
index 73ad34f6..7b299fc1 100644
--- a/.claude/settings.json
+++ b/.claude/settings.json
@@ -6,12 +6,6 @@
         "hooks": [
           { "type": "command", "command": "node .claude/hooks/block-push.mjs" }
         ]
-      },
-      {
-        "matcher": "Edit|Write|MultiEdit|NotebookEdit",
-        "hooks": [
-          { "type": "command", "command": "node .claude/hooks/require-jj-new.mjs" }
-        ]
       }
     ]
   }
diff --git a/.claude/skills/agent-review/SKILL.md b/.claude/skills/agent-review/SKILL.md
index b137808a..99be8b49 100644
--- a/.claude/skills/agent-review/SKILL.md
+++ b/.claude/skills/agent-review/SKILL.md
@@ -29,8 +29,8 @@ failure mode (see [Failure modes](#failure-modes-name-them-in-the-brief)). The
 real gate is `yarn test:desktop:electron` in the main checkout — not a second LLM read.
 
 Orchestrator review:
-1. `jj -R .worktrees/<name> diff --stat -r 'main..@'` — scope check.
-2. `jj -R .worktrees/<name> diff -r 'main..@'` or `Read` each changed file.
+1. `git -C .worktrees/<name> diff --stat main...HEAD` — scope check.
+2. `git -C .worktrees/<name> diff main...HEAD` or `Read` each changed file.
 3. Look for: cross-app touches, missing tests, scope creep, secrets,
    `webSecurity:false` / `sandbox:false` regressions, lazy `require('electron')`,
    `setTimeout` in main without `isDestroyed()` guard, top-level
@@ -45,7 +45,7 @@ You are reviewing agent-produced work in clone .worktrees/<name>/.
 The agent claims it implemented <task>. Verify the claim — do NOT trust it.
 
 ACCEPTANCE (all runtime, all must pass — no grep shortcuts):
-1. `jj -R .worktrees/<name> diff --stat -r 'main..@'` — list files; flag any
+1. `git -C .worktrees/<name> diff --stat main...HEAD` — list files; flag any
    touch outside the declared scope.
 2. `yarn workspace @peek/desktop test:unit` from the clone — must pass; report
    numeric count.
@@ -89,8 +89,8 @@ Reviewer subagents drift toward these. Naming them in the brief reduces it.
      a. echo <name> > /tmp/mpeek-agent-name
      b. scripts/finalize-isolated-clone.sh
      c. If FF rejected: rebase IN THE CLONE
-          (jj -R .worktrees/<name> git fetch --remote origin
-           jj -R .worktrees/<name> rebase -s 'roots(::@ ~ ::main)' -d main)
+          (git -C .worktrees/<name> fetch origin
+           git -C .worktrees/<name> rebase origin/main)
         Then retry finalize.
 3. After ALL targeted clones finalized:
      yarn test:desktop:electron   # run_in_background, FULL suite (all 6 runners, ~3300+, ~10 min), canonical gate
@@ -115,7 +115,7 @@ When tests are green but user approval is pending, the orchestrator must:
    (see the `peek` skill's tag model).
 2. Surface to the user, in one short message:
    - The commit IDs landed on main
-   - The diff stat (`jj diff --stat -r 'main..@'` or per-commit)
+   - The diff stat (`git diff --stat main...HEAD` in the clone, or per-commit)
    - The test result (numeric pass count, runtime)
    - "Approve to mark done, or call out anything to revisit"
 3. Wait for explicit "approve" / "ok mark done" / equivalent before
@@ -132,24 +132,28 @@ sufficient.
 When `test:desktop:electron` fails after landing:
 
 1. Identify which finalized commit caused the failure (often obvious from the
-   failing test's surface area; if not, `jj log main@tangled..main` + bisect by
-   `jj op restore`).
-2. `jj abandon <finalized-commit-id>` in main — this leaves `main` pointing one
-   commit back. The chaos-defense scripts will FF correctly on next finalize.
+   failing test's surface area; if not, `git log --oneline tangled/main..main`
+   and bisect by resetting the clone to earlier commits).
+2. In the CLONE (never the main checkout) —
+   `git -C .worktrees/<name> reset --hard <sha-before-the-bad-commit>` —
+   discards the clone's landed commit back to the last good state. Git has no
+   operation log to restore from, so this is destructive: uncommitted work in
+   the clone is gone. `main` already fast-forwarded past the bad commit and
+   stays there; the fix lands as a new commit on top rather than rewriting
+   history.
 3. The clone still exists (preserved by finalize). SendMessage the **original
    agent** (not a fresh spawn) with:
    ```
    Your <task> landed but yarn test:desktop:electron failed: <paste failing test +
-   relevant log lines>. The commit was abandoned from main. The clone at
-   .worktrees/<name>/ still has your work. Diagnose, fix in the clone,
-   commit, and report back. Same brief as before re: do-not-finalize,
-   do-not-push.
+   relevant log lines>. The clone at .worktrees/<name>/ has been reset back
+   to before your commit. Diagnose, fix in the clone, commit, and report back.
+   Same brief as before re: do-not-finalize, do-not-push.
    ```
 4. When the agent returns, run `/agent-review` on the updated diff.
 
 Why SendMessage and not a new Agent: the original agent has full context on
 what it did and why. A fresh spawn re-reads everything. The clone still has
-its node_modules + jj state; no respawn overhead.
+its node_modules; no respawn overhead.
 
 ---
 
diff --git a/.claude/skills/fix/SKILL.md b/.claude/skills/fix/SKILL.md
index 1a39b348..fc7821f6 100644
--- a/.claude/skills/fix/SKILL.md
+++ b/.claude/skills/fix/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: fix
-description: Spawn a background coding agent with mpeek repo rules baked in (jj not git, yarn scripts, one command per Bash call). Use when delegating a well-scoped fix or implementation to a background agent.
+description: Spawn a background coding agent with mpeek repo rules baked in (yarn scripts, one command per Bash call). Use when delegating a well-scoped fix or implementation to a background agent.
 ---
 
 # /fix — Spawn background coding agent
@@ -10,7 +10,6 @@ When the user invokes /fix with a description:
 1. Spawn a **background coding agent** (`subagent_type=general-purpose`, `run_in_background=true`) with the task description.
 
 2. Include these rules in the agent prompt:
-   - Use `jj` not `git` for version control
    - Use `yarn <script>` for build/test/lint — read `package.json` scripts first
    - No compound bash commands (`&&`, `;`, `|`)
    - Use Read/Grep/Glob tools instead of bash for file operations
diff --git a/.claude/skills/mpeek-clone-pool/SKILL.md b/.claude/skills/mpeek-clone-pool/SKILL.md
index 8589ace8..34ed9575 100644
--- a/.claude/skills/mpeek-clone-pool/SKILL.md
+++ b/.claude/skills/mpeek-clone-pool/SKILL.md
@@ -6,7 +6,7 @@ description: The isolated clone pool for agent work in mpeek. Invoke BEFORE spaw
 # Isolated agent workspaces (clone pool)
 
 For parallel background agents (heavy rewrites, electron tests, `yarn start`),
-claim an isolated **true clone** with its own `.jj` and `.git`. Each clone has a
+claim an isolated **true clone** with its own `.git`. Each clone has a
 dedicated Electron profile dir so tests don't race on shared DB / ports / window
 state. The `node_modules` for the app(s) in scope are symlinked from the main
 checkout; no `yarn install` needed.
@@ -23,14 +23,14 @@ scripts/spawn-isolated-clone.sh
 # Inside the clone (you're cd'd into .worktrees/<name>):
 PROFILE=clone-<name> yarn <script>
 
-# After work is done — rebase commits into main checkout's bookmark.
-# Run the MAIN CHECKOUT's copy (cd back to it first): the script derives
-# the main-checkout path from its own $0, so invoking the clone's copy
-# makes it look for the pool-* remote in the clone and fail.
+# After work is done — fast-forward the commits into the main checkout's
+# `main` branch. Run the MAIN CHECKOUT's copy (cd back to it first): the
+# script derives the main-checkout path from its own $0, so invoking the
+# clone's copy makes it look for the pool-* remote in the clone and fail.
 scripts/finalize-isolated-clone.sh
 
 # Only when fully done with the slot:
-scripts/clean-isolated-clone.sh                 # forgets agent bookmark, removes clone dir + profile dir + git remote
+scripts/clean-isolated-clone.sh                 # forgets agent branch, removes clone dir + profile dir + git remote
 ```
 
 Task association (optional, recommended): when `/tmp/mpeek-clone-task` is set,
@@ -39,13 +39,13 @@ clean echoes it on teardown so you can see which task is being reclaimed.
 Recommended naming: `/tmp/mpeek-agent-name` = `<task-id-prefix>-<short-label>`
 (e.g. `71cfde09-chrome-host-gate`) so `ls .worktrees/*` is self-documenting.
 
-Why true clones (not jj workspaces): physically separate `.jj` dirs eliminate
+Why true clones: physically separate `.git` dirs and working trees eliminate
 the concurrent-edit hazard. Integration happens via a registered `pool-<name>`
 git remote in the main checkout — the main checkout's working state never
 changes unexpectedly because an agent is working.
 
-The old `spawn-isolated-agent.sh` family (jj workspaces, retired in Phase 6 of
-the apps/ restructure) is GONE — use the clone pool.
+The old `spawn-isolated-agent.sh` family (retired in Phase 6 of the apps/
+restructure) is GONE — use the clone pool.
 
 ## Scripts: file-name convention for invariant command text
 
@@ -90,38 +90,32 @@ Finalize works the same as any other slot (`scripts/finalize-isolated-clone.sh`)
 
 ## Chaos-defense background (why the chokepoints exist)
 
-After the 2026-05-21 cleanup, structural defenses replaced the previous
-ad-hoc bookmark management:
+After the 2026-05-21 cleanup, two structural defenses replaced the previous
+ad-hoc branch management:
 
 1. **`scripts/finalize-isolated-clone.sh` is fast-forward-or-bust.** It refuses
    to rebase. If the agent's work isn't a strict descendant of current `main`,
    the script tells the agent to rebase IN THE CLONE before retrying. This
    eliminates the divergent-commit-id pattern caused by rebasing remote-tracked
-   refs. It also refuses to finalize if doing so would STRAND non-empty work the
-   main checkout is currently sitting on (peek `0b908fef` — the silent-orphan
-   trap); it points you at `finalize-main-checkout-stack.sh` to land that work
-   first.
-
-2. **`scripts/finalize-main-checkout-stack.sh` is the main-checkout analogue.**
-   Work committed directly in the main checkout with `jj commit` advances `@`
-   but NOT the `main` bookmark, so it strands `main` below it. This script
-   fast-forwards `main` to that stack (fast-forward-or-bust, same as above) so
-   nobody hand-moves `main`. It does not push.
-
-3. **`scripts/push-main.sh` is the only sanctioned path to publish `main`.** It
-   verifies local `main` is a strict descendant of `main@tangled`, warns on
-   divergent siblings on the push path, prints the exact commit list, requires
-   `--yes` to proceed, and post-push prunes stale `pool-*` remote-tracking refs
-   so future fetches can't resurrect cleaned-up divergence.
+   refs. It also refuses to finalize if doing so would STRAND work the main
+   checkout is currently sitting on (peek `0b908fef` — the silent-orphan trap),
+   which under git means a detached HEAD carrying commits no branch names; give
+   them a branch first.
+
+2. **`scripts/push-main.sh` is the only sanctioned path to publish `main`.** It
+   verifies local `main` is a strict descendant of `tangled/main`, prints the
+   exact commit list, and requires `--yes` to proceed.
 
 The binding rules live in the root `CLAUDE.md` (never manually
-`jj bookmark set main`; `main` moves only via these chokepoint scripts).
+`git branch -f main`; never push `main` by hand; `main` moves only via these
+two chokepoint scripts).
 
 Edit-in-clone discipline: when changing `scripts/*` or any tracked file that's
 part of this machinery, work in a clone instead of the main checkout —
-`jj op restore` inside the main checkout can wipe uncommitted edits, which
-happened repeatedly during the 2026-05-21 session. The clone pool runs through
-the same hardened path (spawn → commit → finalize) and is unaffected.
+a `git reset --hard` or `git checkout` inside the main checkout can wipe
+uncommitted edits, which happened repeatedly during the 2026-05-21 session.
+The clone pool runs through the same hardened path (spawn → commit → finalize)
+and is unaffected.
 
 Related history: the Agent tool's `isolation: "worktree"` parameter (banned in
 root `CLAUDE.md`) left 10 orphan git worktrees in `.claude/worktrees/` (since
diff --git a/.claude/skills/release/SKILL.md b/.claude/skills/release/SKILL.md
index 198e195c..f4619dca 100644
--- a/.claude/skills/release/SKILL.md
+++ b/.claude/skills/release/SKILL.md
@@ -9,7 +9,7 @@ When the user invokes /release:
 
 1. Get recent commits since last changelog entry:
    ```
-   jj log -r 'main' --no-graph -T 'description.first_line() ++ "\n"' --limit 30
+   git log --oneline -30 main
    ```
 
 2. Read `CHANGELOG.md` to find the latest date heading (format: `## YYYY-MM-DD`).
@@ -29,7 +29,7 @@ When the user invokes /release:
 
 6. Commit both files:
    ```
-   jj commit -m "docs: update changelog and RSS feed for <date>"
+   git commit -am "docs: update changelog and RSS feed for <date>"
    ```
 
 ## Important
diff --git a/.claude/skills/review/SKILL.md b/.claude/skills/review/SKILL.md
index f6c701cf..1ad04d78 100644
--- a/.claude/skills/review/SKILL.md
+++ b/.claude/skills/review/SKILL.md
@@ -1,18 +1,18 @@
 ---
 name: review
-description: Review the current uncommitted jj diff via a background agent — correctness, tests, CLAUDE.md-rule compliance, pubsub checks. Use when reviewing local uncommitted changes before commit.
+description: Review the current uncommitted git diff via a background agent — correctness, tests, CLAUDE.md-rule compliance, pubsub checks. Use when reviewing local uncommitted changes before commit.
 ---
 
 When the user invokes /review:
 
 1. Show current change summary:
    ```
-   jj diff --stat
+   git diff --stat
    ```
 
 2. Get the full diff:
    ```
-   jj diff
+   git diff
    ```
 
 3. Spawn a **background agent** (`subagent_type=general-purpose`, `run_in_background=true`) to review all changed files:
@@ -21,7 +21,7 @@ When the user invokes /review:
    - **Correctness**: Logic errors, off-by-one, null/undefined handling
    - **Missing tests**: New functionality without test coverage
    - **Style**: Adherence to existing codebase conventions
-   - **CLAUDE.md rules**: jj not git, yarn scripts, no compound bash, etc.
+   - **CLAUDE.md rules**: yarn scripts, no compound bash, etc.
    - **Incomplete renames**: Stale references to old names
    - **Security**: Exposed secrets, unsafe operations
    - **PubSub**: Missing event publications for data mutations
diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md
index bdc80b44..730d4b71 100644
--- a/DEVELOPMENT.md
+++ b/DEVELOPMENT.md
@@ -592,7 +592,7 @@ This covers all 146+ scripts automatically, including:
 
 **No manual permission updates needed** when adding new scripts - the wildcards handle it.
 
-Other pre-approved tool patterns: `git:*`, `jj:*`, `node:*`, `cargo:*`, `electron:*`
+Other pre-approved tool patterns: `git:*`, `node:*`, `cargo:*`, `electron:*`
 
 ## Mobile Development (Tauri iOS/Android)
 
@@ -787,7 +787,7 @@ URL: `https://peek-node.up.railway.app`
 
 **Important:** The server uses **npm** (not yarn). Railway's Nixpacks builder auto-detects `package-lock.json` and uses npm. Do not add `yarn.lock` to `backend/server/` — it will cause Nixpacks to use yarn and fail with frozen lockfile errors.
 
-**How it works:** The deploy script (`yarn server:deploy`) uses `git subtree split` to extract `backend/server/` into a standalone `deploy/server` branch, then pushes to GitHub. Railway watches this branch.
+**How it works:** The deploy script (`yarn server:deploy`) builds the `deploy/server` branch in a temporary git worktree, writing out each file under `backend/server/` at its content on `main`, then pushes to GitHub. Railway watches this branch.
 
 ```bash
 # Run tests first
@@ -798,8 +798,8 @@ yarn server:deploy
 ```
 
 This runs `scripts/deploy-server.sh` which:
-1. Exports jj state to git (`jj git export`)
-2. Splits `backend/server/` into branch `deploy/server` via `git subtree split`
+1. Creates a temporary git worktree checked out to the `deploy/server` branch
+2. Writes out `backend/server/`'s contents at the `main` revision into that worktree and commits the result
 3. Removes `yarn.lock` from the deploy branch if present
 4. Pushes `deploy/server` to GitHub (`git push github deploy/server`)
 
diff --git a/apps/desktop/CLAUDE.md b/apps/desktop/CLAUDE.md
index 833e55b6..680ff8a1 100644
--- a/apps/desktop/CLAUDE.md
+++ b/apps/desktop/CLAUDE.md
@@ -7,7 +7,7 @@ This is the Electron desktop app. Code lives under `apps/desktop/` with subdirec
 - `tests/` — Playwright integration tests
 - `electron-builder.yml` — Packaging config
 
-For cross-cutting rules (jj workflow, subagent dispatch, Bash discipline), see the root `CLAUDE.md`.
+For cross-cutting rules (git workflow, subagent dispatch, Bash discipline), see the root `CLAUDE.md`.
 
 ---
 
diff --git a/apps/desktop/electron-builder.yml b/apps/desktop/electron-builder.yml
index 59533395..dd4ec01c 100644
--- a/apps/desktop/electron-builder.yml
+++ b/apps/desktop/electron-builder.yml
@@ -19,8 +19,6 @@ files:
   - "!out"
   - "!out/**"
   # Exclude version control and tooling
-  - "!.jj"
-  - "!.jj/**"
   - "!.yarn"
   - "!.yarn/**"
   - "!.claude"
diff --git a/apps/extension/CLAUDE.md b/apps/extension/CLAUDE.md
index 5cb9e656..778b786b 100644
--- a/apps/extension/CLAUDE.md
+++ b/apps/extension/CLAUDE.md
@@ -11,7 +11,7 @@ Key files:
 - `sync -> ../../sync` — symlink to shared sync code
 - `tests/` — Node.js unit tests + E2E sync test
 
-For cross-cutting rules (jj workflow, subagent dispatch, Bash discipline), see the root `CLAUDE.md`.
+For cross-cutting rules (git workflow, subagent dispatch, Bash discipline), see the root `CLAUDE.md`.
 
 ---
 
diff --git a/apps/mobile/CLAUDE.md b/apps/mobile/CLAUDE.md
index 3a61e0f4..f73d08a1 100644
--- a/apps/mobile/CLAUDE.md
+++ b/apps/mobile/CLAUDE.md
@@ -5,7 +5,7 @@ This is the Tauri-mobile app ("Peek Save") for iOS and Android. Code lives under
 - `src-tauri/` — Rust Tauri backend, Xcode project (`src-tauri/gen/apple/`), Android project
 - `BUILD_NUMBER` — Plain-text integer, incremented by `deploy:sim` script before each sim install
 
-For cross-cutting rules (jj workflow, subagent dispatch, Bash discipline), see the root `CLAUDE.md`.
+For cross-cutting rules (git workflow, subagent dispatch, Bash discipline), see the root `CLAUDE.md`.
 
 ---
 
diff --git a/apps/server/CLAUDE.md b/apps/server/CLAUDE.md
index 18de2608..abd1bc37 100644
--- a/apps/server/CLAUDE.md
+++ b/apps/server/CLAUDE.md
@@ -11,7 +11,7 @@ Code lives under `apps/server/`. Key files:
 - `storage/` — blob/image storage abstraction
 - `railway.json` — Railway deployment config
 
-For cross-cutting rules (jj workflow, subagent dispatch, Bash discipline), see the root `CLAUDE.md`.
+For cross-cutting rules (git workflow, subagent dispatch, Bash discipline), see the root `CLAUDE.md`.
 
 ---
 
diff --git a/docs/mobile.md b/docs/mobile.md
index f46da46f..21d5f21f 100644
--- a/docs/mobile.md
+++ b/docs/mobile.md
@@ -751,7 +751,7 @@ Verify:
 
 ### Xcode Points at Wrong Workspace
 
-**Symptom:** Build fails with `search path '.../ios-fixes-XXXX/...' not found` or similar, pointing at an old/different jj workspace.
+**Symptom:** Build fails with `search path '.../ios-fixes-XXXX/...' not found` or similar, pointing at a stale/removed clone directory.
 
 **Cause:** Xcode's DerivedData caches `$(PROJECT_DIR)` from whichever workspace the project was first opened from.
 
diff --git a/docs/overnight-audit.md b/docs/overnight-audit.md
index 167cf5df..8d757d2a 100644
--- a/docs/overnight-audit.md
+++ b/docs/overnight-audit.md
@@ -66,7 +66,7 @@ in place.
 
 ## What Was Fixed
 
-All changes are committed. jj log:
+All changes are committed. git log:
 
 ```
 a80ca3f8 docs: command audit and placeholder for tile:window:open e2e
diff --git a/docs/sync-source-refactor.md b/docs/sync-source-refactor.md
index 3d7d5dc6..189b8c75 100644
--- a/docs/sync-source-refactor.md
+++ b/docs/sync-source-refactor.md
@@ -267,4 +267,4 @@ ELECTRON_RUN_AS_NODE=1 ./node_modules/.bin/electron packages/integration-tests/s
 
 1. **`item_events` table migration** — `sync-e2e.test.js` creates a fresh DB but the desktop datastore's `validateSyncSchema()` requires all tables from `schema/v1.json` including `item_events`. Either the test setup needs to run migrations, or `initDatabase()` needs to create missing tables.
 2. **`test:sync:e2e` package.json script** — should use `ELECTRON_RUN_AS_NODE=1` instead of bare `node`. All sync test scripts that touch the desktop datastore need this.
-3. **Server deps** — `apps/server/node_modules` may not be installed in jj workspaces. Run `cd apps/server && npm install` if tests fail with `Cannot find module 'hono'`.
+3. **Server deps** — `apps/server/node_modules` may not be installed in agent clones. Run `cd apps/server && npm install` if tests fail with `Cannot find module 'hono'`.
diff --git a/notes/peek-talk-overview.md b/notes/peek-talk-overview.md
index 67116dc0..3edcb1a1 100644
--- a/notes/peek-talk-overview.md
+++ b/notes/peek-talk-overview.md
@@ -146,7 +146,7 @@ Small and portable — features built on it could run in other environments with
 
 ## Scale
 
-~3,190 tests across 6 runners, ~10 min wall-clock (including ~1,950 main-process unit tests). 146+ package.json scripts. MIT. Primary remote is Tangled; GitHub is Railway-deploy only. Local workflow is jj (Jujutsu), not git.
+~3,190 tests across 6 runners, ~10 min wall-clock (including ~1,950 main-process unit tests). 146+ package.json scripts. MIT. Primary remote is Tangled; GitHub is Railway-deploy only.
 
 # Three clients, one sync contract
 
diff --git a/scripts/changelog-bump.js b/scripts/changelog-bump.js
index c784766a..2179d807 100644
--- a/scripts/changelog-bump.js
+++ b/scripts/changelog-bump.js
@@ -2,22 +2,22 @@
 /**
  * changelog-bump.js
  *
- * Reads jj log between the last-bumped marker and the upper-bound revset
+ * Reads git log between the last-bumped marker and the upper-bound ref
  * (default `main`), generates terse one-line bullets clustered by
  * (type, area, day), and merges them into CHANGELOG.md under
  * `## Week of YYYY-MM-DD (Wnn)` / `### YYYY-MM-DD`.
  *
  * Usage:
- *   node scripts/changelog-bump.js [--dry-run] [--since <commit>] [--up-to <revset>]
+ *   node scripts/changelog-bump.js [--dry-run] [--since <commit>] [--up-to <ref>]
  *
- *   --up-to defaults to `main`. Pass a feature bookmark (e.g. `mcp-llm-policy`)
+ *   --up-to defaults to `main`. Pass a feature branch (e.g. `mcp-llm-policy`)
  *   to bump BEFORE finalizing main onto a stack — that way the bump commit
  *   joins the feature stack and a single finalize covers everything. After
  *   main has been advanced onto the stack, the default `main` is correct.
  *
  * Marker:
  *   `<!-- last-bumped: <commit-short-id> -->` — first match in CHANGELOG.md.
- *   On success, the marker is rewritten to the upper-bound revset's HEAD.
+ *   On success, the marker is rewritten to the upper-bound ref's HEAD.
  *
  * Skip rules (commit titles):
  *   - chore(*)
@@ -63,7 +63,7 @@ function findMarker(content) {
 }
 
 function getRevHead(rev) {
-  const out = execSync(`jj log -r ${rev} -T 'commit_id.short()' --no-graph`, {
+  const out = execSync(`git rev-parse --short ${rev}`, {
     encoding: 'utf-8',
   });
   return out.trim();
@@ -71,14 +71,13 @@ function getRevHead(rev) {
 
 function getCommits(sinceCommit, upTo) {
   // Tab-separated: short_id \t ISO timestamp \t description first line
-  const tmpl = String.raw`commit_id.short() ++ "\t" ++ committer.timestamp().format("%Y-%m-%dT%H:%M:%S%z") ++ "\t" ++ description.first_line() ++ "\n"`;
   const range = `${sinceCommit}..${upTo}`;
-  const cmd = `jj log -r '${range}' --no-graph -T '${tmpl}' --reversed`;
+  const cmd = `git log --reverse --pretty=format:'%h%x09%aI%x09%s' ${range}`;
   let out;
   try {
     out = execSync(cmd, { encoding: 'utf-8' });
   } catch (err) {
-    throw new Error(`jj log failed for range ${range}: ${err.message}`);
+    throw new Error(`git log failed for range ${range}: ${err.message}`);
   }
   return out
     .split('\n')
diff --git a/scripts/clean-isolated-clone.sh b/scripts/clean-isolated-clone.sh
index 80fc1bb9..6c774df2 100755
--- a/scripts/clean-isolated-clone.sh
+++ b/scripts/clean-isolated-clone.sh
@@ -1,13 +1,12 @@
 #!/bin/bash
 # Tear down an isolated clone: remove the clone dir, the registered git
-# remote in the main checkout, the agent bookmark safety copy, and the
-# clone's Electron profile dir.
+# remote in the main checkout, and the clone's Electron profile dir.
 #
 # Usage: scripts/clean-isolated-clone.sh <name>
 #
 # Only call this when you want to fully reclaim the slot. For ongoing
 # parallel work, prefer scripts/finalize-isolated-clone.sh which preserves
-# the clone + bookmark for reuse.
+# the clone + branch for reuse.
 
 set -euo pipefail
 
@@ -55,15 +54,6 @@ if git remote get-url "$REMOTE_NAME" >/dev/null 2>&1; then
   echo "Removed git remote ${REMOTE_NAME}" >&2
 fi
 
-# Drop any agent-<name>-* bookmarks (safety copies) in main.
-BOOKMARKS=$(jj bookmark list -T 'name ++ "\n"' 2>/dev/null | grep "^agent-${NAME}-" || true)
-if [ -n "$BOOKMARKS" ]; then
-  for bm in $BOOKMARKS; do
-    jj bookmark forget "$bm" >&2 || true
-    echo "Forgot bookmark ${bm}" >&2
-  done
-fi
-
 # Report the task association, if one was recorded at spawn time, before it's
 # deleted along with the rest of the clone dir. Informational only.
 if [ -r "${CLONE_DIR}/.clone-task" ]; then
diff --git a/scripts/deploy-server.sh b/scripts/deploy-server.sh
index d86bd620..a392f560 100755
--- a/scripts/deploy-server.sh
+++ b/scripts/deploy-server.sh
@@ -6,12 +6,9 @@
 # yarn.lock, otherwise Nixpacks will use yarn and fail.
 set -e
 
-# Find the jj repo root (where .git lives)
-REPO_ROOT="$(jj workspace root)"
+# Find the repo root (where .git lives)
+REPO_ROOT="$(git rev-parse --show-toplevel)"
 DIR="$REPO_ROOT"
-while [ ! -d "$DIR/.git" ] && [ "$DIR" != "/" ]; do
-  DIR="$(dirname "$DIR")"
-done
 
 if [ ! -d "$DIR/.git" ]; then
   echo "Error: could not find .git directory" >&2
@@ -23,27 +20,22 @@ cd "$DIR"
 echo "=== Server Deploy ==="
 echo ""
 
-# Auto-commit any pending jj changes
-if [ -n "$(jj diff --stat 2>/dev/null)" ]; then
+# Auto-commit any pending changes
+if [ -n "$(git status --porcelain)" ]; then
   echo ">>> Auto-committing pending changes..."
-  jj commit -m "chore: auto-commit for deploy"
+  git add -A
+  git commit -m "chore: auto-commit for deploy"
 fi
 
-# Sync jj state to git and ensure git main matches jj main
-echo ">>> Syncing jj → git..."
-jj git export
-MAIN_COMMIT=$(jj log -r main --no-graph -T 'commit_id' 2>/dev/null)
-git branch -f main "$MAIN_COMMIT" 2>/dev/null || true
-
 # Show what we're deploying
 echo ""
 echo ">>> Deploying from main:"
-jj log -r main --no-graph -T 'commit_id.short(12) ++ " " ++ description.first_line()' 2>/dev/null
+git log -1 --format='%H %s' main 2>/dev/null
 echo ""
 
 # Show recent commits that touched server
 echo ">>> Recent commits touching apps/server/:"
-jj log -r 'ancestors(main, 10)' --no-graph -T 'change_id.short(8) ++ " " ++ description.first_line() ++ "\n"' -- apps/server/ 2>/dev/null | head -5
+git log -10 --format='%h %s' main -- apps/server/ 2>/dev/null | head -5
 echo ""
 
 # Ensure deploy/server branch exists
@@ -64,14 +56,15 @@ git worktree prune 2>/dev/null || true
 
 git worktree add "$DEPLOY_DIR" deploy/server
 
-# Use jj to get the actual files (avoids git working tree sync issues)
+# Read file content at the `main` commit (not the working tree) so the
+# deploy branch reflects committed main regardless of what's checked out.
 echo "Syncing apps/server/ to deploy branch..."
 rm -rf "$DEPLOY_DIR"/* 2>/dev/null || true
-jj file list -r main -- apps/server/ | while read f; do
+git ls-tree -r --name-only main -- apps/server/ | while read f; do
   REL="${f#apps/server/}"
   [ "$REL" = "yarn.lock" ] && continue
   mkdir -p "$DEPLOY_DIR/$(dirname "$REL")"
-  jj file show "$f" -r main > "$DEPLOY_DIR/$REL"
+  git show "main:$f" > "$DEPLOY_DIR/$REL"
 done
 
 # Commit and push if there are changes
diff --git a/scripts/finalize-isolated-clone.sh b/scripts/finalize-isolated-clone.sh
index 28bf753f..2c94d0cb 100755
--- a/scripts/finalize-isolated-clone.sh
+++ b/scripts/finalize-isolated-clone.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
-# Finalize an isolated clone's commits into the main checkout's `main` bookmark.
+# Finalize an isolated clone's commits into the main checkout's `main` branch.
 #
 # Usage:
 #   echo <name> > /tmp/mpeek-agent-name
@@ -13,9 +13,9 @@
 #
 # Why: rebasing agent commits inside the main checkout (the old behavior)
 # rewrites commit IDs while the clone's pool-* remote still tracks the
-# originals. That ALWAYS produces divergent change_ids in jj — the root
-# cause of the chaos we cleaned up on 2026-05-21. Fast-forward-only finalize
-# eliminates divergence by construction.
+# originals, leaving orphaned copies of the same work on both sides — the
+# root cause of the chaos we cleaned up on 2026-05-21. Fast-forward-only
+# finalize eliminates that by construction.
 #
 # Cost: if main moves while the agent is working (e.g. another agent
 # finalized first), the agent has to rebase in their own clone before
@@ -24,16 +24,16 @@
 #
 # ## Mechanism
 #
-# 1. In the clone, advance the agent's bookmark to @ or @- (depending on
-#    whether the agent left work at @ or did `jj new` after).
-# 2. Fetch from the clone's pool-<name> git remote into main checkout.
+# 1. In the clone, find the newest agent-<name>-<timestamp> branch — the
+#    branch tip IS the work tip.
+# 2. Fetch from the clone's pool-<name> git remote into the main checkout.
 # 3. Check: is the fetched ref a strict descendant of current `main`?
-#    - YES: advance `main` bookmark to the fetched tip. Move @ on top.
+#    - YES: advance `main` to the fetched tip.
 #    - NO:  refuse with explicit rebase recipe.
 #
 # After a successful fast-forward, the clone is automatically reset to main
 # (via reset-isolated-clone.sh) so it's ready for the next task. All agent
-# bookmarks are preserved as breadcrumbs for archaeology.
+# branches are preserved as breadcrumbs for archaeology.
 # Full teardown (reclaim slot): scripts/clean-isolated-clone.sh.
 
 set -euo pipefail
@@ -66,35 +66,14 @@ if [ ! -d "$CLONE_DIR" ]; then
   exit 1
 fi
 
-# ── Step 1: in the clone, advance the agent bookmark to the work tip ──────
-cd "$CLONE_DIR"
-BOOKMARK=$(jj bookmark list -T 'name ++ "\n"' 2>/dev/null \
-  | grep "^agent-${NAME}-" \
-  | sort -t- -k3 -n -r \
-  | head -1)
-if [ -z "$BOOKMARK" ]; then
-  echo "error: no agent-${NAME}-<timestamp> bookmark found in clone." >&2
+# ── Step 1: in the clone, find the newest agent branch ────────────────────
+BRANCH=$(git -C "$CLONE_DIR" for-each-ref --sort=-creatordate --format='%(refname:short)' "refs/heads/agent-${NAME}-*" | head -1)
+if [ -z "$BRANCH" ]; then
+  echo "error: no agent-${NAME}-<timestamp> branch found in clone." >&2
   echo "       was the clone spawned via spawn-isolated-clone.sh?" >&2
   exit 1
 fi
-echo "Found bookmark in clone: ${BOOKMARK}" >&2
-
-# Pick @ if it has a description (agent did `jj describe` without trailing
-# `jj new` — the work IS @); otherwise @- (jj-canonical: work is @-, @ is
-# an empty placeholder). --allow-backwards because `jj describe` keeps the
-# change_id while changing commit_id, which jj treats as a sideways move.
-AT_DESC=$(jj log -r @ --no-graph -T 'description' 2>/dev/null)
-if [ -n "$AT_DESC" ]; then
-  WORK_TIP=$(jj log -r @ --no-graph -T 'commit_id' 2>/dev/null | head -1)
-  TIP_LABEL="@"
-else
-  WORK_TIP=$(jj log -r '@-' --no-graph -T 'commit_id' 2>/dev/null | head -1)
-  TIP_LABEL="@-"
-fi
-if [ -n "$WORK_TIP" ]; then
-  jj bookmark set "$BOOKMARK" -r "$WORK_TIP" --allow-backwards >&2
-  echo "Bookmark ${BOOKMARK} advanced to ${TIP_LABEL} (${WORK_TIP:0:12})" >&2
-fi
+echo "Found branch in clone: ${BRANCH}" >&2
 
 # ── Step 2: in main, fetch from the clone's git remote ────────────────────
 cd "$MAIN_DIR"
@@ -104,20 +83,20 @@ if ! git remote get-url "$REMOTE_NAME" >/dev/null 2>&1; then
   exit 1
 fi
 echo "Fetching from ${REMOTE_NAME}..." >&2
-jj git fetch --remote "$REMOTE_NAME" >&2
+git fetch "$REMOTE_NAME" >&2
 
-REMOTE_REF="${BOOKMARK}@${REMOTE_NAME}"
+REMOTE_REF="${REMOTE_NAME}/${BRANCH}"
 
 # ── Step 3: fast-forward-or-bust check ────────────────────────────────────
-REMOTE_REV=$(jj log -r "$REMOTE_REF" --no-graph -T 'commit_id' 2>/dev/null | head -1)
-MAIN_REV=$(jj log -r main --no-graph -T 'commit_id' 2>/dev/null | head -1)
+REMOTE_REV=$(git rev-parse "$REMOTE_REF" 2>/dev/null || true)
+MAIN_REV=$(git rev-parse main 2>/dev/null || true)
 
 if [ -z "$REMOTE_REV" ]; then
   echo "error: could not resolve ${REMOTE_REF} after fetch." >&2
   exit 1
 fi
 if [ -z "$MAIN_REV" ]; then
-  echo "error: could not resolve local 'main' bookmark." >&2
+  echo "error: could not resolve local 'main' branch." >&2
   exit 1
 fi
 
@@ -128,18 +107,7 @@ if [ "$REMOTE_REV" = "$MAIN_REV" ]; then
 fi
 
 # Strict-descendant check: is MAIN_REV an ancestor of REMOTE_REV?
-# Computed as: does jj's ancestor set of REMOTE_REV contain MAIN_REV?
-# (We grep instead of using `&` in the revset because chook blocks `&` in
-# Bash tool args; this stays portable to interactive invocations too.)
-#
-# IMPORTANT: under `set -o pipefail`, `grep -q` short-circuits on first match
-# and causes the upstream `echo` to receive SIGPIPE (exit 141). pipefail then
-# makes the whole pipeline exit 141, and `if !` flips that to truthy — i.e.
-# the ERROR branch runs even when MAIN_REV IS an ancestor. Use `grep -c`
-# (counts every line, no early exit) with the count discarded; check grep's
-# exit code directly, which is 0 iff at least one match was found.
-ANCESTORS_OF_REMOTE=$(jj log -r "::${REMOTE_REV}" --no-graph -T 'commit_id ++ "\n"' 2>/dev/null)
-if ! echo "$ANCESTORS_OF_REMOTE" | grep -cFx "$MAIN_REV" >/dev/null; then
+if ! git merge-base --is-ancestor "$MAIN_REV" "$REMOTE_REV"; then
   echo "" >&2
   echo "ERROR: agent's work is NOT a fast-forward of main." >&2
   echo "" >&2
@@ -150,9 +118,9 @@ if ! echo "$ANCESTORS_OF_REMOTE" | grep -cFx "$MAIN_REV" >/dev/null; then
   echo "their own clone before finalize. Recipe:" >&2
   echo "" >&2
   echo "  cd ${CLONE_DIR}" >&2
-  echo "  jj git fetch                                # pull latest main" >&2
-  echo "  jj rebase -s ${BOOKMARK} -d main@origin --skip-emptied" >&2
-  echo "  # resolve any conflicts: jj resolve" >&2
+  echo "  git fetch origin                             # pull latest main" >&2
+  echo "  git rebase origin/main" >&2
+  echo "  # resolve any conflicts, then: git rebase --continue" >&2
   echo "  cd ${MAIN_DIR}" >&2
   echo "  echo ${NAME} > /tmp/mpeek-agent-name" >&2
   echo "  scripts/finalize-isolated-clone.sh" >&2
@@ -161,51 +129,60 @@ if ! echo "$ANCESTORS_OF_REMOTE" | grep -cFx "$MAIN_REV" >/dev/null; then
 fi
 
 # ── Step 3.5: strand guard (peek 0b908fef) ────────────────────────────────
-# Step 4 below does `jj bookmark set main` + `jj new` onto the clone's line.
-# Any non-empty, described work the MAIN CHECKOUT is currently sitting on that
-# is NOT on that incoming line would be left referenced by nothing — the silent
-# orphan trap. Detect it and refuse, rather than evaporate it.
+# Step 4 below moves `main` onto the incoming line. Work the MAIN CHECKOUT is
+# sitting on that is NOT on that line would be left referenced by nothing — the
+# silent orphan trap.
 #
-# Revset `::@ ~ ::REMOTE_REV ~ empty()`: everything on the main checkout's
-# current @ line (`::@`), minus the incoming/shared history (`::REMOTE_REV` —
-# removes old main and every clone commit), minus empty placeholders (the @
-# left by a trailing `jj new`). What remains is exactly the main-checkout-only
-# stack this finalize would strand. Scoped to `::@` (not `descendants(main)`)
-# so unrelated abandoned breadcrumbs elsewhere in the DAG don't trip it.
-STRANDED=$(jj log -r "::@ ~ ::${REMOTE_REV} ~ empty()" --no-graph \
-  -T 'commit_id.short() ++ "  " ++ description.first_line() ++ "\n"' 2>/dev/null || true)
-if [ -n "$STRANDED" ]; then
-  echo "" >&2
-  echo "ERROR: finalizing clone ${NAME} would STRAND main-checkout work:" >&2
-  echo "" >&2
-  echo "$STRANDED" >&2
-  echo "These commits sit on the main checkout's @ line but not on the clone's" >&2
-  echo "line. Moving main onto the clone would orphan them silently (0b908fef)." >&2
-  echo "Land them first, then rebase THIS clone onto the new main and re-run:" >&2
-  echo "" >&2
-  echo "  scripts/finalize-main-checkout-stack.sh --yes   # FF main to that stack" >&2
-  echo "  cd ${CLONE_DIR}" >&2
-  echo "  jj git fetch" >&2
-  echo "  jj rebase -s ${BOOKMARK} -d main@origin --skip-emptied" >&2
-  echo "  cd ${MAIN_DIR}" >&2
-  echo "  echo ${NAME} > /tmp/mpeek-agent-name" >&2
-  echo "  scripts/finalize-isolated-clone.sh" >&2
-  echo "" >&2
-  exit 6
+# Committed work on `main` itself cannot be stranded: the fast-forward gate
+# above already refuses unless `main` is an ancestor of the incoming tip, and
+# work on any other branch stays reachable through that branch. The one hole is
+# a DETACHED HEAD carrying commits — nothing names those, so moving `main` past
+# them leaves them to the reflog and nothing else. Detect and refuse.
+if ! git symbolic-ref -q HEAD >/dev/null 2>&1; then
+  STRANDED=$(git log --oneline "${REMOTE_REV}..HEAD" 2>/dev/null || true)
+  if [ -n "$STRANDED" ]; then
+    echo "" >&2
+    echo "ERROR: finalizing clone ${NAME} would STRAND main-checkout work:" >&2
+    echo "" >&2
+    echo "$STRANDED" >&2
+    echo "HEAD is detached and these commits are on no branch. Moving main onto" >&2
+    echo "the clone's line would orphan them silently (0b908fef). Give them a" >&2
+    echo "name first, then rebase THIS clone onto the new main and re-run:" >&2
+    echo "" >&2
+    echo "  git switch -c <branch-name>          # or: git branch -f main HEAD" >&2
+    echo "  cd ${CLONE_DIR}" >&2
+    echo "  git fetch origin" >&2
+    echo "  git rebase origin/main" >&2
+    echo "  cd ${MAIN_DIR}" >&2
+    echo "  echo ${NAME} > /tmp/mpeek-agent-name" >&2
+    echo "  scripts/finalize-isolated-clone.sh" >&2
+    echo "" >&2
+    exit 6
+  fi
 fi
 
-# ── Step 4: fast-forward main and @ ───────────────────────────────────────
-jj bookmark set main -r "$REMOTE_REV"
+# ── Step 4: fast-forward main ──────────────────────────────────────────────
+# `main` is normally the checked-out branch in the main checkout: fast-forward
+# it in place with a merge when HEAD is on it, and move the ref directly
+# otherwise. Refuse rather than clobber uncommitted edits.
+CURRENT_BRANCH=$(git symbolic-ref --short -q HEAD || true)
+if [ "$CURRENT_BRANCH" = "main" ]; then
+  if [ -n "$(git status --porcelain)" ]; then
+    echo "error: working tree is dirty; refusing to fast-forward 'main' in place." >&2
+    echo "       commit or stash your changes, then re-run." >&2
+    exit 1
+  fi
+  git merge --ff-only "$REMOTE_REV" >&2
+else
+  git branch -f main "$REMOTE_REV"
+fi
 echo "Fast-forwarded main: ${MAIN_REV:0:12} → ${REMOTE_REV:0:12}" >&2
 
-# Move @ onto the new tip (preserves the convention that @ rides above main)
-jj new "$REMOTE_REV" >&2
-
 echo "" >&2
 echo "Finalized clone ${NAME} (fast-forward, no rebase, no divergence)." >&2
 
 # Reset the clone back to main so it's ready for the next task.
-# Bookmarks are preserved as breadcrumbs for archaeology.
+# Branches are preserved as breadcrumbs for archaeology.
 "${MAIN_DIR}/scripts/reset-isolated-clone.sh" >&2
 
 echo "" >&2
diff --git a/scripts/finalize-main-checkout-stack.sh b/scripts/finalize-main-checkout-stack.sh
deleted file mode 100755
index 50d3cf88..00000000
--- a/scripts/finalize-main-checkout-stack.sh
+++ /dev/null
@@ -1,131 +0,0 @@
-#!/bin/bash
-# Finalize a stack committed directly in the MAIN checkout by fast-forwarding
-# the local `main` bookmark to the work tip. The main-checkout analogue of
-# scripts/finalize-isolated-clone.sh (which handles ONLY pool clones).
-#
-# ## Why this exists
-#
-# Work committed in the main checkout with plain `jj commit` advances @ but
-# NEVER the `main` bookmark — there is no auto-advance, and the two existing
-# chokepoints don't cover this case: finalize-isolated-clone.sh is clone-only,
-# and push-main.sh only PUSHES whatever `main` already points at (it never moves
-# it forward). So a stack built in the main checkout strands `main` below it, and
-# the only way anyone had to publish it was `jj bookmark set main` BY HAND — the
-# exact move the repo rules forbid, because ad-hoc bookmark surgery is how the
-# 2026-05-21 rebase-divergence chaos crept in. Three pushes in a row (2026-07-05
-# .. -07) worked around this by hand. This script replaces that ritual with a
-# guarded, fast-forward-ONLY chokepoint so nobody hand-moves `main` again.
-#
-# ## Semantics: fast-forward-or-bust
-#
-# Advances `main` only if the work tip is a STRICT DESCENDANT of the current
-# `main`. It never rebases — rebasing rewrites commit_ids while remotes still
-# track the originals, which manufactures divergent change_ids (the chaos). If
-# `main` has moved ahead of your stack, rebase your work onto `main` first, then
-# re-run.
-#
-# It does NOT push. Run scripts/push-main.sh afterward — that stays the sole
-# pusher, and it runs its own strict-descendant + divergence gate before
-# touching tangled.
-#
-# ## Usage
-#
-#   scripts/finalize-main-checkout-stack.sh          # preview what would advance
-#   scripts/finalize-main-checkout-stack.sh --yes     # advance `main` for real
-#   # then: scripts/push-main.sh          (preview)
-#   #       scripts/push-main.sh --yes    (publish)
-
-set -euo pipefail
-
-YES=0
-for arg in "$@"; do
-  case "$arg" in
-    --yes) YES=1 ;;
-    *) echo "unknown arg: $arg" >&2; exit 2 ;;
-  esac
-done
-
-MAIN_DIR="$(cd "$(dirname "$0")/.." && pwd)"
-cd "$MAIN_DIR"
-
-# ── Resolve the work tip ──────────────────────────────────────────────────
-# @ if it carries a description (the work IS @); otherwise @- (jj-canonical:
-# work is @-, @ is the empty placeholder left by a trailing `jj new`). Mirrors
-# finalize-isolated-clone.sh's tip selection.
-AT_DESC=$(jj log -r @ --no-graph -T 'description' 2>/dev/null)
-if [ -n "$AT_DESC" ]; then
-  WORK_TIP=$(jj log -r @ --no-graph -T 'commit_id' 2>/dev/null | head -1)
-  TIP_LABEL="@"
-else
-  WORK_TIP=$(jj log -r '@-' --no-graph -T 'commit_id' 2>/dev/null | head -1)
-  TIP_LABEL="@-"
-fi
-MAIN_REV=$(jj log -r main --no-graph -T 'commit_id' 2>/dev/null | head -1)
-
-if [ -z "$WORK_TIP" ]; then
-  echo "error: could not resolve work tip (${TIP_LABEL})." >&2
-  exit 1
-fi
-if [ -z "$MAIN_REV" ]; then
-  echo "error: local 'main' bookmark not found." >&2
-  exit 1
-fi
-
-# Already at the tip: nothing to do.
-if [ "$WORK_TIP" = "$MAIN_REV" ]; then
-  echo "main is already at the work tip (${MAIN_REV:0:12}). Nothing to finalize." >&2
-  exit 0
-fi
-
-# ── Strict-descendant (fast-forward) check ────────────────────────────────
-# jj DAG range X::Y is empty iff X is NOT an ancestor of Y. The trailing
-# `|| true` guards the SIGPIPE-from-`head` interaction under `set -o pipefail`
-# (same reasoning as push-main.sh: head closes the pipe, jj log gets SIGPIPE,
-# pipefail would otherwise abort the script).
-DAG_RANGE_HEAD=$(jj log -r "${MAIN_REV}::${WORK_TIP}" --no-graph -T 'commit_id ++ "\n"' 2>/dev/null | head -1 || true)
-if [ -z "$DAG_RANGE_HEAD" ]; then
-  echo "" >&2
-  echo "ERROR: the work tip is NOT a strict descendant of local 'main'." >&2
-  echo "" >&2
-  echo "  local main:   ${MAIN_REV:0:12}" >&2
-  echo "  work tip:     ${WORK_TIP:0:12} (${TIP_LABEL})" >&2
-  echo "" >&2
-  echo "This is fast-forward-only and refuses to rebase. If 'main' moved ahead" >&2
-  echo "of your stack, rebase your work onto it first, then re-run:" >&2
-  echo "" >&2
-  echo "  jj rebase -s 'roots(::@ ~ ::main)' -d main" >&2
-  echo "" >&2
-  exit 5
-fi
-
-# ── Preview the advance ───────────────────────────────────────────────────
-echo "" >&2
-echo "main would fast-forward (${MAIN_REV:0:12} → ${WORK_TIP:0:12}):" >&2
-echo "" >&2
-jj log -r "${MAIN_REV}..${WORK_TIP}" --no-graph -T 'commit_id.short() ++ "  " ++ description.first_line() ++ "\n"' >&2
-
-if [ "$YES" != 1 ]; then
-  echo "" >&2
-  echo "(preview only — re-run with --yes to advance 'main'," >&2
-  echo " then scripts/push-main.sh to publish)" >&2
-  exit 0
-fi
-
-# ── Fast-forward main ─────────────────────────────────────────────────────
-# No --allow-backwards: the strict-descendant guard above proves this is a
-# pure forward move, which `jj bookmark set` allows without the flag. Omitting
-# it means a non-forward move (a bug in the guard) would fail loudly instead of
-# silently rewinding `main`.
-jj bookmark set main -r "$WORK_TIP" >&2
-echo "" >&2
-echo "Fast-forwarded main: ${MAIN_REV:0:12} → ${WORK_TIP:0:12}" >&2
-
-# If the work tip WAS @ (no trailing empty placeholder), put a fresh empty @
-# above it so the convention "@ rides above main" holds. When the tip was @-,
-# @ is already that empty placeholder — leave it.
-if [ "$TIP_LABEL" = "@" ]; then
-  jj new "$WORK_TIP" >&2
-fi
-
-echo "" >&2
-echo "Next: publish with scripts/push-main.sh (preview), then --yes." >&2
diff --git a/scripts/jj-worktrees.sh b/scripts/jj-worktrees.sh
deleted file mode 100755
index ccbcdb9c..00000000
--- a/scripts/jj-worktrees.sh
+++ /dev/null
@@ -1,82 +0,0 @@
-#!/bin/bash
-# jj worktree management for multi-agent workflow
-# Usage: scripts/jj-worktrees.sh <command> [args]
-
-set -euo pipefail
-
-CMD="${1:-help}"
-
-case "$CMD" in
-  status)
-    # Show all workspaces with unmerged commits
-    for ws in $(jj workspace list 2>/dev/null | awk -F: '{print $1}'); do
-      commits=$(jj log -r "::$ws ~ ::main" --no-graph -T 'description.first_line() ++ "\n"' 2>/dev/null | grep -v '^$' || true)
-      if [ -n "$commits" ]; then
-        echo "=== $ws ==="
-        echo "$commits"
-        echo
-      fi
-    done
-    ;;
-
-  merge)
-    # Merge a specific workspace to main
-    WS="${2:?Usage: jj-worktrees.sh merge <workspace-name>}"
-    commits=$(jj log -r "::$WS ~ ::main" --no-graph -T 'change_id.short() ++ " " ++ description.first_line() ++ "\n"' 2>/dev/null | grep -v '^$' || true)
-    if [ -z "$commits" ]; then
-      echo "No unmerged commits in $WS"
-      exit 0
-    fi
-    echo "Merging $WS to main:"
-    echo "$commits"
-    # Get the tip commit of the workspace
-    tip=$(jj log -r "$WS-" --no-graph -T 'change_id.short()' 2>/dev/null | head -1)
-    if [ -z "$tip" ]; then
-      echo "Could not find tip commit for $WS"
-      exit 1
-    fi
-    jj rebase -s "roots(::$WS ~ ::main)" -d main
-    jj bookmark set main -r "$tip"
-    echo "Done. Main now at: $(jj log -r main --no-graph -T 'change_id.short() ++ " " ++ description.first_line()' 2>/dev/null)"
-    ;;
-
-  merge-all)
-    # Merge all workspaces with unmerged commits
-    for ws in $(jj workspace list 2>/dev/null | awk -F: '{print $1}'); do
-      [ "$ws" = "default" ] && continue
-      commits=$(jj log -r "::$ws ~ ::main" --no-graph -T 'description.first_line() ++ "\n"' 2>/dev/null | grep -v '^$' || true)
-      if [ -n "$commits" ]; then
-        echo "=== Merging $ws ==="
-        bash "$0" merge "$ws"
-        echo
-      fi
-    done
-    ;;
-
-  clean)
-    # Show worktree directories and sizes
-    echo "=== .claude/worktrees ==="
-    if [ -d ".claude/worktrees" ]; then
-      du -sh .claude/worktrees/*/ 2>/dev/null || echo "(empty)"
-    fi
-    echo
-    echo "=== jj workspaces ==="
-    jj workspace list 2>/dev/null
-    ;;
-
-  log)
-    # Show recent main commits
-    jj log -r 'ancestors(main, 10)' --no-graph -T 'change_id.short() ++ " " ++ description.first_line() ++ "\n"' 2>/dev/null
-    ;;
-
-  help|*)
-    echo "Usage: scripts/jj-worktrees.sh <command>"
-    echo
-    echo "Commands:"
-    echo "  status     Show all workspaces with unmerged commits"
-    echo "  merge <ws> Merge a specific workspace to main"
-    echo "  merge-all  Merge all unmerged workspaces to main"
-    echo "  clean      Show worktree directories and sizes"
-    echo "  log        Show recent main commits"
-    ;;
-esac
diff --git a/scripts/push-main.sh b/scripts/push-main.sh
index 162fb36c..ec86b66f 100755
--- a/scripts/push-main.sh
+++ b/scripts/push-main.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 # Push local `main` to tangled. The ONLY sanctioned path to publishing
-# work — replaces the convention of `jj git push --bookmark main`.
+# work — replaces the convention of `git push tangled main` run ad hoc.
 #
 # Usage:
 #   scripts/push-main.sh           # preview what would be pushed; refuse to push
@@ -9,15 +9,11 @@
 #
 # ## What it enforces
 #
-# 1. Local `main` is a strict descendant of `main@tangled`.
+# 1. Local `main` is a strict descendant of `tangled/main`.
 #    (Prevents accidental rewinds; refuses if local main is behind or sideways.)
-# 2. No commits between `main@tangled` and `main` exist as divergent siblings.
-#    (Catches the chaos-mode pattern where past rebases produced /0 /1 copies
-#    of commits that are still hanging around — we don't want to push a copy
-#    that has an alternate version on the remote already.)
-# 3. Optional fetch-first: `--fetch` runs `jj git fetch --remote tangled` to
-#    refresh the local view of `main@tangled` before checks.
-# 4. The `desktop-disruptive` Playwright suite, when the push touches
+# 2. Optional fetch-first: `--fetch` runs `git fetch tangled` to refresh the
+#    local view of `tangled/main` before checks.
+# 3. The `desktop-disruptive` Playwright suite, when the push touches
 #    apps/desktop/. See "The disruptive suite" below.
 #
 # ## The disruptive suite
@@ -35,21 +31,10 @@
 # push range touches apps/desktop/. `--no-disruptive` skips it — for pushing from
 # a machine someone is actively using, or when the display is mid-presentation.
 #
-# It lives HERE rather than in a git pre-push hook because pushes go out through
-# `jj git push` below, which a git hook does not reliably gate. CLAUDE.md and peek
-# `5f0824de` both describe a `.githooks/pre-push` per-app gate; that file has never
-# existed on any ref, so there was nothing to hook into. If peek `d2d561aa`
-# (evaluate moving off jj to plain git) ever lands, a real pre-push hook becomes
-# the natural home and this block should move there — d2d561aa's migration
-# checklist already lists .githooks/pre-push as a file to rewrite.
-#
-# ## Post-push cleanup
-#
-# After a successful push, prunes any `pool-*` remote-tracking refs whose
-# change_ids are now reachable from `main` — those refs held the OLD commit
-# IDs from the clone-pool era. Keeping them around would let future
-# `jj git fetch --remote tangled` resurrect divergent commits we just cleaned
-# up.
+# It lives HERE rather than in `.githooks/pre-push` deliberately: a push through
+# this script is human-initiated and rare, so gating it at the one chokepoint
+# that issues the push is simpler than wiring a hook that every push path would
+# need to trigger correctly.
 
 set -euo pipefail
 
@@ -70,42 +55,36 @@ cd "$MAIN_DIR"
 
 if [ "$FETCH" = 1 ]; then
   echo "Fetching from tangled..." >&2
-  jj git fetch --remote tangled >&2
+  git fetch tangled >&2
 fi
 
 # Resolve commit IDs.
-MAIN_REV=$(jj log -r main --no-graph -T 'commit_id' 2>/dev/null | head -1)
-TANGLED_REV=$(jj log -r 'main@tangled' --no-graph -T 'commit_id' 2>/dev/null | head -1)
+MAIN_REV=$(git rev-parse main 2>/dev/null || true)
+TANGLED_REV=$(git rev-parse tangled/main 2>/dev/null || true)
 
 if [ -z "$MAIN_REV" ]; then
-  echo "error: local 'main' bookmark not found." >&2
+  echo "error: local 'main' branch not found." >&2
   exit 1
 fi
 if [ -z "$TANGLED_REV" ]; then
-  echo "error: 'main@tangled' not found — has tangled been fetched? Try --fetch." >&2
+  echo "error: 'tangled/main' not found — has tangled been fetched? Try --fetch." >&2
   exit 1
 fi
 
 # Same-commit: nothing to push.
 if [ "$MAIN_REV" = "$TANGLED_REV" ]; then
-  echo "main and main@tangled are at the same commit (${MAIN_REV:0:12}). Nothing to push." >&2
+  echo "main and tangled/main are at the same commit (${MAIN_REV:0:12}). Nothing to push." >&2
   exit 0
 fi
 
 # Check: is TANGLED_REV an ancestor of MAIN_REV? (i.e. main is a strict
-# descendant of main@tangled — safe fast-forward push)
-# jj DAG range X::Y = descendants(X) intersected with ancestors(Y). Empty iff
-# X is NOT an ancestor of Y. The trailing `|| true` is needed because
-# `head -1` exits after the first line, closing the pipe and triggering
-# SIGPIPE on `jj log` — combined with `set -o pipefail` that would abort
-# the script. We only care about whether the range is non-empty.
-DAG_RANGE_HEAD=$(jj log -r "${TANGLED_REV}::${MAIN_REV}" --no-graph -T 'commit_id ++ "\n"' 2>/dev/null | head -1 || true)
-if [ -z "$DAG_RANGE_HEAD" ]; then
+# descendant of tangled/main — safe fast-forward push)
+if ! git merge-base --is-ancestor "$TANGLED_REV" "$MAIN_REV"; then
   echo "" >&2
-  echo "ERROR: local 'main' is NOT a strict descendant of main@tangled." >&2
+  echo "ERROR: local 'main' is NOT a strict descendant of tangled/main." >&2
   echo "" >&2
   echo "  local main:      ${MAIN_REV:0:12}" >&2
-  echo "  main@tangled:    ${TANGLED_REV:0:12}" >&2
+  echo "  tangled/main:    ${TANGLED_REV:0:12}" >&2
   echo "" >&2
   echo "This means tangled has commits the local main doesn't include. Either:" >&2
   echo "  (a) someone (or a cron) pushed to tangled main since the last local fetch." >&2
@@ -122,34 +101,7 @@ PUSH_RANGE="${TANGLED_REV}..${MAIN_REV}"
 echo "" >&2
 echo "Commits to push (${TANGLED_REV:0:12} → ${MAIN_REV:0:12}):" >&2
 echo "" >&2
-jj log -r "$PUSH_RANGE" --no-graph -T 'commit_id.short() ++ "  " ++ description.first_line() ++ "\n"' >&2
-
-# Check: any of those commit IDs have divergent siblings in the local jj?
-# (Divergent siblings would mean we're pushing one of multiple versions of the
-# same change_id — likely a re-occurrence of the chaos we cleaned up.)
-PUSH_CHANGE_IDS=$(jj log -r "$PUSH_RANGE" --no-graph -T 'change_id ++ "\n"' 2>/dev/null)
-DIVERGENT_HITS=""
-for change_id in $PUSH_CHANGE_IDS; do
-  count=$(jj log -r "change_id($change_id)" --no-graph -T 'commit_id ++ "\n"' 2>/dev/null | wc -l | tr -d ' ')
-  if [ "$count" -gt 1 ]; then
-    DIVERGENT_HITS="${DIVERGENT_HITS} ${change_id}"
-  fi
-done
-if [ -n "$DIVERGENT_HITS" ]; then
-  echo "" >&2
-  echo "WARNING: the following change_ids have divergent siblings in the local repo:" >&2
-  for cid in $DIVERGENT_HITS; do
-    echo "  ${cid}" >&2
-  done
-  echo "" >&2
-  echo "Pushing one version means the alternates linger as orphans. Either:" >&2
-  echo "  (a) Abandon the alternates first: jj abandon -r 'divergent() ~ ancestors(main)'" >&2
-  echo "  (b) Accept the noise and push anyway (re-run with --yes if you've reviewed)." >&2
-  echo "" >&2
-  if [ "$YES" != 1 ]; then
-    exit 5
-  fi
-fi
+git log --oneline "$PUSH_RANGE" >&2
 
 # Dry-run / preview mode.
 if [ "$YES" != 1 ]; then
@@ -162,7 +114,7 @@ fi
 # desktop app: these specs only cover apps/desktop, and a docs- or server-only
 # push has no reason to hijack the display for a couple of minutes.
 if [ "$DISRUPTIVE" = 1 ]; then
-  TOUCHES_DESKTOP=$(jj diff --from "$TANGLED_REV" --to "$MAIN_REV" --name-only 2>/dev/null | grep -c '^apps/desktop/' || true)
+  TOUCHES_DESKTOP=$(git diff --name-only "$TANGLED_REV" "$MAIN_REV" 2>/dev/null | grep -c '^apps/desktop/' || true)
   if [ "$TOUCHES_DESKTOP" -gt 0 ]; then
     echo "" >&2
     echo "Running the desktop-disruptive suite (${TOUCHES_DESKTOP} apps/desktop/ file(s) in this push)." >&2
@@ -187,26 +139,7 @@ fi
 # Push for real.
 echo "" >&2
 echo "Pushing main to tangled..." >&2
-jj git push --remote tangled --bookmark main >&2
-
-# Post-push cleanup: prune pool-* remote-tracking refs whose change_ids are now
-# reachable from main. Those refs held the OLD commit IDs from any prior
-# rebase-style finalizes — keeping them lets future fetches resurrect divergence.
-echo "" >&2
-echo "Cleaning up stale pool-* remote-tracking refs..." >&2
-PUSHED_CHANGE_IDS=$(jj log -r "${TANGLED_REV}..main" --no-graph -T 'change_id ++ "\n"' 2>/dev/null)
-for change_id in $PUSHED_CHANGE_IDS; do
-  # find any pool-*-tracked bookmark at the same change_id
-  for bm in $(jj bookmark list --all-remotes -T 'name ++ "\n"' 2>/dev/null | grep '@pool-' | sort -u); do
-    bm_change=$(jj log -r "$bm" --no-graph -T 'change_id' 2>/dev/null | head -1)
-    if [ "$bm_change" = "$change_id" ]; then
-      bm_name="${bm%@pool-*}"
-      pool="${bm##*@}"
-      echo "  pruning ${bm} (change_id now on main as commit ${bm_change:0:12})" >&2
-      jj git push --remote "${pool#pool-}" --bookmark "$bm_name" --deleted 2>/dev/null || true
-    fi
-  done
-done
+git push tangled main >&2
 
 echo "" >&2
-echo "Push complete. main@tangled is now at ${MAIN_REV:0:12}." >&2
+echo "Push complete. tangled/main is now at ${MAIN_REV:0:12}." >&2
diff --git a/scripts/reset-isolated-clone.sh b/scripts/reset-isolated-clone.sh
index 91c5a689..2f01841a 100755
--- a/scripts/reset-isolated-clone.sh
+++ b/scripts/reset-isolated-clone.sh
@@ -1,8 +1,8 @@
 #!/bin/bash
 # Reset an isolated clone back to main so it's ready for the next task.
 #
-# Preserves all agent-<name>-* bookmarks as breadcrumbs for archaeology.
-# Does NOT create a new bookmark — that's spawn's job.
+# Preserves all agent-<name>-* branches as breadcrumbs for archaeology.
+# Does NOT create a new branch — that's spawn's job.
 #
 # Usage:
 #   echo <name> > /tmp/mpeek-agent-name
@@ -43,9 +43,14 @@ fi
 cd "$CLONE_DIR"
 
 # Fetch latest state from origin
-jj git fetch >&2
+git fetch origin >&2
 
-# Move working copy to main — leaves all bookmarks intact
-jj new main@origin >&2
+# Detach HEAD onto origin/main and hard-reset the working tree. Detaching
+# (rather than checking out a local branch) is what preserves the existing
+# agent-* branches — checking one of them out here would let the next
+# spawn's `git switch -C` silently overwrite it instead of leaving it as a
+# breadcrumb.
+git switch --detach origin/main >&2
+git reset --hard >&2
 
-echo "Reset clone ${NAME} to main (bookmarks preserved)." >&2
+echo "Reset clone ${NAME} to main (branches preserved)." >&2
diff --git a/scripts/spawn-isolated-clone.sh b/scripts/spawn-isolated-clone.sh
index 52bbfb41..bddc3e88 100755
--- a/scripts/spawn-isolated-clone.sh
+++ b/scripts/spawn-isolated-clone.sh
@@ -2,19 +2,19 @@
 # Claim an isolated CLONE for a background agent.
 #
 # This is the canonical agent isolation tool. It creates a TRUE INDEPENDENT
-# CLONE with its own .jj/ and .git/, eliminating both concurrent-edit hazards
-# between agents and the orphan-commit hazard of git worktrees.
-# (The old spawn-isolated-agent.sh jj-workspace pool has been retired.)
+# CLONE with its own .git/, eliminating both concurrent-edit hazards between
+# agents and the orphan-commit hazard of git worktrees.
+# (The old spawn-isolated-agent.sh shared-workspace pool has been retired.)
 #
 # Integration back into the main checkout happens via a registered git
-# remote (pool-<name>) — finalize fetches the agent's bookmark and rebases
+# remote (pool-<name>) — finalize fetches the agent's branch and fast-forwards
 # in the main checkout. The main checkout's working state never changes
 # unexpectedly because of an agent.
 #
 # Usage: scripts/spawn-isolated-clone.sh <name> [--base=<branch>]
 #
 # --base defaults to "main". Pass --base=apps-migration (or any other
-# bookmark name) to base the clone's working copy on a different branch.
+# branch name) to base the clone's working copy on a different branch.
 #
 # --scope=apps/desktop limits node_modules symlinking to that one app +
 # root + packages/*. Speeds up spawning for agents that only touch one app.
@@ -102,14 +102,14 @@ fi
 PROFILE="clone-${NAME}"
 PROFILE_DIR="${HOME}/Library/Application Support/Peek/${PROFILE}"
 TIMESTAMP=$(date +%s)
-AGENT_BOOKMARK="agent-${NAME}-${TIMESTAMP}"
+AGENT_BRANCH="agent-${NAME}-${TIMESTAMP}"
 REMOTE_NAME="pool-${NAME}"
 
 cd "$MAIN_DIR"
 
 if [ ! -d "$CLONE_DIR" ]; then
   echo "Creating new clone at ${CLONE_DIR}" >&2
-  jj git clone --colocate "$MAIN_DIR" "$CLONE_DIR" >&2
+  git clone "$MAIN_DIR" "$CLONE_DIR" >&2
   cd "$MAIN_DIR"
   if ! git remote get-url "$REMOTE_NAME" >/dev/null 2>&1; then
     git remote add "$REMOTE_NAME" "${CLONE_DIR}/.git"
@@ -119,13 +119,11 @@ else
   echo "Reusing existing clone at ${CLONE_DIR}" >&2
 fi
 
-# Reset clone to current BASE and create a fresh bookmark.
-# Use BASE@origin since the clone only has remote-tracking refs, not local ones.
-cd "$CLONE_DIR"
-jj git fetch >&2
-jj new "${BASE}@origin" >&2
-jj bookmark create "$AGENT_BOOKMARK" -r @ >&2
-echo "Working copy set to ${BASE}; bookmark ${AGENT_BOOKMARK} created at @" >&2
+# Reset clone to current BASE and create a fresh branch.
+# Use origin/BASE since the clone only has remote-tracking refs, not local ones.
+git -C "$CLONE_DIR" fetch origin >&2
+git -C "$CLONE_DIR" switch -C "$AGENT_BRANCH" "origin/${BASE}" >&2
+echo "Working copy set to ${BASE}; branch ${AGENT_BRANCH} created at HEAD" >&2
 
 # Record the optional task association as local metadata. Never tracked —
 # see the root .gitignore entry for .clone-task.
@@ -133,7 +131,7 @@ if [ -n "$TASK" ]; then
   cat > "${CLONE_DIR}/.clone-task" <<EOF
 task=${TASK}
 name=${NAME}
-bookmark=${AGENT_BOOKMARK}
+branch=${AGENT_BRANCH}
 created=${TIMESTAMP}
 EOF
   echo "Recorded task association: ${TASK} -> ${CLONE_DIR}/.clone-task" >&2
@@ -198,7 +196,6 @@ while IFS= read -r pkg; do
   echo "Symlinked ${rel_dir}/node_modules" >&2
 done < <(find . -name package.json \
   -not -path '*/node_modules/*' \
-  -not -path '*/.jj/*' \
   -not -path '*/.git/*' \
   -not -path '*/tmp/*' \
   -not -path '*/.claude/*' \
diff --git a/scripts/spawn-mobile-workspace.sh b/scripts/spawn-mobile-workspace.sh
index 7897e547..9894c3b4 100755
--- a/scripts/spawn-mobile-workspace.sh
+++ b/scripts/spawn-mobile-workspace.sh
@@ -10,9 +10,9 @@
 # data + libapp.a/xcframework artifacts. A normal pool slot would pay the cold-
 # build cost (~2 min Rust + Xcode time) on every spawn since clean-isolated-
 # clone.sh tears down the dir. The mobile slot PERSISTS those artifacts across
-# spawns: spawn-isolated-clone.sh on an existing clone only does `jj new BASE`
-# and re-symlinks node_modules — untracked build outputs in the clone's WC
-# survive untouched.
+# spawns: spawn-isolated-clone.sh on an existing clone only resets the working
+# tree to BASE and re-symlinks node_modules — untracked build outputs in the
+# clone's working tree survive untouched.
 #
 # Usage:
 #   scripts/spawn-mobile-workspace.sh