@nickmeriano/task 0.8.0 → 0.10.0

package/dist/claim.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claim.test.d.ts","sourceRoot":"","sources":["../src/claim.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}
+{"version":3,"file":"claim.test.d.ts","sourceRoot":"","sources":["../src/claim.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG"}

package/dist/claim.test.js

@@ -6,15 +6,23 @@
  * 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";
@@ -35,24 +43,44 @@ function sh(cwd, command, ...args) {
 }
 /** The CLI as callers see it — a subprocess with an exit code. */
 function cli(cwd, ...args) {
+    return cliEnv(cwd, {}, ...args);
+}
+/** Like cli(), with extra env — the delete-dropping git shim rides in PATH. */
+function cliEnv(cwd, env, ...args) {
     return new Promise((resolve) => {
-        execFile(process.execPath, ["--experimental-strip-types", CLI, ...args], { cwd }, (error, stdout, stderr) => {
+        execFile(process.execPath, ["--experimental-strip-types", CLI, ...args], { cwd, env: { ...process.env, ...env } }, (error, stdout, stderr) => {
             resolve({ code: error ? (error.code ?? 1) : 0, stdout, stderr });
         });
     });
 }
+/**
+ * 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() {
+    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 ?? ""}`;
+}
 /**
  * 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) {
+function fixture(branchPrefix) {
     const home = tempDir();
     const bare = join(home, "origin.git");
     sh(home, "git", "init", "--quiet", "--bare", "-b", "main", bare);
@@ -61,20 +89,29 @@ function fixture(claimPrefix) {
     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"));
-        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");
@@ -86,113 +123,120 @@ function fixture(claimPrefix) {
         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;
     const loser = ra.code === 0 ? rb : ra;
     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");
-    assert.match(readFileSync(join(winner, ".task", "tickets", "1", "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/);
+    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", keys.one, "ticket.md"), "utf8"), /status: in_progress/);
+    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"]);
+    assert.deepEqual(remote.split("\n").map((l) => l.split("refs/heads/")[1]), [`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);
-    // 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]);
+    // 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
-    const released = await cli(dir, "claim", "--release", "2", "--comment", "trying another shape");
+    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", 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.match(readFileSync(join(dir, ".task", "tickets", "2", "ticket.md"), "utf8"), /status: todo/);
-    assert.equal((await cli(dir, "claim", "2")).code, 0);
+    assert.equal(sh(dir, "git", "ls-remote", "--heads", "origin", `task/claim/clm-${keys.two}`), "");
+    assert.match(readFileSync(join(dir, ".task", "tickets", keys.two, "ticket.md"), "utf8"), /status: todo/);
+    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);
-    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);
+    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"));
-    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"));
+    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/);
 });
-/**
- * A monorepo with two boards for the multi-board selection paths (TAS-27):
- * a root board (ROO, one ready ticket) and a nested one under pkg/ (NES,
- * one ready ticket). The root config carries the new `claims` block and,
- * optionally, the top-level `boards` list — NES deliberately ahead of ROO,
- * so priority provably follows list order, not nearness.
- */
 function multiFixture(options = {}) {
     const home = tempDir();
     const bare = join(home, "origin.git");
@@ -208,10 +252,10 @@ function multiFixture(options = {}) {
         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");
     sh(seed, "git", "push", "--quiet", "-u", "origin", "main");
@@ -223,10 +267,10 @@ function multiFixture(options = {}) {
         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 = [];
     for (;;) {
@@ -237,12 +281,13 @@ test("claim --next drains the queue in position order and exits 1 when empty", a
         }
         assert.equal(result.code, 0, result.stderr);
         const { task, branch } = JSON.parse(result.stdout);
-        order.push(task.number);
+        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 () => {
     const { clone } = fixture();
@@ -258,40 +303,40 @@ test("two concurrent claim --next calls land on different tickets", async () =>
     assert.notEqual(ids[0], ids[1], `both claimed ${ids[0]}`);
 });
 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);
-    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);
-    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).task.id, "ROO-1");
+    assert.equal(JSON.parse(overridden.stdout).task.id, `ROO-${rootKey}`);
     const unknown = await cli(b, "claim", "--next", "--board", "NOPE");
     assert.equal(unknown.code, 2);
     assert.match(unknown.stderr, /no board with prefix NOPE/);
 });
 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).task.id, "ROO-1");
+    assert.equal(JSON.parse(next.stdout).task.id, `ROO-${rootKey}`);
     // ROO's queue is drained and NES never entered the scope.
     const empty = await cli(dir, "claim", "--next", "--json");
     assert.equal(empty.code, 1);
 });
 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);
     // At the cap, --next and explicit-id claims both refuse with exit 2 —
@@ -300,40 +345,181 @@ 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).task.id, "ROO-1");
+    assert.equal(JSON.parse(forced.stdout).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/);
-    const released = await cli(dir, "claim", "--release", "1", "--comment", "the migration kept flaking — needs a fixture, not a retry", "--author", "claude");
+    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", keys.one, "--comment", "the migration kept flaking — needs a fixture, not a retry", "--author", "claude");
     assert.equal(released.code, 0, released.stderr);
     // 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);
     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).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);
+    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);
+    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).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).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);
+    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}`), "");
+});
 //# sourceMappingURL=claim.test.js.map