@nickmeriano/task 0.8.0 → 0.10.0

package/src/claim.test.ts

@@ -6,16 +6,24 @@
  * 1. Two concurrent `task claim <same-id>`: exactly one exits 0, the other
  *    exits 1 — git's atomic ref creation is the lock.
  * 2. Validation failures exit 2 before anything touches git.
- * 3. `task list --claimable` is the queue: position order, minus blocked,
- *    needs-human, and already-claimed tickets.
+ * 3. `task list --claimable` is the queue: position order, minus blocked
+ *    and already-claimed tickets — open asks never exclude a ticket.
  * 4. `task claim --release` deletes the branch both sides and the ticket is
  *    claimable again.
+ * 5. `task claim --lock-only` takes the same lock without touching the
+ *    checkout — a branch-pinned (even dirty) session can hold it — and
+ *    `--release` works on it symmetrically.
+ * 6. Deletions are verified: against a remote that silently drops deletion
+ *    pushes (TAS-8b7s9), release and sweep fail loudly instead of lying.
+ * 7. `task sweep` deletes claim branches whose tickets are done, canceled or
+ *    missing on the current checkout, and leaves live ones — and any branch
+ *    named outside the claim scheme — alone.
  */
 
 import assert from "node:assert/strict"
 import { test } from "node:test"
 import { execFile, spawnSync } from "node:child_process"
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
 import { readFileSync } from "node:fs"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
