@rallycry/conveyor-skills 1.0.11 → 1.0.13

package/README.md

@@ -17,6 +17,7 @@ normal dependency bumps: no git submodules, no manual syncing.
 | `conveyor-start` | `/conveyor-start <card>` | Hand a planned card to a cloud pod, confirm the environment came up, report where to watch it (local surface only) |
 | `conveyor-build` | `/conveyor-build <card>` | Execute a planned card to a PR — one task or a whole feature-branch pack |
 | `conveyor-review` | `/conveyor-review <card>` | Review the PR against its plan and render one verdict, with risk |
+| `conveyor-release-review` | `/conveyor-release-review [release]` | Audit everything in a pending release, keep only findings backed by evidence that survive an adversarial pass, and file them by priority as a blocker pack and a suggestions pack (local surface only) |
 | `conveyor-consensus` | `/conveyor-consensus <question>` | Sweep the sources a project actually has, count what happened, score the proposals against those counts, and attach an HTML verdict to the card |
 | `conveyor-local-loop` | `/loop /conveyor-local-loop` | Run this machine as a serial local agent: claim Open cards and packs, build to PR, repeat |
 | `conveyor-prune` | `/conveyor-prune [project\|all]` | Sweep every Planning/Open card, give each one disposition (cancel, park on hold, merge into a pack, keep), apply only the confirmed rows (local surface only) |
@@ -79,6 +80,33 @@ and safe:
 - `conveyor-skills link --check` verifies the links without changing anything
   (exit 1 when out of date) — useful in CI.
 
+## Taking turns on one checkout
+
+Local agent sessions that share one git checkout take turns on it.
+`/conveyor-build`, `/conveyor-local-loop` and local `/conveyor-review` fixes
+hold a **checkout claim** while they use the working tree; a second session
+that finds it held says so and waits instead of switching branches underneath
+the first. Cloud pods have their own checkout and skip this.
+
+The claim is one file in the git dir (`.git/conveyor-checkout-claim.json`, or
+the per-worktree git dir), so it is never committed and never shows in
+`git status`. The skills drive it through the same bin:
+
+```bash
+conveyor-skills checkout acquire --card <slug> [--branch <b>]  # take / refresh
+conveyor-skills checkout verify  --card <slug>                 # still mine? (heartbeat)
+conveyor-skills checkout release --card <slug>                 # give it back
+conveyor-skills checkout status                                # who holds it
+conveyor-skills checkout wait --timeout 1740                   # block until free
+```
+
+Each command prints one JSON line. A claim goes stale when its holder's
+process is dead, when the same process started a new session, or when its
+heartbeat is older than two hours (`CONVEYOR_CHECKOUT_CLAIM_TTL_SECONDS`).
+`conveyor-skills checkout release --force` is the human override for a wedged
+claim. The full protocol lives in
+[`skills/conveyor-build/references/checkout-claim.md`](skills/conveyor-build/references/checkout-claim.md).
+
 ## Versioning
 
 Versions are cut automatically from git tags on the Conveyor repo's `main`

package/bin/checkout-claim.mjs

