@afokapu/atdd-bun 0.10.99 → 0.10.101

package/integrity.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.10.99",
+  "version": "0.10.101",
   "files": {
     "HOOK_AUDIT.md": "5329d840db37671b1918f688ead26865473b87db73dbc75f7c8b2a8bbe8d6d43",
     "PLANNER_PORT.md": "fb5935bac8b7ac18994de21e43ace3a5ef8cd55f85b0e3349fca261280054f11",
@@ -1258,10 +1258,10 @@
     "relationships.yaml": "fccaf745b383fe527b7db9022233037bdf5b5cc3d495bb40da3cca4746f5e241",
     "src/agent.ts": "6d6c6e75908af8fbab13432f0001b0374bb25cf3dee46ba218dfd67e0090cb56",
     "src/ci.ts": "b5c57dd87fc780b2b272156b68830d14e695a1a28300dec46a06f71864e0c59e",
-    "src/cli.ts": "d93c3aebb78e752fd96347a5b177c0ed0697010c6e2533e116de93e772cd65a8",
+    "src/cli.ts": "395638ab87565bb10c2beb35988ff1acf686924d13515795156a2e8893b3da88",
     "src/docs-capability.ts": "bdeeb414649049b1cd4fa8008cada3a576318be51c43bec91bfa46a8e250c270",
     "src/enforce.ts": "e0c10519aeecd7080f2900ea230fad2f09482af47c1cee885d5de71573e29732",
-    "src/hooks.ts": "b96b5fee3a03c2f4c317d6725d6d21ed3133db18d0cdcdda72183cf05c7b6639",
+    "src/hooks.ts": "556a1c58699653c6c435b2cea705d74670afdc9ea0c99ee84c9cdd1342c9fef8",
     "src/index.ts": "4081f8b08d1d3ee9e15a9964143e53d9cfb94a5616ab3e58a180d24cc16dc381",
     "src/integrity.ts": "f1ede7cb04924ae88e11917047277e264af6596b9759e381bd9c497cd34a797d",
     "src/journey-docs.ts": "994d229376244c84212cff951032823068a76565dd2fd427b9d44e341bd14853",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@afokapu/atdd-bun",
-  "version": "0.10.99",
+  "version": "0.10.101",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/afokapu/atdd-bun.git"

package/src/cli.ts

@@ -22,7 +22,7 @@ const usage = {
     "atdd-bun [profile ...] [--root <path>] [--ratchet --base <full-sha> [--ratchet-activate-profiles]]",
     "atdd-bun init [--replace]",
     "atdd-bun hooks <install|uninstall|status> [--replace]",
-    "atdd-bun worktree <start|finish|status>",
+    "atdd-bun worktree <start|finish|status> [branch] [--vcs <git|jj>]",
     "atdd-bun ci <init|status> [--replace]",
     "atdd-bun agent <init|status> [--replace]",
     "atdd-bun profiles registry [--check]",
@@ -86,7 +86,10 @@ if (args[0] === "hook") {
   if (result.message) console[result.ok ? "log" : "error"](result.message); process.exit(result.ok ? 0 : 1);
 }
 if (args[0] === "worktree") {
-  const result = args[1] === "start" ? await startWorktree(process.cwd(), args[2] ?? "") : args[1] === "finish" ? await finishWorktree(process.cwd(), args.includes("--delete-branch")) : args[1] === "status" ? await worktreeStatus(process.cwd()) : fail("worktree requires start, finish, or status");
+  const vcsAt = args.indexOf("--vcs"), vcsValue = vcsAt === -1 ? "git" : args[vcsAt + 1];
+  if (vcsValue !== "git" && vcsValue !== "jj") fail("--vcs requires git or jj");
+  const branch = args[1] === "start" ? args.slice(2).find((arg, index, rest) => !arg.startsWith("-") && rest[index - 1] !== "--vcs") ?? "" : "";
+  const result = args[1] === "start" ? await startWorktree(process.cwd(), branch, vcsValue) : args[1] === "finish" ? await finishWorktree(process.cwd(), args.includes("--delete-branch"), vcsValue) : args[1] === "status" ? await worktreeStatus(process.cwd(), vcsValue) : fail("worktree requires start, finish, or status");
   console[result.ok ? "log" : "error"](result.message); process.exit(result.ok ? 0 : 1);
 }
 if (args[0] === "ci") {

package/src/hooks.ts

@@ -61,44 +61,49 @@ async function ratchetCommitGate(root: string, staged: string[], registryChanged
   try { candidateConfig = Bun.YAML.parse(stagedConfig.out) as Record<string, unknown>; policy = parseRatchetPolicy(candidateConfig); }
   catch (error) { return bad(`ratchet activation commit gate configuration is invalid: ${String(error)}`); }
   if (policy?.mode !== "reject-new" || !Array.isArray(candidateConfig.profiles) || !candidateConfig.profiles.every(profile => typeof profile === "string")) return null;
-  if ((await git(root, ["diff", "--quiet"])).code !== 0 || (await git(root, ["ls-files", "--others", "--exclude-standard"])).out) return bad("ratchet activation commit gate requires no unstaged or untracked candidate state");
   const head = await git(root, ["rev-parse", "--verify", "HEAD^{commit}"]);
   if (head.code || !/^[0-9a-f]{40}$/i.test(head.out)) return bad("ratchet activation commit gate requires an exact committed HEAD base");
-  const scratch = await mkdtemp(join(tmpdir(), "atdd-ratchet-commit-gate-"));
+  let scratch: string | undefined;
   try {
+    scratch = await mkdtemp(join(tmpdir(), "atdd-ratchet-commit-gate-"));
     const added = await git(root, ["worktree", "add", "--detach", "--no-checkout", scratch, head.out]);
-    if (added.code) return bad(`could not materialize ratchet activation base: ${added.err || added.out}`);
+    if (added.code) throw new Error(`could not materialize ratchet activation base: ${added.err || added.out}`);
     const checkedOut = await git(scratch, ["checkout", "--detach", head.out]);
-    if (checkedOut.code) return bad(`could not checkout ratchet activation base: ${checkedOut.err || checkedOut.out}`);
+    if (checkedOut.code) throw new Error(`could not checkout ratchet activation base: ${checkedOut.err || checkedOut.out}`);
     const baseConfig = await configAt(scratch), candidateProfiles = stable(candidateConfig.profiles.map(normalizeProfileName));
     const baseProfiles = stable(await enabledProfiles(scratch));
     const policyMatches = stable(policy.profiles.map(normalizeProfileName)).join(",") === candidateProfiles.join(",");
     const activation = isStrictProfileExpansion(baseProfiles, candidateProfiles) && activationContextDigest(baseConfig) === activationContextDigest(candidateConfig);
     const unchanged = baseProfiles.join(",") === candidateProfiles.join(",") && contextDigest(baseConfig, baseProfiles) === contextDigest(candidateConfig, candidateProfiles);
     if (candidateProfiles.some(profile => !concreteProfiles.includes(profile as typeof concreteProfiles[number])) || !policyMatches || (!activation && !unchanged)) return bad("ratchet reject-new requires either unchanged explicit profiles/context or an explicit monotonic profile expansion with identical non-profile context");
-    const selectedProfiles = activation || staged.some(needsFullCommitRatchetProfiles) ? candidateProfiles : (await affectedProfiles(root, staged, registryChanged)).filter(profile => candidateProfiles.includes(profile));
     const tree = await git(root, ["write-tree"]);
     if (tree.code || !/^[0-9a-f]{40}$/i.test(tree.out)) return bad(`could not identify staged ratchet activation candidate: ${tree.err || tree.out}`);
     const baseTree = await git(root, ["rev-parse", "--verify", `${head.out}^{tree}`]);
     if (baseTree.code || !/^[0-9a-f]{40}$/i.test(baseTree.out)) return bad(`could not identify ratchet activation base tree: ${baseTree.err || baseTree.out}`);
-    const normalize = (findings: Awaited<ReturnType<typeof enforce>>) => findings.map(finding => ({ ...finding, file: canonicalFindingPath(scratch, finding.file) }));
-    // Scan and cache the unpatched HEAD before materializing the staged candidate; both keys remain exact Git trees.
-    const cacheDirectory = await findingsCacheDirectory(root), toolkit = await toolkitIdentity().catch(() => null);
-    const findingsAt = async (treeId: string) => cachedFindings(cacheDirectory, treeId, toolkit, selectedProfiles, async () => normalize(await enforce({ root: scratch, profiles: selectedProfiles as any })));
-    const baseFindings = selectedProfiles.length ? await findingsAt(baseTree.out) : [];
-    const patch = await git(root, ["diff", "--cached", "--binary"], undefined, true);
-    if (patch.code) return bad(`could not read staged ratchet activation candidate: ${patch.err || patch.out}`);
-    const applied = await git(scratch, ["apply", "--whitespace=nowarn"], patch.out);
-    if (applied.code) return bad(`could not materialize staged ratchet activation candidate: ${applied.err || applied.out}`);
+    // Scan only exact Git trees in private scratch: live unstaged/untracked bytes never enter, and cache keys stay tree IDs.
+    const materialize = async (treeId: string, label: string) => {
+      const reset = await git(scratch!, ["read-tree", "--reset", "-u", treeId]);
+      if (reset.code) throw new Error(`could not materialize ${label}: ${reset.err || reset.out}`);
+      const exact = await git(scratch!, ["write-tree"]);
+      if (exact.code || exact.out !== treeId) throw new Error(`${label} did not materialize exactly: ${exact.err || exact.out}`);
+    };
+    await materialize(tree.out, "staged ratchet activation candidate");
     const materialized = await configAt(scratch), materializedProfiles = stable(await enabledProfiles(scratch));
     const materializedContext = activation ? activationContextDigest(materialized) === activationContextDigest(candidateConfig) : materializedProfiles.join(",") === candidateProfiles.join(",") && contextDigest(materialized, materializedProfiles) === contextDigest(candidateConfig, candidateProfiles);
     if (!materializedContext) return bad("staged ratchet candidate did not materialize exactly");
+    const selectedProfiles = activation || staged.some(needsFullCommitRatchetProfiles) ? candidateProfiles : (await affectedProfiles(scratch, staged, registryChanged)).filter(profile => candidateProfiles.includes(profile));
+    const normalize = (findings: Awaited<ReturnType<typeof enforce>>) => findings.map(finding => ({ ...finding, file: canonicalFindingPath(scratch!, finding.file) }));
+    const cacheDirectory = await findingsCacheDirectory(root), toolkit = await toolkitIdentity().catch(() => null);
+    const findingsAt = async (treeId: string) => cachedFindings(cacheDirectory, treeId, toolkit, selectedProfiles, async () => normalize(await enforce({ root: scratch, profiles: selectedProfiles as any })));
+    await materialize(baseTree.out, "ratchet activation base tree");
+    const baseFindings = selectedProfiles.length ? await findingsAt(baseTree.out) : [];
+    await materialize(tree.out, "staged ratchet activation candidate");
     const candidateFindings = selectedProfiles.length ? await findingsAt(tree.out) : [];
     const delta = compareFindings(baseFindings, candidateFindings);
     const report = JSON.stringify({ schema: "atdd-bun.ratchet-report/v1", mode: policy.mode, base: head.out, candidate: tree.out, profiles: selectedProfiles, context: contextDigest(candidateConfig, candidateProfiles), ...delta });
     return { ok: delta.new.length === 0, message: report };
   } catch (error) { return bad(`ratchet activation commit gate failed closed: ${String(error)}`); }
-  finally { await git(root, ["worktree", "remove", "--force", scratch]); await rm(scratch, { recursive: true, force: true }); }
+  finally { if (scratch) { await git(root, ["worktree", "remove", "--force", scratch]); await rm(scratch, { recursive: true, force: true }); } }
 }
 
 /** A pushed reject-new candidate is judged from its immutable object IDs, never the hook's checkout or index. */
@@ -376,10 +381,171 @@ export async function hooksStatus(root = process.cwd()) {
 }
 
 const branchPath = (branch: string) => branch.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-export async function startWorktree(root = process.cwd(), branch = "") { const cfg = await policy(root); if (!cfg.worktrees.enabled) return bad("worktree policy is disabled; set worktrees.enabled: true in atdd-bun.yaml"); const state = await layout(root, cfg.worktrees); if ("error" in state) return bad(state.error); if (state.current !== state.primary) return bad(`start must run from the primary checkout ${state.primary}`); if (!branch) return bad("branch is required: atdd-bun worktree start <branch>"); if ((await git(root, ["check-ref-format", "--branch", branch])).code) return bad(`invalid branch name ${JSON.stringify(branch)}`); if (cfg.protected_branches.includes(branch)) return bad(`cannot create a worktree for protected branch ${branch}`); const leaf = branchPath(branch); if (!leaf) return bad(`branch ${JSON.stringify(branch)} cannot form a safe worktree directory`); const target = join(state.worktreeRoot, leaf); if (existsSync(target)) return bad(`worktree path already exists: ${target}`); await mkdir(state.worktreeRoot, { recursive: true }); const created = await git(state.primary, ["worktree", "add", target, "-b", branch]); if (created.code) return bad(created.err || created.out); const hooks = await installHooks(target); if (!hooks.ok) return bad(`created ${target}, but could not install hooks: ${hooks.message}`); return { ok: true, message: `created linked worktree ${target} on ${branch}` }; }
+const jj = async (root: string, args: string[]) => { const child = Bun.spawn({ cmd: ["jj", ...args], cwd: root, stdout: "pipe", stderr: "pipe" }); const out = await new Response(child.stdout).text(), err = await new Response(child.stderr).text(); return { code: await child.exited, out: out.trim(), err: err.trim() }; };
+async function requireJj46(cwd: string) {
+  const result = await jj(cwd, ["version"]);
+  if (result.code) return `Jujutsu is unavailable: ${result.err || result.out}`;
+  const match = result.out.match(/\b(\d+)\.(\d+)\.(\d+)\b/);
+  if (!match) return `could not parse Jujutsu version: ${result.out}`;
+  const major = Number(match[1]), minor = Number(match[2]);
+  if (major === 0 && minor < 46) return `Jujutsu 0.46.0 or newer is required; found ${match[0]}`;
+  return null;
+}
+
+async function jjPrimaryRoot(root: string) {
+  const common = await git(root, ["rev-parse", "--git-common-dir"]);
+  if (common.code || !common.out) return null;
+  return realpath(dirname(resolve(root, common.out))).catch(() => null);
+}
+
+async function currentCommit(root: string) {
+  await jj(root, ["status"]);
+  const result = await jj(root, ["log", "-r", "@", "--no-graph", "-T", "commit_id"]);
+  return result.code ? null : result.out;
+}
+
+async function branchCommit(root: string, branch: string) {
+  const result = await git(root, ["rev-parse", "--verify", `refs/heads/${branch}^{commit}`]);
+  return result.code ? null : result.out;
+}
+
+// A delivery commit must have one unambiguous non-protected exported bookmark.
+// Ref ordering is never used as ownership authority.
+async function branchForCommit(root: string, commit: string, protectedBranches: string[]) {
+  const refs = await git(root, ["for-each-ref", "--format=%(refname:short)", "--points-at", commit, "refs/heads/"]);
+  if (refs.code) return { error: refs.err || refs.out };
+  const candidates = refs.out.split("\n").map(line => line.trim()).filter(Boolean)
+    .filter(name => !protectedBranches.includes(name));
+  return candidates.length === 1
+    ? { branch: candidates[0]! }
+    : { error: `current Jujutsu revision must have exactly one non-protected exported bookmark; found ${candidates.length}` };
+}
+
+type Layout = { primary: string; worktreeRoot: string; current: string };
+async function jjLayout(root: string, cfg: HookPolicy): Promise<Layout | { error: string }> {
+  const current = await realpath(resolve(root));
+  const primary = await jjPrimaryRoot(current);
+  if (!primary) return { error: "not inside a colocated Git-backed Jujutsu workspace" };
+  const expectedPrimary = cfg.worktrees.primary_directory === "." ? primary : join(dirname(primary), cfg.worktrees.primary_directory);
+  if (primary !== expectedPrimary) return { error: `primary checkout must be ${expectedPrimary}, not ${primary}` };
+  const primaryTip = await branchCommit(primary, cfg.worktrees.primary_branch);
+  if (!primaryTip) return { error: `primary bookmark ${cfg.worktrees.primary_branch} is not exported to Git` };
+  return { primary, worktreeRoot: resolve(primary, cfg.worktrees.root.replaceAll("{repo}", basename(primary))), current };
+}
+
+async function noConflicts(root: string) {
+  const result = await jj(root, ["log", "-r", "@ & conflicts()", "--no-graph", "-T", "commit_id"]);
+  return result.code ? { error: result.err || result.out } : result.out ? { error: "workspace has unresolved conflicts" } : {};
+}
+
+async function preflight(root: string, cfg: HookPolicy): Promise<Layout | { error: string }> {
+  if (!cfg.worktrees.enabled) return { error: "worktree policy is disabled; set worktrees.enabled: true in atdd-bun.yaml" };
+  const version = await requireJj46(root);
+  return version ? { error: version } : jjLayout(root, cfg);
+}
+
+async function startTarget(root: string, branch: string, state: Layout, cfg: HookPolicy) {
+  if (state.current !== state.primary) return { error: `start must run from the primary checkout ${state.primary}` };
+  if (!branch) return { error: "branch is required: atdd-bun worktree start <branch>" };
+  if ((await git(root, ["check-ref-format", "--branch", branch])).code) return { error: `invalid branch name ${JSON.stringify(branch)}` };
+  if (cfg.protected_branches.includes(branch)) return { error: `cannot create a worktree for protected branch ${branch}` };
+  if (await branchCommit(state.primary, branch)) return { error: `branch ${branch} already exists` };
+  const leaf = branchPath(branch);
+  if (!leaf) return { error: `branch ${JSON.stringify(branch)} cannot form a safe worktree directory` };
+  const target = join(state.worktreeRoot, leaf);
+  return existsSync(target) ? { error: `worktree path already exists: ${target}` } : { leaf, target };
+}
+
+// Workspace creation is two-phase. If bookmark export fails, both JJ artifacts
+// are rolled back so a failed start leaves no reusable partial delivery state.
+async function createWorkspace(state: Layout, target: { leaf: string; target: string }, branch: string, cfg: HookPolicy) {
+  await mkdir(state.worktreeRoot, { recursive: true });
+  const created = await jj(state.primary, ["workspace", "add", "--colocate", "--name", target.leaf, "-r", cfg.worktrees.primary_branch, target.target]);
+  if (created.code) return bad(created.err || created.out);
+  const bookmark = await jj(target.target, ["bookmark", "set", branch, "-r", "@"]);
+  const id = await currentCommit(target.target);
+  const exported = await branchCommit(target.target, branch);
+  if (!bookmark.code && id && exported === id) return { ok: true, message: `created linked Jujutsu workspace ${target.target} on ${branch}` };
+  await jj(state.primary, ["workspace", "remove", target.leaf]);
+  await jj(state.primary, ["bookmark", "delete", branch]);
+  return bad(bookmark.err || bookmark.out || `bookmark ${branch} was not exported to the colocated Git repository`);
+}
+
+async function finishCandidate(state: Layout, cfg: HookPolicy) {
+  if (state.current === state.primary || !inside(state.worktreeRoot, state.current)) return { error: `finish must run from a linked workspace beneath ${state.worktreeRoot}` };
+  const conflict = await noConflicts(state.current);
+  if ("error" in conflict) return conflict;
+  const current = await currentCommit(state.current);
+  if (!current) return { error: "could not resolve the current Jujutsu revision" };
+  let delivery = current, found = await branchForCommit(state.current, current, cfg.protected_branches);
+  if ("error" in found) {
+    const changed = await jj(state.current, ["diff", "-r", "@", "--name-only"]);
+    const parent = await jj(state.current, ["log", "-r", "@-", "--no-graph", "-T", "commit_id"]);
+    if (changed.code || changed.out || parent.code || !parent.out) return found;
+    const parentFound = await branchForCommit(state.current, parent.out, cfg.protected_branches);
+    if ("error" in parentFound) return found;
+    delivery = parent.out;
+    found = parentFound;
+  }
+  const tip = await branchCommit(state.primary, found.branch);
+  if (!tip || tip !== delivery) return { error: `bookmark ${found.branch} must point at the delivery revision before finish` };
+  if ((await git(state.primary, ["merge-base", "--is-ancestor", tip, cfg.worktrees.primary_branch])).code) return { error: `branch ${found.branch} is not merged into ${cfg.worktrees.primary_branch} in the primary checkout` };
+  return { branch: found.branch, tip, name: branchPath(found.branch) };
+}
+
+// The sanitized bookmark name is not sufficient authority to remove a workspace;
+// verify the JJ registry resolves that name back to the exact current path.
+async function verifyWorkspace(state: Layout, candidate: { name: string }) {
+  const recorded = await jj(state.primary, ["workspace", "root", "--name", candidate.name]);
+  if (recorded.code) return `workspace ${candidate.name} is not registered: ${recorded.err || recorded.out}`;
+  const recordedPath = await realpath(recorded.out).catch(() => null);
+  return recordedPath === state.current ? null : `workspace ${candidate.name} resolves to ${recorded.out}, not ${state.current}`;
+}
+
+async function deleteBookmark(state: Layout, candidate: { branch: string; tip: string }, cfg: HookPolicy) {
+  const now = await branchCommit(state.primary, candidate.branch);
+  const merged = !(await git(state.primary, ["merge-base", "--is-ancestor", candidate.tip, cfg.worktrees.primary_branch])).code;
+  if (now !== candidate.tip || !merged) return `workspace removed, but bookmark ${candidate.branch} was not deleted: its tip changed or is no longer merged into ${cfg.worktrees.primary_branch}`;
+  const deleted = await jj(state.primary, ["bookmark", "delete", candidate.branch]);
+  return deleted.code ? `workspace removed, but bookmark deletion failed: ${deleted.err || deleted.out}` : null;
+}
+async function startJjWorktree(root: string, branch: string, cfg: HookPolicy) {
+  const state = await preflight(root, cfg);
+  if ("error" in state) return bad(state.error);
+  const target = await startTarget(root, branch, state, cfg);
+  if ("error" in target) return bad(target.error);
+  return createWorkspace(state, target, branch, cfg);
+}
+async function statusJjWorktrees(root: string, cfg: HookPolicy) {
+  if (!cfg.worktrees.enabled) return bad("worktree policy is disabled");
+  const version = await requireJj46(root);
+  if (version) return bad(version);
+  const state = await jjLayout(root, cfg);
+  if ("error" in state) return bad(state.error);
+  const result = await jj(state.primary, ["workspace", "list"]);
+  return result.code ? bad(result.err || result.out) : { ok: true, message: result.out };
+}
+
+async function finishJjWorktree(root: string, deleteBranch: boolean, cfg: HookPolicy) {
+  const state = await preflight(root, cfg);
+  if ("error" in state) return bad(state.error);
+  const candidate = await finishCandidate(state, cfg);
+  if ("error" in candidate) return bad(candidate.error);
+  const mismatch = await verifyWorkspace(state, candidate);
+  if (mismatch) return bad(mismatch);
+  const removed = await jj(state.primary, ["workspace", "remove", candidate.name]);
+  if (removed.code) return bad(removed.err || removed.out);
+  if (!deleteBranch) return { ok: true, message: `removed merged Jujutsu workspace ${state.current}` };
+  const deletionError = await deleteBookmark(state, candidate, cfg);
+  return deletionError ? bad(deletionError) : { ok: true, message: `removed merged Jujutsu workspace ${state.current} and bookmark ${candidate.branch}` };
+}
+
+
+export type VcsMode = "git" | "jj";
+export async function startWorktree(root = process.cwd(), branch = "", vcs: VcsMode = "git") { const cfg = await policy(root); if (vcs === "jj") return startJjWorktree(root, branch, cfg); if (!cfg.worktrees.enabled) return bad("worktree policy is disabled; set worktrees.enabled: true in atdd-bun.yaml"); const state = await layout(root, cfg.worktrees); if ("error" in state) return bad(state.error); if (state.current !== state.primary) return bad(`start must run from the primary checkout ${state.primary}`); if (!branch) return bad("branch is required: atdd-bun worktree start <branch>"); if ((await git(root, ["check-ref-format", "--branch", branch])).code) return bad(`invalid branch name ${JSON.stringify(branch)}`); if (cfg.protected_branches.includes(branch)) return bad(`cannot create a worktree for protected branch ${branch}`); const leaf = branchPath(branch); if (!leaf) return bad(`branch ${JSON.stringify(branch)} cannot form a safe worktree directory`); const target = join(state.worktreeRoot, leaf); if (existsSync(target)) return bad(`worktree path already exists: ${target}`); await mkdir(state.worktreeRoot, { recursive: true }); const created = await git(state.primary, ["worktree", "add", target, "-b", branch]); if (created.code) return bad(created.err || created.out); const hooks = await installHooks(target); if (!hooks.ok) return bad(`created ${target}, but could not install hooks: ${hooks.message}`); return { ok: true, message: `created linked worktree ${target} on ${branch}` }; }
 
-export async function worktreeStatus(root = process.cwd()) { const { policy: cfg, source } = await primaryPolicy(root); if (!cfg.worktrees.enabled) return disabledWorktreePolicy(source); const state = await layout(root, cfg.worktrees); if ("error" in state) return bad(state.error); const result = await git(state.primary, ["worktree", "list", "--porcelain"]); return result.code ? bad(result.err) : { ok: true, message: result.out }; }
+export async function worktreeStatus(root = process.cwd(), vcs: VcsMode = "git") { const { policy: cfg, source } = await primaryPolicy(root); if (!cfg.worktrees.enabled) return disabledWorktreePolicy(source); if (vcs === "jj") return statusJjWorktrees(root, cfg); const state = await layout(root, cfg.worktrees); if ("error" in state) return bad(state.error); const result = await git(state.primary, ["worktree", "list", "--porcelain"]); return result.code ? bad(result.err) : { ok: true, message: result.out }; }
 
 async function generatedHooksOnly(root: string): Promise<boolean> { const directory = join(root, ".githooks"); if (!existsSync(directory)) return false; const names = (await readdir(directory)).sort(); if (names.join("\n") !== [...hookEvents].sort().join("\n")) return false; return (await Promise.all(hookEvents.map(async event => (await readFile(join(directory, event), "utf8")) === await renderHook(event, root)))).every(Boolean); }
 
-export async function finishWorktree(root = process.cwd(), deleteBranch = false) { const { policy: cfg, source } = await primaryPolicy(root); if (!cfg.worktrees.enabled) return disabledWorktreePolicy(source); const state = await layout(root, cfg.worktrees); if ("error" in state) return bad(state.error); if (state.current === state.primary || !inside(state.worktreeRoot, state.current)) return bad(`finish must run from a linked worktree beneath ${state.worktreeRoot}`); if (!state.branch || cfg.protected_branches.includes(state.branch)) return bad("finish requires a non-protected named branch"); const status = (await git(state.current, ["status", "--porcelain"])).out, generatedHooks = await generatedHooksOnly(state.current), onlyGeneratedHooks = Boolean(status) && status.split("\n").every(line => line.endsWith(" .githooks/") || line.endsWith(" .githooks")); if (status && !onlyGeneratedHooks) return bad("worktree is dirty; commit, stash, or discard changes before finish"); const tip = (await git(state.primary, ["rev-parse", "--verify", `refs/heads/${state.branch}`])).out.trim(); if (!tip || (await git(state.primary, ["merge-base", "--is-ancestor", tip, cfg.worktrees.primary_branch])).code) return bad(`branch ${state.branch} is not merged into ${cfg.worktrees.primary_branch} in the primary checkout`); const removed = await git(state.primary, ["worktree", "remove", ...(onlyGeneratedHooks && generatedHooks ? ["--force"] : []), state.current]); if (removed.code) return bad(removed.err || removed.out); if (deleteBranch) { const now = (await git(state.primary, ["rev-parse", "--verify", `refs/heads/${state.branch}`])).out.trim(); if (now !== tip || (await git(state.primary, ["merge-base", "--is-ancestor", tip, cfg.worktrees.primary_branch])).code) return bad(`worktree removed, but branch ${state.branch} was not deleted: its tip changed or is no longer merged into ${cfg.worktrees.primary_branch}`); const deleted = await git(state.primary, ["branch", "-D", state.branch]); if (deleted.code) return bad(`worktree removed, but branch deletion failed: ${deleted.err || deleted.out}`); } return { ok: true, message: `removed merged worktree ${state.current}${deleteBranch ? ` and branch ${state.branch}` : ""}` }; }
+export async function finishWorktree(root = process.cwd(), deleteBranch = false, vcs: VcsMode = "git") { const { policy: cfg, source } = await primaryPolicy(root); if (!cfg.worktrees.enabled) return disabledWorktreePolicy(source); if (vcs === "jj") return finishJjWorktree(root, deleteBranch, cfg); const state = await layout(root, cfg.worktrees); if ("error" in state) return bad(state.error); if (state.current === state.primary || !inside(state.worktreeRoot, state.current)) return bad(`finish must run from a linked worktree beneath ${state.worktreeRoot}`); if (!state.branch || cfg.protected_branches.includes(state.branch)) return bad("finish requires a non-protected named branch"); const status = (await git(state.current, ["status", "--porcelain"])).out, generatedHooks = await generatedHooksOnly(state.current), onlyGeneratedHooks = Boolean(status) && status.split("\n").every(line => line.endsWith(" .githooks/") || line.endsWith(" .githooks")); if (status && !onlyGeneratedHooks) return bad("worktree is dirty; commit, stash, or discard changes before finish"); const tip = (await git(state.primary, ["rev-parse", "--verify", `refs/heads/${state.branch}`])).out.trim(); if (!tip || (await git(state.primary, ["merge-base", "--is-ancestor", tip, cfg.worktrees.primary_branch])).code) return bad(`branch ${state.branch} is not merged into ${cfg.worktrees.primary_branch} in the primary checkout`); const removed = await git(state.primary, ["worktree", "remove", ...(onlyGeneratedHooks && generatedHooks ? ["--force"] : []), state.current]); if (removed.code) return bad(removed.err || removed.out); if (deleteBranch) { const now = (await git(state.primary, ["rev-parse", "--verify", `refs/heads/${state.branch}`])).out.trim(); if (now !== tip || (await git(state.primary, ["merge-base", "--is-ancestor", tip, cfg.worktrees.primary_branch])).code) return bad(`worktree removed, but branch ${state.branch} was not deleted: its tip changed or is no longer merged into ${cfg.worktrees.primary_branch}`); const deleted = await git(state.primary, ["branch", "-D", state.branch]); if (deleted.code) return bad(`worktree removed, but branch deletion failed: ${deleted.err || deleted.out}`); } return { ok: true, message: `removed merged worktree ${state.current}${deleteBranch ? ` and branch ${state.branch}` : ""}` }; }