@@ -46,11 +54,16 @@ interface CliResult {
 
 /** The CLI as callers see it — a subprocess with an exit code. */
 function cli(cwd: string, ...args: string[]): Promise<CliResult> {
+  return cliEnv(cwd, {}, ...args)
+}
+
+/** Like cli(), with extra env — the delete-dropping git shim rides in PATH. */
+function cliEnv(cwd: string, env: Record<string, string>, ...args: string[]): Promise<CliResult> {
   return new Promise((resolve) => {
     execFile(
       process.execPath,
       ["--experimental-strip-types", CLI, ...args],
-      { cwd },
+      { cwd, env: { ...process.env, ...env } },
       (error, stdout, stderr) => {
         resolve({ code: error ? ((error as { code?: number }).code ?? 1) : 0, stdout, stderr })
       },
@@ -58,23 +71,45 @@ function cli(cwd: string, ...args: string[]): Promise<CliResult> {
   })
 }
 
+/**
+ * A PATH whose `git` silently swallows branch-deletion pushes — exit 0,
+ * nothing deleted — and delegates everything else to the real git. This is
+ * the observed cloud-proxy behavior TAS-8b7s9 documents: the deletion "works"
+ * while the ref survives, which is exactly what verified release must catch.
+ * POSIX-only by construction, like the failure it reproduces.
+ */
+function deleteDroppingPath(): string {
+  const dir = mkdtempSync(join(tmpdir(), "task-fake-git-"))
+  process.on("exit", () => rmSync(dir, { recursive: true, force: true }))
+  const real = spawnSync("sh", ["-c", "command -v git"], { encoding: "utf8" }).stdout.trim()
+  const shim = join(dir, "git")
+  writeFileSync(
+    shim,
+    `#!/bin/sh\nfor a in "$@"; do case "$a" in --delete) exit 0;; esac; done\nexec "${real}" "$@"\n`,
+  )
+  chmodSync(shim, 0o755)
+  return `${dir}:${process.env.PATH ?? ""}`
+}
+
 interface Fixture {
   bare: string
   clone: () => string
+  /** Keys of the seeded tickets, by role. */
+  keys: { one: string; two: string; blocked: string; person: string; parked: string; jumper: string }
 }
 
 /**
  * A bare origin holding a board with the claimable shapes:
- *   1 "Ready one"    todo
- *   2 "Ready two"    todo
- *   3 "Blocked"      todo, blocked by 1
- *   4 "For a person" todo, needs-human
- *   5 "Still parked" backlog
- *   6 "Jumped queue" todo, moved to the top of the column after creation —
- *                    claimable order must be [6, 1, 2], proving position
- *                    order beats number order.
+ *   one     "Ready one"    todo
+ *   two     "Ready two"    todo
+ *   blocked "Blocked"      todo, blocked by `one`
+ *   person  "For a person" todo, carrying an open ask
+ *   parked  "Still parked" backlog
+ *   jumper  "Jumped queue" todo, moved to the top of the column after
+ *           creation — claimable order must be [jumper, one, two], proving
+ *           position order beats creation order.
  */
-function fixture(claimPrefix?: string): Fixture {
+function fixture(branchPrefix?: string): Fixture {
   const home = tempDir()
   const bare = join(home, "origin.git")
   sh(home, "git", "init", "--quiet", "--bare", "-b", "main", bare)
@@ -84,20 +119,29 @@ function fixture(claimPrefix?: string): Fixture {
   sh(seed, "git", "config", "user.name", "Test")
   sh(seed, "git", "config", "user.email", "test@example.com")
   const store = initProject(seed, { name: "claim board", prefix: "CLM" })
-  if (claimPrefix !== undefined) {
+  if (branchPrefix !== undefined) {
     const configPath = join(seed, ".task", "config.json")
     const config = JSON.parse(readFileSync(configPath, "utf8")) as Record<string, unknown>
-    config.claimPrefix = claimPrefix
+    config.claims = { branchPrefix }
     writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`)
   }
-  store.create({ title: "Ready one", status: "todo" })
-  store.create({ title: "Ready two", status: "todo" })
-  store.create({ title: "Blocked", status: "todo", blockedBy: [1] })
-  store.create({ title: "For a person", status: "todo", needsHuman: true })
-  store.create({ title: "Still parked", status: "backlog" })
+  const one = store.create({ title: "Ready one", status: "todo" })
+  const two = store.create({ title: "Ready two", status: "todo" })
+  const blocked = store.create({ title: "Blocked", status: "todo", blockedBy: [one.key] })
+  const person = store.create({ title: "For a person", status: "todo" })
+  store.addAsk(person.key, "Approve the vendor contract", "claude")
+  const parked = store.create({ title: "Still parked", status: "backlog" })
   const jumper = store.create({ title: "Jumped queue", status: "backlog" })
   // A status move without an explicit slot lands on top of the new column.
-  store.update(jumper.number, { status: "todo" })
+  store.update(jumper.key, { status: "todo" })
+  const keys = {
+    one: one.key,
+    two: two.key,
+    blocked: blocked.key,
+    person: person.key,
+    parked: parked.key,
+    jumper: jumper.key,
+  }
   sh(seed, "git", "add", "-A")
   sh(seed, "git", "commit", "--quiet", "-m", "board")
   sh(seed, "git", "push", "--quiet", "-u", "origin", "main")
@@ -110,15 +154,15 @@ function fixture(claimPrefix?: string): Fixture {
     sh(dir, "git", "config", "user.email", "test@example.com")
     return dir
   }
-  return { bare, clone }
+  return { bare, clone, keys }
 }
 
 test("two concurrent claims of one ticket: exactly one wins", async () => {
-  const { bare, clone } = fixture()
+  const { bare, clone, keys } = fixture()
   const a = clone()
   const b = clone()
 
-  const [ra, rb] = await Promise.all([cli(a, "claim", "1"), cli(b, "claim", "1")])
+  const [ra, rb] = await Promise.all([cli(a, "claim", keys.one), cli(b, "claim", keys.one)])
   assert.deepEqual([ra.code, rb.code].sort(), [0, 1], `a: ${ra.stderr}\nb: ${rb.stderr}`)
 
   const winner = ra.code === 0 ? a : b
@@ -126,123 +170,145 @@ test("two concurrent claims of one ticket: exactly one wins", async () => {
   assert.match(loser.stderr, /already claimed|rejected/)
 
   // The winner is left on the claim branch, flip committed and pushed.
-  assert.equal(sh(winner, "git", "rev-parse", "--abbrev-ref", "HEAD"), "task/claim/clm-1")
+  const branch = `task/claim/clm-${keys.one}`
+  assert.equal(sh(winner, "git", "rev-parse", "--abbrev-ref", "HEAD"), branch)
   assert.match(
-    readFileSync(join(winner, ".task", "tickets", "1", "ticket.md"), "utf8"),
+    readFileSync(join(winner, ".task", "tickets", keys.one, "ticket.md"), "utf8"),
     /status: in_progress/,
   )
-  assert.match(
-    sh(winner, "git", "ls-remote", "--heads", "origin", "task/claim/clm-1"),
-    /refs\/heads\/task\/claim\/clm-1/,
-  )
+  assert.ok(sh(winner, "git", "ls-remote", "--heads", "origin", branch).includes(`refs/heads/${branch}`))
   // Origin's default branch never saw the flip — the claim rides the branch.
   assert.equal(sh(winner, "git", "diff", "--stat", "origin/main..HEAD", "--", "README.md"), "")
-  assert.match(sh(winner, "git", "show", "origin/main:.task/tickets/1/ticket.md"), /status: todo/)
+  assert.match(
+    sh(winner, "git", "show", `origin/main:.task/tickets/${keys.one}/ticket.md`),
+    /status: todo/,
+  )
   void bare
 })
 
 test("unclaimable tickets exit 2, before anything touches origin", async () => {
-  const { clone } = fixture()
+  const { clone, keys } = fixture()
   const dir = clone()
 
-  assert.equal((await cli(dir, "claim", "5")).code, 2) // backlog
-  assert.equal((await cli(dir, "claim", "3")).code, 2) // blocked
-  assert.equal((await cli(dir, "claim", "4")).code, 2) // needs a human
-  assert.equal((await cli(dir, "claim", "99")).code, 2) // missing
-  assert.match((await cli(dir, "claim", "3")).stderr, /blocked by CLM-1/)
+  assert.equal((await cli(dir, "claim", keys.parked)).code, 2) // backlog
+  assert.equal((await cli(dir, "claim", keys.blocked)).code, 2) // blocked
+  assert.equal((await cli(dir, "claim", "zz9zz")).code, 2) // missing
+  assert.match(
+    (await cli(dir, "claim", keys.blocked)).stderr,
+    new RegExp(`blocked by CLM-${keys.one}`),
+  )
 
   // A dirty tree refuses too — claiming switches branches. Only *tracked*
   // modifications count: untracked files ride a branch switch untouched
   // (release deliberately leaves one — the reason comment).
   const gitignore = join(dir, ".task", ".gitignore")
   writeFileSync(gitignore, `${readFileSync(gitignore, "utf8")}\nwip\n`)
-  const dirty = await cli(dir, "claim", "2")
+  const dirty = await cli(dir, "claim", keys.two)
   assert.equal(dirty.code, 2)
   assert.match(dirty.stderr, /working tree is dirty/)
   sh(dir, "git", "checkout", "--", ".task/.gitignore")
   writeFileSync(join(dir, "scratch.txt"), "untracked is fine")
-  assert.equal((await cli(dir, "claim", "2")).code, 0)
+  assert.equal((await cli(dir, "claim", keys.two)).code, 0)
 
   // Nothing above created a stray claim branch for the failed ids.
   const remote = sh(dir, "git", "ls-remote", "--heads", "origin", "task/claim/*")
   assert.deepEqual(
     remote.split("\n").map((l) => l.split("refs/heads/")[1]),
-    ["task/claim/clm-2"],
+    [`task/claim/clm-${keys.two}`],
   )
 })
 
 test("list --claimable is the queue: position order, minus everything unclaimable", async () => {
-  const { clone } = fixture()
+  const { clone, keys } = fixture()
   const a = clone()
-  assert.equal((await cli(a, "claim", "6")).code, 0)
+  assert.equal((await cli(a, "claim", keys.jumper)).code, 0)
 
   const b = clone()
   const listed = await cli(b, "list", "--claimable", "--json")
   assert.equal(listed.code, 0)
-  const { tasks } = JSON.parse(listed.stdout) as { tasks: { number: number }[] }
-  // 6 claimed, 3 blocked, 4 needs-human, 5 not todo — position order keeps
-  // 1 before 2 (creation order within the column).
-  assert.deepEqual(tasks.map((t) => t.number), [1, 2])
+  const { tasks } = JSON.parse(listed.stdout) as { tasks: { key: string }[] }
+  // jumper claimed, blocked blocked, parked not todo — position order keeps
+  // one before two (creation order within the column). person carries an open
+  // ask and is claimable anyway: asks gate done, not claim.
+  assert.deepEqual(tasks.map((t) => t.key), [keys.one, keys.two, keys.person])
 
   assert.equal((await cli(b, "list", "--claimable", "--status", "todo")).code, 1)
 })
 
 test("release deletes the branch everywhere and reopens the claim", async () => {
-  const { clone } = fixture()
+  const { clone, keys } = fixture()
   const dir = clone()
-  assert.equal((await cli(dir, "claim", "2")).code, 0)
-  assert.equal((await cli(dir, "claim", "2")).code, 1) // locally claimed too
+  assert.equal((await cli(dir, "claim", keys.two)).code, 0)
+  assert.equal((await cli(dir, "claim", keys.two)).code, 1) // locally claimed too
 
-  const released = await cli(dir, "claim", "--release", "2", "--comment", "trying another shape")
+  const released = await cli(dir, "claim", "--release", keys.two, "--comment", "trying another shape")
   assert.equal(released.code, 0, released.stderr)
-  assert.match(released.stdout, /released CLM-2/)
+  assert.ok(released.stdout.includes(`released CLM-${keys.two}`), released.stdout)
 
   // Back on the default branch, branch gone on both sides, ticket todo again.
   assert.equal(sh(dir, "git", "rev-parse", "--abbrev-ref", "HEAD"), "main")
-  assert.equal(sh(dir, "git", "ls-remote", "--heads", "origin", "task/claim/clm-2"), "")
+  assert.equal(sh(dir, "git", "ls-remote", "--heads", "origin", `task/claim/clm-${keys.two}`), "")
   assert.match(
-    readFileSync(join(dir, ".task", "tickets", "2", "ticket.md"), "utf8"),
+    readFileSync(join(dir, ".task", "tickets", keys.two, "ticket.md"), "utf8"),
     /status: todo/,
   )
-  assert.equal((await cli(dir, "claim", "2")).code, 0)
+  assert.equal((await cli(dir, "claim", keys.two)).code, 0)
 
   // Releasing an unclaimed ticket is a quiet no-op, not an error.
-  const noop = await cli(dir, "claim", "--release", "1", "--comment", "noop")
+  const noop = await cli(dir, "claim", "--release", keys.one, "--comment", "noop")
   assert.equal(noop.code, 0)
   assert.match(noop.stdout, /wasn't claimed/)
 })
 
-test("a configured claimPrefix moves the whole namespace", async () => {
-  const { clone } = fixture("claude/task/")
+test("a configured claims.branchPrefix moves the whole namespace", async () => {
+  const { clone, keys } = fixture("claude/task/")
   const dir = clone()
 
-  assert.equal((await cli(dir, "claim", "1")).code, 0)
-  assert.equal(sh(dir, "git", "rev-parse", "--abbrev-ref", "HEAD"), "claude/task/clm-1")
-  assert.match(
-    sh(dir, "git", "ls-remote", "--heads", "origin", "claude/task/*"),
-    /refs\/heads\/claude\/task\/clm-1/,
+  assert.equal((await cli(dir, "claim", keys.one)).code, 0)
+  assert.equal(sh(dir, "git", "rev-parse", "--abbrev-ref", "HEAD"), `claude/task/clm-${keys.one}`)
+  assert.ok(
+    sh(dir, "git", "ls-remote", "--heads", "origin", "claude/task/*").includes(
+      `refs/heads/claude/task/clm-${keys.one}`,
+    ),
   )
 
   // Every side of the feature reads the same key: the queue looks for claims
   // under the configured namespace, and release deletes there too.
   const other = clone()
   const listed = await cli(other, "list", "--claimable", "--json")
-  const { tasks } = JSON.parse(listed.stdout) as { tasks: { number: number }[] }
-  assert.deepEqual(tasks.map((t) => t.number), [6, 2])
-  assert.equal((await cli(other, "claim", "1")).code, 1)
-  assert.equal((await cli(dir, "claim", "--release", "1", "--comment", "handing it back")).code, 0)
+  const { tasks } = JSON.parse(listed.stdout) as { tasks: { key: string }[] }
+  assert.deepEqual(tasks.map((t) => t.key), [keys.jumper, keys.two, keys.person])
+  assert.equal((await cli(other, "claim", keys.one)).code, 1)
+  assert.equal(
+    (await cli(dir, "claim", "--release", keys.one, "--comment", "handing it back")).code,
+    0,
+  )
   assert.equal(sh(dir, "git", "ls-remote", "--heads", "origin", "claude/task/*"), "")
 
   // A missing trailing slash is forgiven; a malformed value fails loudly.
   const bad = clone()
   const configPath = join(bad, ".task", "config.json")
   const config = JSON.parse(readFileSync(configPath, "utf8")) as Record<string, unknown>
-  config.claimPrefix = "spaces are not refs/"
+  config.claims = { branchPrefix: "spaces are not refs/" }
   writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`)
   sh(bad, "git", "commit", "--quiet", "-am", "bad prefix")
-  const invalid = await cli(bad, "claim", "2")
+  const invalid = await cli(bad, "claim", keys.two)
   assert.equal(invalid.code, 2)
   assert.match(invalid.stderr, /invalid claims\.branchPrefix/)
+
+  // The retired pre-0.8 `claimPrefix` spelling is not honored (TAS-41): a
+  // board carrying only it refuses by name rather than silently defaulting
+  // the lock convention out from under its workers.
+  const retired = clone()
+  const retiredPath = join(retired, ".task", "config.json")
+  const retiredConfig = JSON.parse(readFileSync(retiredPath, "utf8")) as Record<string, unknown>
+  delete retiredConfig.claims
+  retiredConfig.claimPrefix = "claude/task/"
+  writeFileSync(retiredPath, `${JSON.stringify(retiredConfig, null, 2)}\n`)
+  sh(retired, "git", "commit", "--quiet", "-am", "retired key")
+  const refused = await cli(retired, "claim", keys.two)
+  assert.equal(refused.code, 2)
+  assert.match(refused.stderr, /pre-0\.8 spelling and is no longer read/)
 })
 
 /**
@@ -252,7 +318,14 @@ test("a configured claimPrefix moves the whole namespace", async () => {
  * optionally, the top-level `boards` list — NES deliberately ahead of ROO,
  * so priority provably follows list order, not nearness.
  */
-function multiFixture(options: { boards?: string[]; maxOpenCount?: number } = {}): Fixture {
+interface MultiFixture {
+  bare: string
+  clone: () => string
+  rootKey: string
+  nestedKey: string
+}
+
+function multiFixture(options: { boards?: string[]; maxOpenCount?: number } = {}): MultiFixture {
   const home = tempDir()
   const bare = join(home, "origin.git")
   sh(home, "git", "init", "--quiet", "--bare", "-b", "main", bare)
@@ -268,11 +341,11 @@ function multiFixture(options: { boards?: string[]; maxOpenCount?: number } = {}
   if (options.boards) config.boards = options.boards
   config.claims = { branchPrefix: "task/claim/", maxOpenCount: options.maxOpenCount }
   writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`)
-  root.create({ title: "Root ready", status: "todo" })
+  const rootKey = root.create({ title: "Root ready", status: "todo" }).key
 
   mkdirSync(join(seed, "pkg"), { recursive: true })
   const nested = initProject(join(seed, "pkg"), { name: "nested board", prefix: "NES" })
-  nested.create({ title: "Nested ready", status: "todo" })
+  const nestedKey = nested.create({ title: "Nested ready", status: "todo" }).key
 
   sh(seed, "git", "add", "-A")
   sh(seed, "git", "commit", "--quiet", "-m", "boards")
@@ -286,14 +359,14 @@ function multiFixture(options: { boards?: string[]; maxOpenCount?: number } = {}
     sh(dir, "git", "config", "user.email", "test@example.com")
     return dir
   }
-  return { bare, clone }
+  return { bare, clone, rootKey, nestedKey }
 }
 
 test("claim --next drains the queue in position order and exits 1 when empty", async () => {
-  const { clone } = fixture()
+  const { clone, keys } = fixture()
   const dir = clone()
 
-  const order: number[] = []
+  const order: string[] = []
   for (;;) {
     const result = await cli(dir, "claim", "--next", "--json")
     if (result.code === 1) {
@@ -301,13 +374,14 @@ test("claim --next drains the queue in position order and exits 1 when empty", a
       break
     }
     assert.equal(result.code, 0, result.stderr)
-    const { task, branch } = JSON.parse(result.stdout) as { task: { number: number }; branch: string }
-    order.push(task.number)
+    const { task, branch } = JSON.parse(result.stdout) as { task: { key: string }; branch: string }
+    order.push(task.key)
     assert.equal(sh(dir, "git", "rev-parse", "--abbrev-ref", "HEAD"), branch)
   }
-  // The jumper leads (position order), then creation order; blocked,
-  // needs-human and backlog tickets never surface.
-  assert.deepEqual(order, [6, 1, 2])
+  // The jumper leads (position order), then creation order; blocked and
+  // backlog tickets never surface, while the open ask on `person` doesn't
+  // keep it out of the queue.
+  assert.deepEqual(order, [keys.jumper, keys.one, keys.two, keys.person])
 })
 
 test("two concurrent claim --next calls land on different tickets", async () => {
@@ -326,27 +400,27 @@ test("two concurrent claim --next calls land on different tickets", async () =>
 })
 
 test("--next walks the root boards list in priority order; --board overrides it", async () => {
-  const { clone } = multiFixture({ boards: ["NES", "ROO"] })
+  const { clone, rootKey, nestedKey } = multiFixture({ boards: ["NES", "ROO"] })
   const a = clone()
 
   // list --claimable reads the same scope, in the same order.
   const listed = await cli(a, "list", "--claimable", "--json")
   assert.equal(listed.code, 0, listed.stderr)
   const { tasks } = JSON.parse(listed.stdout) as { tasks: { id: string }[] }
-  assert.deepEqual(tasks.map((t) => t.id), ["NES-1", "ROO-1"])
+  assert.deepEqual(tasks.map((t) => t.id), [`NES-${nestedKey}`, `ROO-${rootKey}`])
 
   // The nested board wins despite the root board being nearest.
   const next = await cli(a, "claim", "--next", "--json")
   assert.equal(next.code, 0, next.stderr)
   const claimed = JSON.parse(next.stdout) as { task: { id: string }; branch: string }
-  assert.equal(claimed.task.id, "NES-1")
-  assert.equal(claimed.branch, "task/claim/nes-1")
+  assert.equal(claimed.task.id, `NES-${nestedKey}`)
+  assert.equal(claimed.branch, `task/claim/nes-${nestedKey}`)
 
   // An explicit --board list is the whole scope, in the given order.
   const b = clone()
   const overridden = await cli(b, "claim", "--next", "--board", "ROO", "--json")
   assert.equal(overridden.code, 0, overridden.stderr)
-  assert.equal((JSON.parse(overridden.stdout) as { task: { id: string } }).task.id, "ROO-1")
+  assert.equal((JSON.parse(overridden.stdout) as { task: { id: string } }).task.id, `ROO-${rootKey}`)
 
   const unknown = await cli(b, "claim", "--next", "--board", "NOPE")
   assert.equal(unknown.code, 2)
@@ -354,12 +428,12 @@ test("--next walks the root boards list in priority order; --board overrides it"
 })
 
 test("without a boards list, --next sees the nearest board only", async () => {
-  const { clone } = multiFixture()
+  const { clone, rootKey } = multiFixture()
   const dir = clone()
 
   const next = await cli(dir, "claim", "--next", "--json")
   assert.equal(next.code, 0, next.stderr)
-  assert.equal((JSON.parse(next.stdout) as { task: { id: string } }).task.id, "ROO-1")
+  assert.equal((JSON.parse(next.stdout) as { task: { id: string } }).task.id, `ROO-${rootKey}`)
 
   // ROO's queue is drained and NES never entered the scope.
   const empty = await cli(dir, "claim", "--next", "--json")
@@ -367,7 +441,7 @@ test("without a boards list, --next sees the nearest board only", async () => {
 })
 
 test("maxOpenCount caps every claim repo-wide; --force is the escape", async () => {
-  const { clone } = multiFixture({ boards: ["NES", "ROO"], maxOpenCount: 1 })
+  const { clone, rootKey } = multiFixture({ boards: ["NES", "ROO"], maxOpenCount: 1 })
   const a = clone()
   assert.equal((await cli(a, "claim", "--next", "--json")).code, 0)
 
@@ -377,34 +451,35 @@ test("maxOpenCount caps every claim repo-wide; --force is the escape", async ()
   const capped = await cli(b, "claim", "--next")
   assert.equal(capped.code, 2)
   assert.match(capped.stderr, /maxOpenCount cap \(1\)/)
-  const explicit = await cli(b, "claim", "ROO-1")
+  const explicit = await cli(b, "claim", `ROO-${rootKey}`)
   assert.equal(explicit.code, 2)
   assert.match(explicit.stderr, /maxOpenCount cap \(1\)/)
 
   const forced = await cli(b, "claim", "--next", "--force", "--json")
   assert.equal(forced.code, 0, forced.stderr)
-  assert.equal((JSON.parse(forced.stdout) as { task: { id: string } }).task.id, "ROO-1")
+  assert.equal((JSON.parse(forced.stdout) as { task: { id: string } }).task.id, `ROO-${rootKey}`)
 })
 
 test("release requires a reason and leaves it as a comment on the ticket", async () => {
-  const { clone } = fixture()
+  const { clone, keys } = fixture()
   const dir = clone()
-  assert.equal((await cli(dir, "claim", "1")).code, 0)
+  assert.equal((await cli(dir, "claim", keys.one)).code, 0)
 
   // No comment, and an empty one, are both refused before anything happens.
-  const missing = await cli(dir, "claim", "--release", "1")
+  const missing = await cli(dir, "claim", "--release", keys.one)
   assert.equal(missing.code, 1)
   assert.match(missing.stderr, /requires --comment/)
-  const empty = await cli(dir, "claim", "--release", "1", "--comment", "")
+  const empty = await cli(dir, "claim", "--release", keys.one, "--comment", "")
   assert.equal(empty.code, 1)
   assert.match(empty.stderr, /requires --comment/)
-  assert.match(
-    sh(dir, "git", "ls-remote", "--heads", "origin", "task/claim/clm-1"),
-    /clm-1/,
+  assert.ok(
+    sh(dir, "git", "ls-remote", "--heads", "origin", `task/claim/clm-${keys.one}`).includes(
+      `clm-${keys.one}`,
+    ),
   )
 
   const released = await cli(
-    dir, "claim", "--release", "1",
+    dir, "claim", "--release", keys.one,
     "--comment", "the migration kept flaking — needs a fixture, not a retry",
     "--author", "claude",
   )
@@ -412,19 +487,215 @@ test("release requires a reason and leaves it as a comment on the ticket", async
 
   // The reason survives the branch: an ordinary attributed comment, sitting
   // uncommitted in the working tree on the default branch.
-  const shown = await cli(dir, "show", "1", "--json")
+  const shown = await cli(dir, "show", keys.one, "--json")
   const { comments } = JSON.parse(shown.stdout) as {
     comments: { author: string; body: string }[]
   }
   assert.equal(comments.length, 1)
   assert.equal(comments[0].author, "claude")
   assert.match(comments[0].body, /kept flaking/)
-  assert.match(sh(dir, "git", "status", "--porcelain"), /tickets\/1\/comments/)
+  assert.ok(sh(dir, "git", "status", "--porcelain").includes(`tickets/${keys.one}/comments`))
 
   // Releasing an unclaimed ticket stays a no-op — no second comment.
-  const noop = await cli(dir, "claim", "--release", "1", "--comment", "again")
+  const noop = await cli(dir, "claim", "--release", keys.one, "--comment", "again")
   assert.equal(noop.code, 0)
   assert.match(noop.stdout, /wasn't claimed/)
-  const after = await cli(dir, "show", "1", "--json")
+  const after = await cli(dir, "show", keys.one, "--json")
   assert.equal((JSON.parse(after.stdout) as { comments: unknown[] }).comments.length, 1)
 })
+
+test("--lock-only claims from a dirty, branch-pinned checkout without touching it", async () => {
+  const { clone, keys } = fixture()
+  const dir = clone()
+  const branch = `task/claim/clm-${keys.one}`
+
+  // The branch-pinned session: a provisioned branch, uncommitted tracked work.
+  sh(dir, "git", "checkout", "--quiet", "-b", "pinned")
+  const gitignore = join(dir, ".task", ".gitignore")
+  writeFileSync(gitignore, `${readFileSync(gitignore, "utf8")}\nwip\n`)
+
+  const claimed = await cli(dir, "claim", keys.one, "--lock-only", "--json")
+  assert.equal(claimed.code, 0, claimed.stderr)
+  const parsed = JSON.parse(claimed.stdout) as {
+    task: { status: string }
+    branch: string
+    deliveredBy: string
+  }
+  assert.equal(parsed.branch, branch)
+  assert.equal(parsed.deliveredBy, "pinned")
+  assert.equal(parsed.task.status, "in_progress")
+
+  // The checkout is exactly where it was: same branch, same dirty file, and
+  // the local ticket file never flipped — the claim lives on origin only.
+  assert.equal(sh(dir, "git", "rev-parse", "--abbrev-ref", "HEAD"), "pinned")
+  assert.match(sh(dir, "git", "status", "--porcelain", "-uno"), /\.task\/\.gitignore/)
+  assert.match(readFileSync(join(dir, ".task", "tickets", keys.one, "ticket.md"), "utf8"), /status: todo/)
+
+  // On origin the claim is a real flip commit built on the default branch,
+  // carrying the delivery branch as a trailer.
+  assert.ok(sh(dir, "git", "ls-remote", "--heads", "origin", branch).includes(`refs/heads/${branch}`))
+  assert.equal(
+    sh(dir, "git", "rev-parse", `origin/${branch}~1`),
+    sh(dir, "git", "rev-parse", "origin/main"),
+  )
+  assert.match(sh(dir, "git", "show", `origin/${branch}:.task/tickets/${keys.one}/ticket.md`), /status: in_progress/)
+  const message = sh(dir, "git", "log", "-1", "--format=%B", `origin/${branch}`)
+  assert.match(message, /lock-only/)
+  assert.match(message, new RegExp(`delivered_by: pinned`))
+
+  // The lock is the same lock: both claim flavors lose to it from elsewhere.
+  const other = clone()
+  assert.equal((await cli(other, "claim", keys.one)).code, 1)
+  assert.equal((await cli(other, "claim", keys.one, "--lock-only")).code, 1)
+
+  // Release is symmetric: no local branch to delete, the origin one goes, and
+  // the pinned checkout still isn't touched.
+  const released = await cli(dir, "claim", "--release", keys.one, "--comment", "handing back a lock-only claim")
+  assert.equal(released.code, 0, released.stderr)
+  assert.equal(sh(dir, "git", "rev-parse", "--abbrev-ref", "HEAD"), "pinned")
+  assert.equal(sh(dir, "git", "ls-remote", "--heads", "origin", branch), "")
+  assert.equal((await cli(other, "claim", keys.one)).code, 0)
+})
+
+test("--lock-only validates against origin's default branch, not the checkout", async () => {
+  const { clone, keys } = fixture()
+  const dir = clone()
+
+  // Not todo on the base tree → exit 2, and nothing minted on origin.
+  const parked = await cli(dir, "claim", keys.parked, "--lock-only")
+  assert.equal(parked.code, 2)
+  assert.match(parked.stderr, /is backlog on origin\/main/)
+
+  // A local promote that hasn't landed on the default branch doesn't count:
+  // the flip commit is built on origin/main, where the ticket is still backlog.
+  assert.equal((await cli(dir, "promote", keys.parked)).code, 0)
+  const promoted = await cli(dir, "claim", keys.parked, "--lock-only")
+  assert.equal(promoted.code, 2)
+  assert.match(promoted.stderr, /is backlog on origin\/main/)
+  assert.equal(sh(dir, "git", "ls-remote", "--heads", "origin", `task/claim/clm-${keys.parked}`), "")
+
+  // Blocked on the base tree refuses too.
+  const blocked = await cli(dir, "claim", keys.blocked, "--lock-only")
+  assert.equal(blocked.code, 2)
+  assert.match(blocked.stderr, new RegExp(`blocked by CLM-${keys.one}`))
+})
+
+test("plain claim warns when it moves the checkout off a non-default branch", async () => {
+  const { clone, keys } = fixture()
+  const dir = clone()
+  sh(dir, "git", "checkout", "--quiet", "-b", "feature")
+
+  const claimed = await cli(dir, "claim", keys.one)
+  assert.equal(claimed.code, 0, claimed.stderr)
+  assert.match(claimed.stdout, /moved you off feature/)
+  assert.match(claimed.stdout, /--lock-only/)
+
+  // From the default branch there is nothing to warn about.
+  const other = clone()
+  const quiet = await cli(other, "claim", keys.two)
+  assert.equal(quiet.code, 0, quiet.stderr)
+  assert.doesNotMatch(quiet.stdout, /moved you off/)
+})
+
+test("sweep deletes done/canceled/missing claims and keeps live ones", async () => {
+  const { clone, keys } = fixture()
+  const a = clone()
+  assert.equal((await cli(a, "claim", keys.one)).code, 0)
+  assert.equal((await cli(a, "claim", keys.two)).code, 0)
+  assert.equal((await cli(a, "claim", keys.person)).code, 0)
+
+  // A second checkout is where the tickets' fates land (a merge, normally):
+  // one finishes, person is canceled, two stays live — plus a branch under
+  // the namespace whose ticket never existed.
+  const b = clone()
+  assert.equal((await cli(b, "move", keys.one, "done")).code, 0)
+  assert.equal((await cli(b, "move", keys.person, "canceled")).code, 0)
+  sh(b, "git", "push", "--quiet", "origin", "main:refs/heads/task/claim/clm-zz9zz")
+  // Namespace squatters sweep must NOT touch: a pre-migration numeric claim
+  // (its branch may head an open PR carrying unmerged work — the TAS-31 case)
+  // and a branch matching no board's prefix. Skipped and reported, never
+  // deleted — sweep's jurisdiction is exactly the names `claim` mints.
+  sh(b, "git", "push", "--quiet", "origin", "main:refs/heads/task/claim/clm-31")
+  sh(b, "git", "push", "--quiet", "origin", "main:refs/heads/task/claim/other-zz9zz")
+
+  const swept = await cli(b, "sweep", "--json")
+  assert.equal(swept.code, 0, swept.stderr)
+  const { sweep } = JSON.parse(swept.stdout) as {
+    sweep: {
+      swept: { branch: string; reason: string }[]
+      kept: { branch: string; status: string }[]
+      skipped: string[]
+      failed: unknown[]
+    }
+  }
+  assert.deepEqual(
+    sweep.swept.map((s) => [s.branch, s.reason]).sort(),
+    [
+      [`task/claim/clm-${keys.one}`, "done"],
+      [`task/claim/clm-${keys.person}`, "canceled"],
+      ["task/claim/clm-zz9zz", "missing"],
+    ].sort(),
+  )
+  assert.deepEqual(sweep.kept, [
+    { branch: `task/claim/clm-${keys.two}`, ticket: `CLM-${keys.two}`, status: "todo" },
+  ])
+  assert.deepEqual(sweep.skipped.sort(), ["task/claim/clm-31", "task/claim/other-zz9zz"])
+  assert.equal(sweep.failed.length, 0)
+
+  // Origin agrees: the live claim and the out-of-scheme branches survive,
+  // and a re-run is a no-op.
+  const remote = sh(b, "git", "ls-remote", "--heads", "origin", "task/claim/*")
+  assert.deepEqual(
+    remote.split("\n").map((l) => l.split("refs/heads/")[1]).sort(),
+    ["task/claim/clm-31", `task/claim/clm-${keys.two}`, "task/claim/other-zz9zz"].sort(),
+  )
+  const again = await cli(b, "sweep", "--json")
+  assert.equal(again.code, 0)
+  assert.equal((JSON.parse(again.stdout) as { sweep: { swept: unknown[] } }).sweep.swept.length, 0)
+})
+
+test(
+  "verified deletion: a remote that drops deletions makes release and sweep fail loudly",
+  { skip: process.platform === "win32" },
+  async () => {
+    const { clone, keys } = fixture()
+    const path = deleteDroppingPath()
+    const dir = clone()
+    assert.equal((await cli(dir, "claim", keys.one)).code, 0)
+
+    // Release under the shim: git says the deletion worked, the ref survives —
+    // pre-TAS-8b7s9 this reported "released" and left a stale lock behind.
+    const released = await cliEnv(
+      dir, { PATH: path },
+      "claim", "--release", keys.one, "--comment", "should not land",
+    )
+    assert.notEqual(released.code, 0)
+    assert.match(released.stderr, /origin still has/)
+    assert.doesNotMatch(released.stdout, /released CLM/)
+    assert.ok(
+      sh(dir, "git", "ls-remote", "--heads", "origin", `task/claim/clm-${keys.one}`).includes(
+        `clm-${keys.one}`,
+      ),
+    )
+    // No release, no comment: the failure must not read as a done release.
+    const shown = await cli(dir, "show", keys.one, "--json")
+    assert.equal((JSON.parse(shown.stdout) as { comments: unknown[] }).comments.length, 0)
+
+    // Sweep under the shim reports the failed deletion and exits non-zero.
+    const b = clone()
+    assert.equal((await cli(b, "move", keys.one, "done")).code, 0)
+    const blocked = await cliEnv(b, { PATH: path }, "sweep", "--json")
+    assert.equal(blocked.code, 1)
+    const { sweep } = JSON.parse(blocked.stdout) as {
+      sweep: { swept: unknown[]; failed: { branch: string; error: string }[] }
+    }
+    assert.equal(sweep.swept.length, 0)
+    assert.equal(sweep.failed.length, 1)
+    assert.match(sweep.failed[0].error, /origin still has/)
+
+    // A capable runner heals it: the same sweep with real git succeeds.
+    const healed = await cli(b, "sweep")
+    assert.equal(healed.code, 0, healed.stderr)
+    assert.equal(sh(b, "git", "ls-remote", "--heads", "origin", `task/claim/clm-${keys.one}`), "")
+  },
+)