@@ -0,0 +1,524 @@
+// conveyor-skills checkout — make local agent sessions that share one git
+// checkout take turns on it. A session holds the claim while it uses the
+// working tree; any other session that finds the claim held waits instead of
+// switching branches underneath the holder.
+//
+// The claim is one JSON file in the per-worktree git dir
+// (`git rev-parse --absolute-git-dir`), so it is never committed, never shows
+// in `git status`, survives branch switches, and linked worktrees get
+// independent claims. Pods have their own checkout and never call this.
+//
+// Every command prints exactly ONE JSON line on stdout; hints go to stderr.
+// Node built-ins only — this ships in the published package next to cli.mjs.
+
+import { spawnSync } from "node:child_process";
+import {
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { hostname as osHostname } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+
+export const CLAIM_FILE = "conveyor-checkout-claim.json";
+export const MUTEX_DIR = "conveyor-checkout-claim.mutex";
+export const SCHEMA = 1;
+export const DEFAULT_TTL_SECONDS = 7200;
+export const DEFAULT_WAIT_TIMEOUT_SECONDS = 1740;
+export const DEFAULT_WAIT_INTERVAL_SECONDS = 5;
+const MUTEX_RETRY_MS = 2000;
+const MUTEX_STALE_MS = 30_000;
+
+export const EXIT = { ok: 0, error: 1, held: 3, branchMoved: 4, dirty: 5 };
+
+const USAGE = `Usage: conveyor-skills checkout <command> [options]
+
+Commands:
+  acquire --card <slug> [--branch <b>]   take or refresh the checkout claim
+  verify  --card <slug> [--branch <b>]   confirm the claim is still yours (also a heartbeat)
+  release --card <slug> [--force]        drop the claim (--force: drop someone else's)
+  status                                 show the claim; always exits 0
+  wait [--timeout 1740] [--interval 5]   block until the claim is free, stale, or yours
+
+Options:
+  --session <id>   session identity (default: CONVEYOR_SESSION_ID, then
+                   CLAUDE_CODE_SESSION_ID, then card:<slug>)
+  --ttl <secs>     heartbeat age after which a claim is stale
+                   (default: CONVEYOR_CHECKOUT_CLAIM_TTL_SECONDS or ${DEFAULT_TTL_SECONDS})
+
+Exit codes: 0 ok, 1 usage error or not a git repo, 3 held by another session
+(or lost), 4 branch moved under the claim, 5 dirty tree.
+`;
+
+/** Marker for a claim file that exists but does not parse as a claim. */
+export const CORRUPT = Object.freeze({ corrupt: true });
+
+/**
+ * Who is asking. The session id is what owns a claim; the pid (the Claude Code
+ * process, when the harness exports it) is what lets a same-host caller prove
+ * a holder is dead instead of waiting out the TTL.
+ */
+export function resolveIdentity({ session, card, env = process.env } = {}) {
+  const resolved =
+    session ||
+    env.CONVEYOR_SESSION_ID ||
+    env.CLAUDE_CODE_SESSION_ID ||
+    (card ? `card:${card}` : null);
+  const pid = Number.parseInt(env.CLAUDE_PID ?? "", 10);
+  return { session: resolved, pid: Number.isInteger(pid) && pid > 0 ? pid : null };
+}
+
+export function defaultPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // EPERM: the process exists but belongs to someone else — alive.
+    return err?.code === "EPERM";
+  }
+}
+
+function isClaimRecord(value) {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    typeof value.session === "string" &&
+    typeof value.host === "string" &&
+    !Number.isNaN(Date.parse(value.heartbeatAt))
+  );
+}
+
+/**
+ * Classify an existing claim relative to the caller.
+ * kind: none | own | live | stale | corrupt. `reason` explains a stale verdict.
+ */
+export function classifyClaim(claim, { identity, now, hostname, pidAlive, ttlSeconds }) {
+  if (claim === null || claim === undefined) return { kind: "none" };
+  if (!isClaimRecord(claim)) return { kind: "corrupt" };
+  const ageSeconds = Math.max(0, Math.round((now - Date.parse(claim.heartbeatAt)) / 1000));
+  if (identity.session && claim.session === identity.session) return { kind: "own", ageSeconds };
+  if (claim.host === hostname && Number.isInteger(claim.pid)) {
+    if (!pidAlive(claim.pid)) return { kind: "stale", reason: "pid-dead", ageSeconds };
+    // Same live process, new session id: the holder ran /clear and moved on.
+    if (identity.pid === claim.pid)
+      return { kind: "stale", reason: "same-pid-new-session", ageSeconds };
+  }
+  if (ageSeconds > ttlSeconds) return { kind: "stale", reason: "ttl-expired", ageSeconds };
+  return { kind: "live", ageSeconds };
+}
+
+/**
+ * What `acquire` does with a classified claim.
+ * A stale claim is only taken over on a clean tree, or when it names the same
+ * card (the tree is that card's own unfinished work). No claim + dirty tree is
+ * refused: someone who never took a claim is mid-change.
+ */
+export function decideAcquire({ classification, claim, card, dirty }) {
+  switch (classification.kind) {
+    case "own":
+      return { write: true, state: "refreshed" };
+    case "none":
+      return dirty ? { write: false, state: "dirty" } : { write: true, state: "acquired" };
+    case "stale":
+      return !dirty || claim.card === card
+        ? { write: true, state: "took-over" }
+        : { write: false, state: "dirty" };
+    default:
+      // live, corrupt
+      return { write: false, state: "held" };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// git + filesystem
+
+function git(cwd, args, env) {
+  const result = spawnSync("git", args, { cwd, env, encoding: "utf8" });
+  return {
+    ok: result.status === 0,
+    out: (result.stdout ?? "").trim(),
+    err: (result.stderr ?? "").trim(),
+  };
+}
+
+function readRepo(cwd, env) {
+  const gitDir = git(cwd, ["rev-parse", "--absolute-git-dir"], env);
+  if (!gitDir.ok) return null;
+  const head = git(cwd, ["symbolic-ref", "--short", "-q", "HEAD"], env);
+  // --no-optional-locks: never take index.lock, so a status read cannot
+  // collide with the holder's own git commands.
+  const status = git(cwd, ["--no-optional-locks", "status", "--porcelain"], env);
+  return {
+    gitDir: gitDir.out,
+    head: head.ok && head.out ? head.out : null,
+    dirty: status.out.length > 0,
+  };
+}
+
+function readClaim(path) {
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch (err) {
+    if (err?.code === "ENOENT") return null;
+    throw err;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return isClaimRecord(parsed) ? parsed : CORRUPT;
+  } catch {
+    return CORRUPT;
+  }
+}
+
+function writeClaim(path, record) {
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(record, null, 2)}\n`);
+  renameSync(tmp, path);
+}
+
+function removeClaim(path) {
+  try {
+    unlinkSync(path);
+  } catch (err) {
+    if (err?.code !== "ENOENT") throw err;
+  }
+}
+
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+/** Run `fn` inside a mkdir-based critical section; mkdir is atomic everywhere. */
+function withMutex(gitDir, fn) {
+  const mutex = join(gitDir, MUTEX_DIR);
+  const deadline = Date.now() + MUTEX_RETRY_MS;
+  for (;;) {
+    try {
+      mkdirSync(mutex);
+      break;
+    } catch (err) {
+      if (err?.code !== "EEXIST") throw err;
+      try {
+        if (Date.now() - statSync(mutex).mtimeMs > MUTEX_STALE_MS) {
+          rmSync(mutex, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+        // Vanished between mkdir and stat — retry.
+        continue;
+      }
+      if (Date.now() > deadline) return { busy: true };
+      sleepSync(25 + Math.floor(Math.random() * 25));
+    }
+  }
+  try {
+    return { value: fn() };
+  } finally {
+    rmSync(mutex, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// CLI
+
+function parseArgs(argv) {
+  const opts = { _: [] };
+  const valued = new Set(["card", "branch", "session", "ttl", "timeout", "interval"]);
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) {
+      opts._.push(arg);
+      continue;
+    }
+    const [key, inline] = arg.slice(2).split(/=(.*)/s, 2);
+    if (valued.has(key)) {
+      const value = inline ?? argv[(i += 1)];
+      if (value === undefined || value === "") throw new Error(`--${key} needs a value`);
+      opts[key] = value;
+    } else if (key === "force" || key === "help") {
+      opts[key] = true;
+    } else {
+      throw new Error(`unknown option --${key}`);
+    }
+  }
+  return opts;
+}
+
+function positiveNumber(raw, name) {
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n <= 0) throw new Error(`--${name} must be a positive number`);
+  return n;
+}
+
+function describeHolder(claim, classification) {
+  if (claim === CORRUPT) return { corrupt: true };
+  return {
+    ...claim,
+    ageSeconds: classification.ageSeconds,
+    stale: classification.kind === "stale",
+  };
+}
+
+function holderHint(holder) {
+  if (holder.corrupt)
+    return "the claim file does not parse — a human decides: `conveyor-skills checkout release --force`";
+  const pid = holder.pid ? ` pid ${holder.pid}` : "";
+  return `checkout held by card ${holder.card ?? "?"} on branch ${holder.branch ?? "(detached)"} (${holder.host}${pid}, heartbeat ${holder.ageSeconds}s ago) — do not touch the tree; run \`conveyor-skills checkout wait\``;
+}
+
+const HINTS = {
+  dirty:
+    "working tree is dirty and no live claim covers it — touch nothing; the user commits or stashes",
+  "branch-moved": "HEAD is not the claimed branch — do not commit or push; report it",
+  lost: "you no longer hold the checkout claim — stop and re-acquire before touching the tree",
+};
+
+const COMMANDS = ["acquire", "verify", "release", "status", "wait"];
+
+const EXIT_BY_STATE = {
+  held: EXIT.held,
+  lost: EXIT.held,
+  "branch-moved": EXIT.branchMoved,
+  dirty: EXIT.dirty,
+};
+
+/** Validate parsed options; returns an error message or null. */
+function usageProblem(command, opts) {
+  if (!COMMANDS.includes(command)) return `unknown checkout command '${command}'`;
+  if (["acquire", "verify"].includes(command) && !opts.card)
+    return `${command} needs --card <slug>`;
+  if (command === "release" && !opts.card && !opts.force)
+    return "release needs --card <slug> (or --force)";
+  return null;
+}
+
+function acquireOp({ ctx, claim, classification, stamp }) {
+  const { opts, repo, identity, hostname, claimPath } = ctx;
+  const decision = decideAcquire({ classification, claim, card: opts.card, dirty: repo.dirty });
+  if (!decision.write) return { state: decision.state };
+  const kept = classification.kind === "own" ? claim : null;
+  const record = {
+    schema: SCHEMA,
+    session: identity.session,
+    pid: identity.pid,
+    host: hostname,
+    card: opts.card,
+    branch: opts.branch ?? kept?.branch ?? repo.head,
+    acquiredAt: kept?.acquiredAt ?? stamp,
+    heartbeatAt: stamp,
+  };
+  writeClaim(claimPath, record);
+  return { state: decision.state, record };
+}
+
+function verifyOp({ ctx, claim, classification, stamp }) {
+  const { opts, repo, identity, claimPath } = ctx;
+  if (classification.kind !== "own") return { state: "lost" };
+  const expected = opts.branch ?? claim.branch;
+  if (expected && repo.head !== expected) return { state: "branch-moved", expected };
+  const record = { ...claim, pid: identity.pid ?? claim.pid, heartbeatAt: stamp };
+  writeClaim(claimPath, record);
+  return { state: "ok", record };
+}
+
+function releaseOp({ ctx, classification }) {
+  if (classification.kind === "none") return { state: "none" };
+  if (classification.kind !== "own" && !ctx.opts.force) return { state: "held" };
+  removeClaim(ctx.claimPath);
+  return { state: "released" };
+}
+
+const MUTATIONS = { acquire: acquireOp, verify: verifyOp, release: releaseOp };
+
+/** Run a mutating command inside the mutex: read, decide, write. */
+function mutate(ctx) {
+  // Test-only: widen the read→write window so the parallel-acquire test fails
+  // loudly if the mutex ever stops serializing callers.
+  const holdMs = Number(ctx.env.CONVEYOR_CHECKOUT_CLAIM_TEST_HOLD_MS) || 0;
+  return withMutex(ctx.repo.gitDir, () => {
+    const claim = readClaim(ctx.claimPath);
+    const classification = ctx.classify(claim);
+    if (holdMs > 0) sleepSync(holdMs);
+    const stamp = new Date(ctx.now()).toISOString();
+    const result = MUTATIONS[ctx.command]({ ctx, claim, classification, stamp });
+    return { ...result, claim, classification };
+  });
+}
+
+/** The JSON line and the stderr hint for a finished mutation. */
+function describeOutcome(base, outcome) {
+  const { state, claim, classification, record, expected } = outcome;
+  const payload = { ...base, state };
+  if (state === "took-over") payload.reason = classification.reason;
+  if (record) payload.claim = record;
+  if (expected) payload.expectedBranch = expected;
+  let hint = HINTS[state] ?? null;
+  if (["held", "lost"].includes(state) && claim !== null) {
+    payload.holder = describeHolder(claim, classification);
+    if (state === "held" || classification.kind === "corrupt") hint = holderHint(payload.holder);
+  }
+  if (state === "took-over")
+    hint = `took over a stale claim (${classification.reason}) from card ${claim.card ?? "?"}`;
+  return { payload, hint };
+}
+
+/** Parse argv into a command; throws on a usage error. */
+function parseCommand(argv, env) {
+  const opts = parseArgs(argv);
+  const ttlSeconds = positiveNumber(
+    opts.ttl ?? env.CONVEYOR_CHECKOUT_CLAIM_TTL_SECONDS ?? DEFAULT_TTL_SECONDS,
+    "ttl",
+  );
+  return { opts, command: opts._[0], ttlSeconds };
+}
+
+/** Everything a command needs to read and judge the claim. */
+function buildContext({ command, opts, ttlSeconds, env, repo, deps }) {
+  const now = deps.now ?? (() => Date.now());
+  const hostname = deps.hostname ?? osHostname();
+  const pidAlive = deps.pidAlive ?? defaultPidAlive;
+  const identity = resolveIdentity({ session: opts.session, card: opts.card, env });
+  const claimPath = join(repo.gitDir, CLAIM_FILE);
+  const classify = (claim) =>
+    classifyClaim(claim, { identity, now: now(), hostname, pidAlive, ttlSeconds });
+  const base = { command, head: repo.head, dirty: repo.dirty, file: claimPath };
+  return { command, opts, env, repo, identity, hostname, claimPath, classify, now, base };
+}
+
+async function runStatus({ ctx, emit }) {
+  const claim = readClaim(ctx.claimPath);
+  const classification = ctx.classify(claim);
+  await emit({
+    ...ctx.base,
+    state: classification.kind,
+    ...(classification.reason ? { reason: classification.reason } : {}),
+    claim: claim === null ? null : describeHolder(claim, classification),
+  });
+  return EXIT.ok;
+}
+
+async function runMutation({ ctx, emit, hint, fail }) {
+  const outcome = mutate(ctx);
+  if (outcome.busy) {
+    const message = `could not take ${MUTEX_DIR} within ${MUTEX_RETRY_MS}ms — another session is mid-claim; retry`;
+    return fail(message, ctx.base);
+  }
+  const { payload, hint: message } = describeOutcome(ctx.base, outcome.value);
+  if (message) hint(message);
+  await emit(payload);
+  return EXIT_BY_STATE[payload.state] ?? EXIT.ok;
+}
+
+/**
+ * Run one checkout command. Resolves to the exit code; writes exactly one JSON
+ * line to `deps.stdout` and waits for it to flush.
+ */
+export async function runCheckoutCli(argv, deps = {}) {
+  const env = deps.env ?? process.env;
+  const stdout = deps.stdout ?? process.stdout;
+  const stderr = deps.stderr ?? process.stderr;
+  let command = argv.find((a) => !a.startsWith("-")) ?? null;
+  const emit = (payload) =>
+    new Promise((resolve) => {
+      stdout.write(`${JSON.stringify(payload)}\n`, () => resolve());
+    });
+  const hint = (msg) => stderr.write(`conveyor-skills checkout: ${msg}\n`);
+  const fail = async (message, extra = {}) => {
+    hint(message);
+    await emit({ command, ...extra, state: "error", error: message });
+    return EXIT.error;
+  };
+
+  let parsed;
+  try {
+    parsed = parseCommand(argv, env);
+  } catch (err) {
+    return fail(err.message);
+  }
+  if (parsed.opts.help || !parsed.command) {
+    stderr.write(USAGE);
+    await emit({ command, state: "usage" });
+    return parsed.opts.help ? EXIT.ok : EXIT.error;
+  }
+  command = parsed.command;
+  const problem = usageProblem(command, parsed.opts);
+  if (problem) return fail(problem);
+
+  const repo = readRepo(deps.cwd ?? process.cwd(), env);
+  if (!repo) return fail("not inside a git repository");
+  const ctx = buildContext({ ...parsed, env, repo, deps });
+  const io = { ctx, emit, hint, fail };
+  if (command === "status") return runStatus(io);
+  if (command === "wait") return runWait(io);
+  return runMutation(io);
+}
+
+/** Sleep up to `ms`, returning early when `signal.wake()` is called. */
+function interruptibleSleep(ms, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    signal.wake = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+  });
+}
+
+const WAIT_VERDICTS = { none: "free", stale: "stale", own: "own" };
+
+async function runWait({ ctx, emit, hint, fail }) {
+  const { opts, base, claimPath, classify } = ctx;
+  let timeoutSeconds;
+  let intervalSeconds;
+  try {
+    timeoutSeconds = positiveNumber(opts.timeout ?? DEFAULT_WAIT_TIMEOUT_SECONDS, "timeout");
+    intervalSeconds = positiveNumber(opts.interval ?? DEFAULT_WAIT_INTERVAL_SECONDS, "interval");
+  } catch (err) {
+    return fail(err.message, base);
+  }
+
+  const signal = { interrupted: false, wake: () => {} };
+  const onSignal = () => {
+    signal.interrupted = true;
+    signal.wake();
+  };
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  const deadline = Date.now() + timeoutSeconds * 1000;
+  let announced = false;
+
+  try {
+    for (;;) {
+      const claim = readClaim(claimPath);
+      const classification = classify(claim);
+      const verdict = WAIT_VERDICTS[classification.kind];
+      if (verdict) {
+        const holder =
+          claim && claim !== CORRUPT ? { holder: describeHolder(claim, classification) } : {};
+        await emit({ ...base, state: verdict, ...holder });
+        return EXIT.ok;
+      }
+      if (!announced) {
+        hint(`waiting — ${holderHint(describeHolder(claim, classification))}`);
+        announced = true;
+      }
+      if (signal.interrupted || Date.now() >= deadline) {
+        await emit({ ...base, state: signal.interrupted ? "interrupted" : "timeout" });
+        return EXIT.ok;
+      }
+      await interruptibleSleep(
+        Math.min(intervalSeconds * 1000, Math.max(0, deadline - Date.now())),
+        signal,
+      );
+    }
+  } finally {
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+  }
+}

