@goodtek/vibeops 3.0.0 → 3.1.1

package/dist/lib/git.js

@@ -4,9 +4,16 @@ import { dim, log } from "./logger.js";
 const exec = promisify(execFile);
 /** Avoid `maxBuffer` errors on large `git commit` / `git add` output. */
 const DEFAULT_GIT_MAX_BUFFER = 64 * 1024 * 1024;
+/**
+ * Environment for every git call: output that VibeOps parses (porcelain, refusal
+ * messages) must not be localized.
+ */
+export function gitEnv() {
+    return { ...process.env, LC_ALL: "C", LANG: "C", LANGUAGE: "C" };
+}
 async function tryGit(cwd, args) {
     try {
-        const { stdout } = await exec("git", args, { cwd });
+        const { stdout } = await exec("git", args, { cwd, env: gitEnv() });
         return { stdout };
     }
     catch {
@@ -16,6 +23,7 @@ async function tryGit(cwd, args) {
 export async function runGit(cwd, args, options = {}) {
     const { stdout, stderr } = await exec("git", args, {
         cwd,
+        env: gitEnv(),
         maxBuffer: options.maxBuffer ?? DEFAULT_GIT_MAX_BUFFER,
     });
     return { stdout, stderr };
@@ -134,69 +142,68 @@ export async function gitCreateBranch(cwd, name, startPoint) {
     await runGit(cwd, args);
 }
 /**
- * When only governance / VibeOps paths are dirty, stash them so `git switch` can proceed.
- * Callers that switch branches should restore with {@link restoreGovernanceStashAfterSwitch}.
+ * When only governance / VibeOps paths are dirty, set aside the TRACKED
+ * governance modifications so `git switch` can proceed. Untracked files are not
+ * stashed — they move with the switch.
+ *
+ * `refs/stash` is shared by every worktree of a repository, so this never uses
+ * `stash push` / `stash pop` (which act on the top entry, possibly another
+ * worktree's). It creates a stash commit (`git stash create`), records it in the
+ * stash list for safety (`git stash store`), and returns its SHA; restore with
+ * {@link restoreGovernanceStashAfterSwitch}, which applies and drops exactly that
+ * entry. Returns null when nothing was set aside.
  */
 export async function stashGovernanceIfBlocking(cwd) {
     const git = await readGitInfo(cwd);
     if (git.dirty !== true)
-        return false;
+        return null;
     const gov = await gitGovernanceOnlyDirty(cwd);
     if (!gov.onlyGovernance || gov.allPaths.length === 0)
-        return false;
-    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
-    const tracked = [];
-    const untracked = [];
-    for (const e of entries) {
-        if (!isGovernanceDocumentationPath(e.path))
-            continue;
-        if (e.untracked)
-            untracked.push(e.path);
-        else
-            tracked.push(e.path);
-    }
-    let didStash = false;
-    if (tracked.length > 0) {
-        await runGit(cwd, [
-            "stash",
-            "push",
-            "-m",
-            "vibeops: governance before branch switch",
-            "--",
-            ...tracked,
-        ]);
-        didStash = true;
-    }
-    if (untracked.length > 0) {
-        try {
-            await runGit(cwd, [
-                "stash",
-                "push",
-                "-u",
-                "-m",
-                "vibeops: governance untracked before branch switch",
-                "--",
-                ...untracked,
-            ]);
-            didStash = true;
-        }
-        catch {
-            // Untracked generated files (e.g. cursor-implement-*.md) may not stash; switch can still proceed.
-        }
-    }
-    return didStash;
+        return null;
+    const tracked = (await gitStatusEntries(cwd))
+        .filter((e) => !e.untracked && isGovernanceDocumentationPath(e.path))
+        .map((e) => e.path);
+    if (tracked.length === 0)
+        return null;
+    const message = "vibeops: governance before branch switch";
+    const { stdout } = await runGit(cwd, ["stash", "create", message]);
+    const sha = stdout.trim();
+    if (sha.length === 0)
+        return null;
+    await runGit(cwd, ["stash", "store", "-q", "-m", message, sha]);
+    await runGit(cwd, ["restore", "--source=HEAD", "--staged", "--worktree", "--", ...tracked]);
+    return sha;
 }
-/** Re-apply governance paths stashed for a branch switch (e.g. new `docs/tasks/*.md`). */
-export async function restoreGovernanceStashAfterSwitch(cwd, didStash) {
-    if (!didStash)
+/**
+ * Re-apply the governance changes set aside by {@link stashGovernanceIfBlocking}
+ * (by SHA) and drop exactly that stash entry — never another worktree's.
+ */
+export async function restoreGovernanceStashAfterSwitch(cwd, stashSha) {
+    if (stashSha === null)
+        return;
+    try {
+        await runGit(cwd, ["stash", "apply", "-q", stashSha]);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message.split("\n")[0] : String(e);
+        log.warn(`Could not restore governance changes (${msg}). They are kept in the stash list: ${dim(`git stash apply ${stashSha}`)}`);
         return;
+    }
     try {
-        await runGit(cwd, ["stash", "pop"]);
-        log.info(dim("Restored stashed governance paths on the task branch."));
+        const { stdout } = await runGit(cwd, ["stash", "list", "--format=%H"]);
+        const index = stdout.split("\n").indexOf(stashSha);
+        if (index >= 0) {
+            const ref = `stash@{${index}}`;
+            // Re-check right before dropping: the list is shared with other worktrees.
+            if ((await gitRevParse(cwd, ref)) === stashSha) {
+                await runGit(cwd, ["stash", "drop", "-q", ref]);
+            }
+        }
+        log.info(dim("Restored governance changes after the branch switch."));
     }
     catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        log.warn(`Could not restore stashed governance files (${msg}). Run ${dim("git stash pop")} manually.`);
+        const msg = e instanceof Error ? e.message.split("\n")[0] : String(e);
+        log.warn(`Restored governance changes; could not drop stash entry ${stashSha} (${msg}).`);
     }
 }
 export async function gitCheckout(cwd, ref) {
@@ -207,12 +214,14 @@ export async function gitCheckout(cwd, ref) {
     await runGit(cwd, ["switch", ref]);
     await restoreGovernanceStashAfterSwitch(cwd, stashed);
 }
-export async function gitCheckoutNewBranch(cwd, name, startPoint) {
+export async function gitCheckoutNewBranch(cwd, name, startPoint, opts = {}) {
     const stashed = await stashGovernanceIfBlocking(cwd);
     if (stashed) {
         log.info(dim("Stashed governance-only changes (.vibeops/, docs/) before branch switch."));
     }
     const args = ["switch", "-c", name];
+    if (opts.noTrack === true)
+        args.push("--no-track");
     if (typeof startPoint === "string" && startPoint.length > 0)
         args.push(startPoint);
     await runGit(cwd, args);
@@ -247,52 +256,51 @@ export async function gitStatusPorcelain(cwd) {
         return [];
     return res.stdout.split("\n").filter((line) => line.length > 0);
 }
-function parsePorcelainLine(line) {
-    if (line.length < 3)
-        return null;
-    const code = line.slice(0, 2);
-    const rest = line.slice(3);
-    if (code === "??") {
-        return { code, staged: false, unstaged: false, untracked: true, path: rest };
-    }
-    if (code === "!!") {
-        return null;
-    }
-    const x = code.charAt(0);
-    const y = code.charAt(1);
-    // Rename / copy: `R  old -> new` or `C  old -> new`
-    if (x === "R" || x === "C") {
-        const arrow = rest.indexOf(" -> ");
-        if (arrow >= 0) {
-            const origPath = rest.slice(0, arrow);
-            const path = rest.slice(arrow + 4);
-            return {
-                code,
-                staged: true,
-                unstaged: y !== " " && y !== "?",
-                untracked: false,
-                path,
-                origPath,
-            };
-        }
-    }
-    return {
-        code,
-        staged: x !== " " && x !== "?",
-        unstaged: y !== " " && y !== "?",
-        untracked: false,
-        path: rest,
-    };
-}
-function parsePorcelain(lines) {
+/**
+ * Parse `git status --porcelain=v1 -z`: records are NUL-terminated, paths are
+ * never quoted, and a rename / copy record is followed by its source path as a
+ * separate NUL-terminated field (`XY new\0old\0`).
+ */
+export function parsePorcelainZ(stdout) {
+    const fields = stdout.split("\0");
     const out = [];
-    for (const line of lines) {
-        const entry = parsePorcelainLine(line);
-        if (entry !== null)
-            out.push(entry);
+    for (let i = 0; i < fields.length; i++) {
+        const record = fields[i];
+        if (record.length < 4)
+            continue;
+        const code = record.slice(0, 2);
+        const path = record.slice(3);
+        if (code === "!!")
+            continue;
+        if (code === "??") {
+            out.push({ code, staged: false, unstaged: false, untracked: true, path });
+            continue;
+        }
+        const x = code.charAt(0);
+        const y = code.charAt(1);
+        let origPath;
+        if (x === "R" || x === "C" || y === "R" || y === "C") {
+            origPath = fields[i + 1];
+            i += 1;
+        }
+        out.push({
+            code,
+            staged: x !== " ",
+            unstaged: y !== " ",
+            untracked: false,
+            path,
+            ...(typeof origPath === "string" && origPath.length > 0 ? { origPath } : {}),
+        });
     }
     return out;
 }
+/** Parsed `git status --porcelain=v1 -z`; empty when the repo is unreadable. */
+async function gitStatusEntries(cwd) {
+    const res = await tryGit(cwd, ["status", "--porcelain=v1", "-z"]);
+    if (!res)
+        return [];
+    return parsePorcelainZ(res.stdout);
+}
 /** Paths under these prefixes may stay uncommitted across `start` / `done` / doc updates. */
 const GOVERNANCE_DOC_REL_PREFIXES = [
     "docs/tasks/",
@@ -380,7 +388,7 @@ export async function tryResolveGovernanceUnmerged(cwd) {
     return resolved;
 }
 export async function listWorkingTreeRelPaths(cwd) {
-    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    const entries = await gitStatusEntries(cwd);
     const all = new Set();
     for (const e of entries) {
         all.add(e.path);
@@ -407,13 +415,29 @@ export function partitionPathsForAutoCommit(paths, opts = {}) {
     }
     return { committable, excluded, unmerged };
 }
+/**
+ * Paths whose working-tree state is not yet in the index: untracked files and
+ * entries with a Y-column change (modified, deleted, type-changed, unmerged).
+ * Index-only changes — a staged deletion (`D `), the source of a staged rename
+ * (`R  old -> new`) — are already recorded and exist in neither the index nor
+ * the working tree, so `git add` must not be given them (it fails with
+ * `pathspec … did not match any files`).
+ */
+export async function listUnstagedRelPaths(cwd) {
+    const entries = await gitStatusEntries(cwd);
+    return entries.filter((e) => e.untracked || e.unstaged).map((e) => e.path);
+}
+/**
+ * Stage `paths` with git's own semantics: `-A` records modifications, new files
+ * and deletions alike; `:(literal)` keeps names with glob characters exact.
+ */
 export async function gitAddPaths(cwd, paths) {
     if (paths.length === 0)
         return;
     const chunkSize = 80;
     for (let i = 0; i < paths.length; i += chunkSize) {
-        const slice = paths.slice(i, i + chunkSize);
-        await runGit(cwd, ["add", "--", ...slice]);
+        const slice = paths.slice(i, i + chunkSize).map((p) => `:(literal)${p}`);
+        await runGit(cwd, ["add", "-A", "--", ...slice]);
     }
 }
 /**
@@ -423,8 +447,7 @@ export async function gitAddPaths(cwd, paths) {
  * block the next TASK unless application code is also dirty.
  */
 export async function gitGovernanceOnlyDirty(cwd) {
-    const lines = await gitStatusPorcelain(cwd);
-    const entries = parsePorcelain(lines);
+    const entries = await gitStatusEntries(cwd);
     const all = new Set();
     for (const e of entries) {
         all.add(e.path);
@@ -441,15 +464,15 @@ export async function gitGovernanceOnlyDirty(cwd) {
     };
 }
 export async function gitWorkingTreeChangedFiles(cwd) {
-    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    const entries = await gitStatusEntries(cwd);
     return entries.filter((e) => e.unstaged).map((e) => e.path);
 }
 export async function gitStagedChangedFiles(cwd) {
-    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    const entries = await gitStatusEntries(cwd);
     return entries.filter((e) => e.staged).map((e) => e.path);
 }
 export async function gitUntrackedFiles(cwd) {
-    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    const entries = await gitStatusEntries(cwd);
     return entries.filter((e) => e.untracked).map((e) => e.path);
 }
 export async function gitCommittedChangedFilesSince(baseCommit, cwd) {
@@ -458,7 +481,7 @@ export async function gitCommittedChangedFilesSince(baseCommit, cwd) {
     return gitDiffNameOnly(cwd, `${baseCommit}..HEAD`);
 }
 export async function gitAllChangedFilesSinceTaskStart(baseCommit, cwd) {
-    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    const entries = await gitStatusEntries(cwd);
     const working = entries.filter((e) => e.unstaged).map((e) => e.path);
     const staged = entries.filter((e) => e.staged).map((e) => e.path);
     const untracked = entries.filter((e) => e.untracked).map((e) => e.path);

package/dist/lib/task-del.js

@@ -2,7 +2,8 @@ import { resolve } from "node:path";
 import { deleteFile } from "./filesystem.js";
 import { GitConfigError, requireGitConfig } from "./git-config.js";
 import { mergeRequestLabel } from "./git-host.js";
-import { gitBranchExists, gitDeleteBranch, gitDeleteRemoteBranch, gitGovernanceOnlyDirty, gitRemoteBranchExists, gitSwitchToBranch, readGitInfo, } from "./git.js";
+import { gitBranchExists, gitDeleteBranch, gitDeleteRemoteBranch, gitGovernanceOnlyDirty, gitRemoteBranchExists, readGitInfo, } from "./git.js";
+import { leaveTaskBranch } from "./git-worktree.js";
 import { dim, log } from "./logger.js";
 import { closeMergeRequest, findMergeRequestByBranches, probeMergeRequestCli, } from "./pr-create.js";
 import { normalizeTaskRef } from "./resolve-task.js";
@@ -83,12 +84,13 @@ export async function deleteTaskBranches(opts) {
     }
     const git = await readGitInfo(cwd);
     if (git.branch === opts.taskBranch) {
-        const switched = await gitSwitchToBranch(cwd, opts.integrationBranch, opts.remote);
-        if (!switched) {
-            log.error(`Integration branch "${opts.integrationBranch}" not found.`);
+        // Worktree-safe (D-006): detach when another worktree owns the integration branch.
+        const left = await leaveTaskBranch(cwd, opts.remote, opts.integrationBranch);
+        if (!left.ok) {
+            log.error(left.message);
             return false;
         }
-        log.ok(`On ${opts.integrationBranch}`);
+        log.ok(left.on === "integration" ? `On ${opts.integrationBranch}` : `Detached at ${left.ref}`);
     }
     if (await gitBranchExists(cwd, opts.taskBranch)) {
         try {

package/dist/lib/task-git-commit.js

@@ -1,5 +1,5 @@
 import { dim, log } from "./logger.js";
-import { gitAddPaths, gitPush, listWorkingTreeRelPaths, partitionPathsForAutoCommit, readGitInfo, runGit, } from "./git.js";
+import { gitAddPaths, gitPush, listUnstagedRelPaths, listWorkingTreeRelPaths, partitionPathsForAutoCommit, readGitInfo, runGit, } from "./git.js";
 export function featCommitMessageFor(taskId, title) {
     const slug = title.replace(/^TASK-\d+\s*[:\-]\s*/i, "").trim() || taskId;
     return `feat(${taskId.toLowerCase()}): ${slug}`;
@@ -31,7 +31,12 @@ export function taskScopedCommitMessage(taskId, rawMessage, defaultType = "feat"
     }
     return `${defaultType}(${scope}): ${msg}`;
 }
-/** Commit all committable dirty paths; returns whether a commit was created. */
+/**
+ * Commit all committable dirty paths (staged and unstaged, including deletions
+ * and renames); returns whether a commit was created. Only paths whose
+ * working-tree state is not yet in the index are passed to `git add`; staged
+ * changes are already part of the commit.
+ */
 export async function commitDirtyWorkingTree(cwd, message, dryRun) {
     const git = await readGitInfo(cwd);
     if (!git.isRepo || git.dirty !== true)
@@ -46,7 +51,8 @@ export async function commitDirtyWorkingTree(cwd, message, dryRun) {
         log.info(dim(`  would commit ${committable.length} path(s): ${message}`));
         return true;
     }
-    await gitAddPaths(cwd, committable);
+    const committableSet = new Set(committable);
+    await gitAddPaths(cwd, (await listUnstagedRelPaths(cwd)).filter((p) => committableSet.has(p)));
     await runGit(cwd, ["commit", "-q", "-m", message]);
     log.ok(`Committed: ${message}`);
     return true;

package/dist/lib/task-id-allocation.js

@@ -0,0 +1,192 @@
+import { readdir, realpath } from "node:fs/promises";
+import { basename, dirname, join, relative } from "node:path";
+import { gitRemoteUrl, runGit } from "./git.js";
+import { currentWorktreeRoot, listWorktrees } from "./git-worktree.js";
+/**
+ * Collision-free TASK ids (D-006).
+ *
+ * next id = 1 + max TASK number found in ANY of:
+ *  1. local `docs/tasks` (this worktree, including uncommitted files);
+ *  2. `docs/tasks` on `<remote>/<integration>` (`git ls-tree`), else local `<integration>`;
+ *  3. VibeOps task branches — local heads and `<remote>/task/*` (refreshed with
+ *     `git fetch --prune <remote> +refs/heads/task/*:refs/remotes/<remote>/task/*`) —
+ *     counted only when the branch name has the generated form AND the branch's
+ *     tree contains that TASK file (so `task/2026-q4-plan` does not inflate ids);
+ *  4. `docs/tasks` in every worktree from `git worktree list` (covers task branches
+ *     whose TASK file is not committed yet).
+ *
+ * A configured remote whose task branches cannot be fetched is an error (fail
+ * closed) — an id could otherwise collide with an unmerged branch.
+ */
+const TASK_FILE_RE = /^TASK-(\d+)(?:-|\.md$)/i;
+/**
+ * Generated task branch form: `task/<NNN>` or `task/<NNN>-<slug>`, where NNN is the
+ * zero-padded TASK number (≥ 3 digits, `formatTaskId`) and slug is `slugify` output
+ * (`[a-z0-9]+` joined by single hyphens) — i.e. `branchNameForTaskFile` of
+ * `TASK-<NNN>-<slug>.md`.
+ */
+export const GENERATED_TASK_BRANCH_RE = /^task\/(\d{3,})(?:-([a-z0-9]+(?:-[a-z0-9]+)*))?$/;
+export function taskNumberFromFilename(name) {
+    const m = TASK_FILE_RE.exec(name.trim());
+    return m ? Number.parseInt(m[1], 10) : null;
+}
+/**
+ * TASK number of a branch in the generated form (accepts `refs/heads/` and
+ * `refs/remotes/<remote>/` prefixes), else null.
+ */
+export function taskNumberFromBranch(ref) {
+    const name = ref
+        .trim()
+        .replace(/^refs\/heads\//, "")
+        .replace(/^refs\/remotes\/[^/]+\//, "");
+    const m = GENERATED_TASK_BRANCH_RE.exec(name);
+    return m ? Number.parseInt(m[1], 10) : null;
+}
+export class TaskIdAllocationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TaskIdAllocationError";
+    }
+}
+async function maxInDir(dir) {
+    let max = 0;
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return 0;
+    }
+    for (const n of names) {
+        const v = taskNumberFromFilename(n);
+        if (v !== null)
+            max = Math.max(max, v);
+    }
+    return max;
+}
+function maxOf(values) {
+    let max = 0;
+    for (const v of values)
+        if (v !== null)
+            max = Math.max(max, v);
+    return max;
+}
+async function refExists(cwd, ref) {
+    try {
+        await runGit(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function branchHasTaskFile(cwd, ref, tasksRel, n) {
+    try {
+        const { stdout } = await runGit(cwd, ["ls-tree", "--name-only", `${ref}:${tasksRel}`]);
+        return stdout.split("\n").some((f) => taskNumberFromFilename(f) === n);
+    }
+    catch {
+        return false; // no docs/tasks in that tree
+    }
+}
+/**
+ * Cross-machine guard for `task ship`: refuse to push `taskBranch` when the remote
+ * already has a different generated task branch with the same TASK number (another
+ * machine allocated the same id). Fails closed when the remote cannot be listed.
+ */
+export async function assertTaskIdFreeOnRemote(cwd, remote, taskBranch) {
+    const n = taskNumberFromBranch(taskBranch);
+    if (n === null)
+        return { ok: true };
+    if ((await gitRemoteUrl(cwd, remote)) === null)
+        return { ok: true };
+    let stdout;
+    try {
+        ({ stdout } = await runGit(cwd, ["ls-remote", "--heads", remote, "task/*"]));
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message.split("\n")[0] : String(e);
+        return {
+            ok: false,
+            message: `Cannot list task branches on ${remote} (${msg}) — refusing to push without checking for a TASK id collision.`,
+        };
+    }
+    const clashes = stdout
+        .split("\n")
+        .map((l) => (l.split("\t")[1] ?? "").replace(/^refs\/heads\//, ""))
+        .filter((name) => name.length > 0 && name !== taskBranch && taskNumberFromBranch(name) === n);
+    if (clashes.length > 0) {
+        return {
+            ok: false,
+            message: `TASK id collision: ${remote} already has ${clashes.join(", ")} for TASK-${String(n).padStart(3, "0")}. Not pushing ${taskBranch}. Renumber this TASK (file + branch) and rerun.`,
+        };
+    }
+    return { ok: true };
+}
+export async function allocateTaskId(input) {
+    const { cwd, tasksDir, remote, integrationBranch } = input;
+    const root = await currentWorktreeRoot(cwd);
+    // Compare canonical paths (macOS /var → /private/var) to get the repo-relative dir.
+    const tasksAbs = await realpath(tasksDir).catch(async () => join(await realpath(dirname(tasksDir)), basename(tasksDir)));
+    const tasksRel = relative(root, tasksAbs).split("\\").join("/");
+    if (tasksRel.startsWith("..") || tasksRel.length === 0) {
+        throw new Error(`TASK directory ${tasksDir} is not inside the worktree ${root}.`);
+    }
+    // 1. local docs/tasks
+    const localFiles = await maxInDir(tasksDir);
+    // 2. integration tree
+    let integrationTree = 0;
+    const treeRef = (await refExists(cwd, `refs/remotes/${remote}/${integrationBranch}`))
+        ? `${remote}/${integrationBranch}`
+        : (await refExists(cwd, `refs/heads/${integrationBranch}`))
+            ? integrationBranch
+            : null;
+    if (treeRef !== null) {
+        const { stdout } = await runGit(cwd, ["ls-tree", "--name-only", `${treeRef}:${tasksRel}`]).catch(() => ({ stdout: "" }));
+        integrationTree = maxOf(stdout.split("\n").map(taskNumberFromFilename));
+    }
+    // 3. VibeOps task branches (local + freshly fetched remote), with TASK-file evidence
+    if (input.fetchRemote !== false && (await gitRemoteUrl(cwd, remote)) !== null) {
+        try {
+            await runGit(cwd, [
+                "fetch",
+                "--prune",
+                remote,
+                `+refs/heads/task/*:refs/remotes/${remote}/task/*`,
+            ]);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message.split("\n")[0] : String(e);
+            throw new TaskIdAllocationError(`Cannot fetch task branches from ${remote} (${msg}) — refusing to pick a TASK id that may collide. Check network / auth and rerun.`);
+        }
+    }
+    const { stdout: refs } = await runGit(cwd, [
+        "for-each-ref",
+        "--format=%(refname)",
+        "refs/heads/task/",
+        `refs/remotes/${remote}/task/`,
+    ]);
+    let branches = 0;
+    for (const ref of refs.split("\n").filter((r) => r.length > 0)) {
+        const n = taskNumberFromBranch(ref);
+        if (n === null || n <= branches)
+            continue;
+        if (await branchHasTaskFile(cwd, ref, tasksRel, n))
+            branches = n;
+    }
+    // 4. every worktree's docs/tasks
+    let worktrees = 0;
+    for (const wt of await listWorktrees(cwd)) {
+        if (wt.bare)
+            continue;
+        worktrees = Math.max(worktrees, await maxInDir(join(wt.path, tasksRel)));
+    }
+    const sources = {
+        localFiles,
+        integrationTree,
+        branches,
+        worktrees,
+    };
+    const max = Math.max(...Object.values(sources));
+    return { next: max + 1, max, sources };
+}