@goodtek/vibeops 2.5.2 → 3.1.0

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 };
+}

package/dist/lib/task-lock.js

@@ -0,0 +1,356 @@
+import { randomUUID } from "node:crypto";
+import { linkSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { hostname } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import { readTextOrNull } from "./filesystem.js";
+import { isGitRepository, runGit } from "./git.js";
+import { dim, log } from "./logger.js";
+import { VIBEOPS_CONFIG_FILE } from "./paths.js";
+/**
+ * Repository-wide lock for VibeOps operations that allocate TASK ids, write TASK
+ * files, create / switch / delete task branches, or stash (D-006). All worktrees
+ * of a repository share one git common dir, so the lock file lives there:
+ * `<git-common-dir>/vibeops-task.lock`, created atomically with its content
+ * (temp file + `link`, EEXIST when held).
+ *
+ * Stale lock: holder on THIS host whose pid is no longer alive, or a lock older
+ * than `lock.staleSeconds` on ANY host (covers pid reuse on this host and
+ * unverifiable pids on other hosts). A start time in the future (clock skew) is
+ * respected, not stale. Removal (release / stale takeover) is guarded by a
+ * breaker file — see {@link withBreakerSync}.
+ */
+export const LOCK_FILE_NAME = "vibeops-task.lock";
+export const TASK_LOCK_DEFAULTS = { waitSeconds: 60, staleSeconds: 600 };
+export const TASK_LOCK_LIMITS = {
+    waitSeconds: { min: 0, max: 600 },
+    staleSeconds: { min: 60, max: 86_400 },
+};
+export class TaskLockConfigError extends Error {
+    constructor(message) {
+        super(`${VIBEOPS_CONFIG_FILE} lock: ${message}`);
+        this.name = "TaskLockConfigError";
+    }
+}
+export class TaskLockHeldError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TaskLockHeldError";
+    }
+}
+/** Validate `.vibeops.json` `lock` (fail closed). `undefined` → defaults. */
+export function parseTaskLockConfig(raw) {
+    if (raw === undefined)
+        return TASK_LOCK_DEFAULTS;
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new TaskLockConfigError("must be an object.");
+    }
+    const o = raw;
+    const allowed = Object.keys(TASK_LOCK_LIMITS);
+    const unknown = Object.keys(o).filter((k) => !allowed.includes(k));
+    if (unknown.length > 0) {
+        throw new TaskLockConfigError(`unknown key ${unknown.map((k) => `\`${k}\``).join(", ")} (allowed: ${allowed.join(", ")}).`);
+    }
+    const out = { ...TASK_LOCK_DEFAULTS };
+    for (const key of allowed) {
+        const v = o[key];
+        if (v === undefined)
+            continue;
+        const { min, max } = TASK_LOCK_LIMITS[key];
+        if (typeof v !== "number" || !Number.isInteger(v) || v < min || v > max) {
+            throw new TaskLockConfigError(`\`${key}\` must be an integer between ${min} and ${max}.`);
+        }
+        out[key] = v;
+    }
+    return out;
+}
+export async function readTaskLockConfig(root) {
+    const text = await readTextOrNull(join(root, VIBEOPS_CONFIG_FILE));
+    if (text === null)
+        return TASK_LOCK_DEFAULTS;
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new TaskLockConfigError("file is not valid JSON.");
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return TASK_LOCK_DEFAULTS;
+    }
+    return parseTaskLockConfig(parsed.lock);
+}
+export async function taskLockPath(cwd) {
+    const { stdout } = await runGit(cwd, ["rev-parse", "--git-common-dir"]);
+    const dir = stdout.trim();
+    return join(isAbsolute(dir) ? dir : resolve(cwd, dir), LOCK_FILE_NAME);
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === "EPERM";
+    }
+}
+function readLockSync(path) {
+    try {
+        const v = JSON.parse(readFileSync(path, "utf8"));
+        // pid + host are enough to judge staleness; token / startedAt may be missing
+        // in a foreign or older lock file.
+        return typeof v.pid === "number" && typeof v.host === "string" ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+function inodeOf(path) {
+    try {
+        return statSync(path).ino;
+    }
+    catch {
+        return null;
+    }
+}
+/** Why the existing lock is stale, or null when it must be respected. */
+export function staleReason(info, cfg, now = Date.now(), mtimeMs = null) {
+    if (info === null) {
+        // Unparseable (foreign / truncated) file: stale only by age.
+        return mtimeMs !== null && (now - mtimeMs) / 1000 > cfg.staleSeconds
+            ? `unreadable and older than ${cfg.staleSeconds}s`
+            : null;
+    }
+    if (info.host === hostname() && !pidAlive(info.pid)) {
+        return `pid ${info.pid} is not running`;
+    }
+    const age = (now - Date.parse(info.startedAt)) / 1000;
+    return Number.isFinite(age) && age > cfg.staleSeconds
+        ? `older than ${cfg.staleSeconds}s (pid ${info.pid} on ${info.host})`
+        : null;
+}
+function describe(info, path) {
+    if (info === null)
+        return `lock file ${path}`;
+    return `pid ${info.pid} on ${info.host} since ${info.startedAt} (${info.operation} in ${info.cwd})`;
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const sleepSync = (ms) => {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+};
+/**
+ * Create `path` atomically WITH its content: write a private temp file, then
+ * `link` it into place (fails with EEXIST if `path` exists). Readers never see a
+ * half-written lock. Returns false when the lock already exists.
+ */
+function createExclusiveSync(path, content) {
+    const tmp = `${path}.${randomUUID()}.tmp`;
+    writeFileSync(tmp, content, { flag: "wx" });
+    try {
+        linkSync(tmp, path);
+        return true;
+    }
+    catch (e) {
+        if (e.code === "EEXIST")
+            return false;
+        throw e;
+    }
+    finally {
+        unlinkSync(tmp);
+    }
+}
+/**
+ * Internal, not configurable: a breaker is held for microseconds (re-check +
+ * unlink), so these only matter after a crash inside that window.
+ * - BREAKER_STALE_MS: a breaker older than this was left by a crash.
+ * - BREAKER_WAIT_MS: upper bound on waiting for the breaker. A stale TAKEOVER
+ *   waits min(this, lock.waitSeconds) — the user's wait budget. RELEASE always
+ *   uses this full bound: giving up early would leave the lock behind.
+ */
+const BREAKER_STALE_MS = 30_000;
+const BREAKER_WAIT_MS = 60_000;
+/**
+ * Every REMOVAL of the lock file (release, stale takeover) happens while holding
+ * the breaker `<lock>.break`. Creation needs the lock to be absent (link), so
+ * while the breaker is held the lock file cannot change identity: "verify
+ * identity, then unlink" is atomic with respect to all other VibeOps processes.
+ */
+function withBreakerSync(lockPath, fn, waitMs = BREAKER_WAIT_MS) {
+    const breaker = `${lockPath}.break`;
+    const token = randomUUID();
+    const deadline = Date.now() + Math.min(BREAKER_WAIT_MS, waitMs);
+    let loggedWait = false;
+    for (;;) {
+        if (createExclusiveSync(breaker, `${JSON.stringify({ token, pid: process.pid, host: hostname() })}\n`)) {
+            break;
+        }
+        let st = null;
+        try {
+            st = statSync(breaker);
+        }
+        catch {
+            continue; // released meanwhile
+        }
+        if (Date.now() - st.mtimeMs > BREAKER_STALE_MS) {
+            // Crash inside a breaker section: move it aside, delete only if it is
+            // still the same file (inode) we judged stale.
+            const aside = `${breaker}.stale-${randomUUID()}`;
+            try {
+                renameSync(breaker, aside);
+                if (statSync(aside).ino === st.ino)
+                    unlinkSync(aside);
+                else {
+                    try {
+                        linkSync(aside, breaker);
+                    }
+                    catch {
+                        // a fresh breaker exists again; ours is not needed
+                    }
+                    unlinkSync(aside);
+                }
+            }
+            catch {
+                // someone else handled it
+            }
+            continue;
+        }
+        if (Date.now() >= deadline) {
+            throw new TaskLockHeldError(`VibeOps lock breaker ${breaker} is held; retry, or delete it if no vibeops process is running.`);
+        }
+        if (!loggedWait) {
+            log.info(dim(`Waiting for VibeOps lock breaker ${breaker}…`));
+            loggedWait = true;
+        }
+        sleepSync(2);
+    }
+    try {
+        return fn();
+    }
+    finally {
+        try {
+            const cur = JSON.parse(readFileSync(breaker, "utf8"));
+            if (cur.token === token)
+                unlinkSync(breaker);
+        }
+        catch {
+            // already gone
+        }
+    }
+}
+/** Unlink the lock only if it is still the file identified by (inode, token). */
+function removeLockIfSame(path, ino, token, breakerWaitMs) {
+    return withBreakerSync(path, () => {
+        if (inodeOf(path) !== ino)
+            return false;
+        const cur = readLockSync(path);
+        if ((typeof cur?.token === "string" ? cur.token : null) !== token)
+            return false;
+        unlinkSync(path);
+        return true;
+    }, breakerWaitMs);
+}
+/** Acquire the repository task lock, waiting up to `waitSeconds` for another holder. */
+export async function acquireTaskLock(cwd, operation, cfg = TASK_LOCK_DEFAULTS) {
+    const path = await taskLockPath(cwd);
+    const info = {
+        token: randomUUID(),
+        pid: process.pid,
+        host: hostname(),
+        startedAt: new Date().toISOString(),
+        operation,
+        cwd: resolve(cwd),
+    };
+    const content = `${JSON.stringify(info)}\n`;
+    const deadline = Date.now() + cfg.waitSeconds * 1000;
+    let loggedWait = false;
+    for (;;) {
+        if (createExclusiveSync(path, content))
+            break;
+        let st;
+        try {
+            st = statSync(path);
+        }
+        catch {
+            continue; // released meanwhile
+        }
+        const holder = readLockSync(path);
+        const stale = staleReason(holder, cfg, Date.now(), st.mtimeMs);
+        if (stale !== null) {
+            const judgedToken = typeof holder?.token === "string" ? holder.token : null;
+            // Takeover honours the user's wait budget; release (below) does not.
+            if (removeLockIfSame(path, st.ino, judgedToken, cfg.waitSeconds * 1000)) {
+                log.warn(`Removed stale VibeOps lock (${stale}): ${path}`);
+            }
+            continue;
+        }
+        if (Date.now() >= deadline) {
+            throw new TaskLockHeldError(`Another VibeOps task operation holds the repository lock: ${describe(holder, path)}. ` +
+                `Wait for it to finish and rerun. If that process is gone, delete ${path}.`);
+        }
+        if (!loggedWait) {
+            log.info(dim(`Waiting for VibeOps lock held by ${describe(holder, path)}…`));
+            loggedWait = true;
+        }
+        await sleep(Math.min(50, Math.max(0, deadline - Date.now())));
+    }
+    const ino = inodeOf(path);
+    let released = false;
+    const releaseSync = () => {
+        if (released)
+            return;
+        released = true;
+        if (ino !== null)
+            removeLockIfSame(path, ino, info.token);
+    };
+    process.once("exit", releaseSync);
+    return {
+        path,
+        async release() {
+            process.removeListener("exit", releaseSync);
+            releaseSync();
+        },
+    };
+}
+/** Run `fn` while holding the repository task lock. */
+export async function withTaskLock(cwd, operation, fn, cfg) {
+    const lock = await acquireTaskLock(cwd, operation, cfg ?? (await readTaskLockConfig(cwd)));
+    try {
+        return await fn();
+    }
+    finally {
+        await lock.release();
+    }
+}
+/**
+ * Command wrapper: run `fn` under the repository task lock, reporting lock /
+ * config errors with exit code 1. Outside a git repository `fn` runs unlocked
+ * (it reports that error itself).
+ */
+export async function runUnderTaskLock(cwd, operation, fn) {
+    if (!(await isGitRepository(cwd))) {
+        await fn();
+        return;
+    }
+    let cfg;
+    try {
+        cfg = await readTaskLockConfig(cwd);
+    }
+    catch (e) {
+        if (e instanceof TaskLockConfigError) {
+            log.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        throw e;
+    }
+    try {
+        await withTaskLock(cwd, operation, fn, cfg);
+    }
+    catch (e) {
+        if (e instanceof TaskLockHeldError) {
+            log.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        throw e;
+    }
+}

package/dist/lib/task-new-cycle.js

@@ -11,6 +11,7 @@ import { applyTaskShipMemory, llmCompleteTaskReship, writeTaskResultSections, }
 import { assertMergeRequestNotOpen, ensureTaskBranchForReship, integrateIntegrationIntoTaskBranch, loadGitConfigForReship, prepareGitContextForReship, refreshGitContextBaseCommit, resolveReshipTarget, } from "./task-reship.js";
 import { hasNonEmptySection, parseTaskFilename, readGitContext } from "./task.js";
 import { prRefLabel } from "./task-ship-state.js";
+import { runUnderTaskLock } from "./task-lock.js";
 async function commitReshipMetadata(opts) {
     if (opts.dryRun) {
         log.info(dim("  would commit new-cycle metadata (Status stays Shipped)"));
@@ -56,7 +57,7 @@ export async function runPostMergeNewCycle(taskRef, options = {}) {
         process.exitCode = 1;
         return;
     }
-    const branchOk = await ensureTaskBranchForReship({
+    const ensureBranch = () => ensureTaskBranchForReship({
         cwd,
         taskFile,
         gitCtx: initialCtx,
@@ -65,6 +66,16 @@ export async function runPostMergeNewCycle(taskRef, options = {}) {
         recreateBranch: options.recreateBranch === true,
         dryRun,
     });
+    let branchOk = false;
+    if (dryRun) {
+        branchOk = await ensureBranch();
+    }
+    else {
+        // D-006: branch switch / recreate / stash are serialized across worktrees.
+        await runUnderTaskLock(cwd, "task ship --new-cycle", async () => {
+            branchOk = await ensureBranch();
+        });
+    }
     if (!branchOk) {
         process.exitCode = 1;
         return;

package/dist/lib/task-push-pr.js

@@ -8,6 +8,7 @@ import { dim, log } from "./logger.js";
 import { createMergeRequest, findMergeRequestByBranches, probeMergeRequestCli, } from "./pr-create.js";
 import { fallbackTaskPr, generateTaskPrWithLlm } from "./task-pr-llm.js";
 import { readGitContext, readTaskFile } from "./task.js";
+import { assertTaskIdFreeOnRemote } from "./task-id-allocation.js";
 function mergeRequestAlreadyExistsMessage(msg) {
     const lower = msg.toLowerCase();
     return (lower.includes("already exists") ||
@@ -66,6 +67,12 @@ export async function finishTaskWithPullRequest(opts) {
     if (ahead === 0) {
         log.warn("No commits ahead of base — pushing branch anyway.");
     }
+    // D-006: another machine may have pushed a task branch with the same TASK id.
+    const idFree = await assertTaskIdFreeOnRemote(opts.cwd, gitCfg.remote, gitCtx.taskBranch);
+    if (!idFree.ok) {
+        log.error(idFree.message);
+        return { ok: false };
+    }
     try {
         await gitPush(opts.cwd, gitCfg.remote, gitCtx.taskBranch, true);
         log.ok(`Pushed ${gitCtx.taskBranch} → ${gitCfg.remote}`);

package/dist/lib/task-reship.js

@@ -1,6 +1,7 @@
 import { resolve } from "node:path";
 import { GitConfigError, requireGitConfig } from "./git-config.js";
-import { gitBranchExists, gitCheckout, gitCheckoutNewBranch, gitDeleteBranch, gitFetchRemote, gitHeadCommit, gitMergeRemoteBranch, gitMergeInProgress, gitPullFastForwardOnly, gitRemoteBranchExists, gitSwitchToBranch, listUnmergedRelPaths, readGitInfo, } from "./git.js";
+import { gitBranchExists, gitCheckout, gitCheckoutNewBranch, gitDeleteBranch, gitFetchRemote, gitHeadCommit, gitMergeRemoteBranch, gitMergeInProgress, gitFetch, gitRemoteBranchExists, gitRemoteUrl, gitRevParse, gitSwitchToBranch, listUnmergedRelPaths, readGitInfo, } from "./git.js";
+import { fastForwardLocalIntegration, leaveTaskBranch, logLocalIntegrationUpdate, resolveIntegrationBaseRef, } from "./git-worktree.js";
 import { dim, log } from "./logger.js";
 import { findMergeRequestByBranches } from "./pr-create.js";
 import { normalizeTaskRef } from "./resolve-task.js";
@@ -63,9 +64,10 @@ async function removeLocalTaskBranch(cwd, taskBranch, integrationBranch, remote)
         return true;
     const git = await readGitInfo(cwd);
     if (git.branch === taskBranch) {
-        const ok = await gitSwitchToBranch(cwd, integrationBranch, remote);
-        if (!ok) {
-            log.error(`Integration branch "${integrationBranch}" not found.`);
+        // Worktree-safe (D-006): detach when another worktree owns the integration branch.
+        const left = await leaveTaskBranch(cwd, remote, integrationBranch);
+        if (!left.ok) {
+            log.error(left.message);
             return false;
         }
     }
@@ -83,14 +85,26 @@ async function removeLocalTaskBranch(cwd, taskBranch, integrationBranch, remote)
 async function recreateTaskBranchFromIntegration(opts) {
     const cwd = resolve(opts.cwd);
     const { taskBranch } = opts.gitCtx;
-    const ok = await gitSwitchToBranch(cwd, opts.integrationBranch, opts.remote);
-    if (!ok) {
+    // Worktree-safe (D-006): start from <remote>/<integration>; never check out
+    // the integration branch (another worktree may own it).
+    if ((await gitRemoteUrl(cwd, opts.remote)) !== null) {
+        try {
+            await gitFetch(cwd, opts.remote, opts.integrationBranch);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log.warn(`git fetch failed (${msg}). Continuing with local refs.`);
+        }
+    }
+    const baseRef = await resolveIntegrationBaseRef(cwd, opts.remote, opts.integrationBranch);
+    if (baseRef === null) {
         log.error(`Integration branch "${opts.integrationBranch}" not found.`);
         return false;
     }
     if (await gitRemoteBranchExists(cwd, opts.remote, opts.integrationBranch)) {
         try {
-            await gitPullFastForwardOnly(cwd, opts.remote, opts.integrationBranch);
+            const update = await fastForwardLocalIntegration(cwd, opts.remote, opts.integrationBranch);
+            logLocalIntegrationUpdate(update, opts.remote, opts.integrationBranch);
         }
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
@@ -98,17 +112,18 @@ async function recreateTaskBranchFromIntegration(opts) {
             return false;
         }
     }
-    const head = await gitHeadCommit(cwd);
-    if (head === null || head.length === 0) {
+    // Full SHA: unambiguous base for later diff ranges.
+    const head = (await gitRevParse(cwd, `${baseRef}^{commit}`)) ?? "";
+    if (head.length === 0) {
         log.error("Integration branch has no commits.");
         return false;
     }
     try {
-        await gitCheckoutNewBranch(cwd, taskBranch, opts.integrationBranch);
+        await gitCheckoutNewBranch(cwd, taskBranch, baseRef, { noTrack: true });
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        log.error(`Could not create ${taskBranch} from ${opts.integrationBranch} with uncommitted changes.`);
+        log.error(`Could not create ${taskBranch} from ${baseRef} with uncommitted changes.`);
         if (msg.length > 0)
             log.info(dim(msg));
         return false;
@@ -118,7 +133,7 @@ async function recreateTaskBranchFromIntegration(opts) {
         baseBranch: opts.integrationBranch,
         baseCommit: head,
     });
-    log.ok(`Created ${taskBranch} from ${opts.integrationBranch}`);
+    log.ok(`Created ${taskBranch} from ${baseRef}`);
     return true;
 }
 /** Checkout or recreate the task branch without changing TASK Status. */