package/bin/cli.mjs

@@ -7,6 +7,9 @@
 // Usage:
 //   conveyor-skills link      (default) create/refresh links, prune stale ones
 //   conveyor-skills link --check   verify links; exit 1 if missing/stale
+//   conveyor-skills checkout <acquire|verify|release|status|wait> ...
+//                             take turns on a shared local checkout
+//                             (see bin/checkout-claim.mjs)
 //
 // Only links owned by this package (target path contains conveyor-skills/skills/)
 // are ever replaced or pruned. Real directories and foreign symlinks are left
@@ -68,10 +71,17 @@ function ownedBy(linkPath) {
 }
 
 const args = process.argv.slice(2);
+
+if (args[0] === "checkout") {
+  const { runCheckoutCli } = await import("./checkout-claim.mjs");
+  // runCheckoutCli resolves only after its JSON line has flushed.
+  process.exit(await runCheckoutCli(args.slice(1)));
+}
+
 const checkOnly = args.includes("--check");
 const command = args.find((a) => !a.startsWith("-")) ?? "link";
 if (command !== "link")
-  fail(`unknown command '${command}' — only 'link' (with optional --check) exists`);
+  fail(`unknown command '${command}' — expected 'link' (with optional --check) or 'checkout'`);
 
 // This package's own skills/ dir, resolved through any install symlink (bun
 // may install the package as a symlink into its store).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rallycry/conveyor-skills",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Shared Claude Code skills for Conveyor consumer repos, linked into .claude/skills via the conveyor-skills CLI",
   "keywords": [
     "claude",
@@ -20,5 +20,9 @@
   "type": "module",
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "test": "node --test __tests__/checkout-claim.test.mjs",
+    "test:unit": "node --test __tests__/checkout-claim.test.mjs"
   }
 }