@ericsanchezok/synergy-workbench 0.0.0-stage → 3.1.1

package/dist/project/tools/session-control.txt

@@ -0,0 +1,60 @@
+Control a target session remotely — inspect its state and perform actions as if you were the user in that session.
+
+The `target` parameter identifies which session to control:
+- A session ID (e.g. "ses_xxx") to target a specific session
+
+## Actions
+
+Abort and pending-input replies work while the target session is running. Compaction and worktree actions require an idle target.
+
+### `create` — Create a standalone primary session
+Creates a normal top-level session in the sidebar. `target` is not used. Optional parameters:
+- `title`: session title
+- `scopeID` or `directory`: where to create it; defaults to the current scope. If you need a valid `scopeID`, call `scope_list` first. If you already know the absolute project path, pass `directory` instead.
+- `workspace`: `{ "mode": "current" }`, `{ "mode": "existing", "target": "..." }`, or `{ "mode": "create", "name": "...", "baseRef": "current|fresh" }`
+- `agent`: per-session agent override for new user messages
+- `model`: per-session model override, `{ "providerID": "...", "modelID": "..." }`
+- `mode`: `interactive` or `unattended`
+- `controlProfile`: `guarded`, `autonomous`, or `full_access`
+- `initialMessage`: enqueue a first user message and wake the new session asynchronously
+
+### `status` — Query session state
+Returns the session's current runtime status, pending questions, and pending permission requests. Use this before other actions to understand what the session needs. For example, before answering a question, call `status` first to see what questions are pending and what options are available.
+
+### `compact` — Trigger compaction
+Forces the target session to compact its conversation history. Useful when a child session is approaching context limits.
+
+### `abort` — Abort execution
+Stops any ongoing processing in the target session. Use when a delegated agent is stuck or doing the wrong thing. The target can be the calling session itself; this also interrupts the calling turn, so do not rely on a successful tool result or a follow-up response from it.
+
+### `worktree_enter` — Create, enter, or switch the target session's worktree
+Uses `worktreeTarget` as an existing worktree name/ID/branch/path when it matches; otherwise creates a new worktree using `worktreeTarget` as the name. Omit `worktreeTarget` to create a uniquely named worktree. Use `baseRef`, `baseRevision`, and `force` as needed.
+
+### `worktree_leave` — Return the target session to the main checkout
+Use `cleanup: "keep"` (default) to keep the worktree, or `cleanup: "remove_if_clean"` to permanently delete it after leaving when it has no uncommitted changes. Permanent deletion drops the registry entry and cannot be undone; use `worktree_archive` when the checkout may be needed again.
+
+### `set_agent` — Set the target session's agent override
+Requires `agent`. Future user messages without an explicit agent use this override.
+
+### `set_model` — Set the target session's model override
+Requires `model: { "providerID": "...", "modelID": "..." }`. Future user messages without an explicit model use this override.
+
+### `set_mode` — Set interactive vs unattended behavior
+Requires `mode: "interactive"` or `mode: "unattended"`. `modeSource` defaults to `session_control`.
+
+### `set_control_profile` — Set the target session's permission control profile
+Requires `controlProfile`. This changes the target session's guarded/autonomous/full-access profile.
+
+### `question_reply` — Answer a pending question
+Provide answers to a question that the target session's agent has asked. The `answers` format is an array of arrays of selected labels — one array per question, each containing the label(s) the user selected. For single-select questions, pass one label; for multiple-select, pass multiple. Use `status` first to discover pending question IDs and available options.
+
+### `question_reject` — Dismiss a pending question
+Reject a question the target session's agent has asked. The agent will receive an error and can adjust its approach.
+
+### `permission_reply` — Approve or deny a permission request
+Respond to a pending permission request in the target session. Use `reply: "once"` to approve this specific request, or `reply: "reject"` to deny it. When rejecting, you can optionally provide a `message` to guide the agent. Use `status` first to discover pending permission IDs.
+
+## Typical workflow
+1. To create a session in another project, call `scope_list` to discover available scope IDs, then call `session_control` with `action: "create"` and the chosen `scopeID`. For an existing session, call `action: "status"` first.
+2. Use `set_agent`, `set_model`, `set_mode`, or worktree actions to adjust the target session.
+3. Use `question_reply` or `permission_reply` when `status` reports pending user input.

package/dist/project/tools/worktree-archive.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { Tool } from "@ericsanchezok/synergy-harness/tool/tool";
+import { Worktree } from "@ericsanchezok/synergy-local-runtime/workspace/worktree";
+import { Session } from "@ericsanchezok/synergy-harness/session";
+import { PermissionNext } from "@ericsanchezok/synergy-harness/permission/next";
+const parameters = z.object({
+    target: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Managed worktree name, ID, branch, or path. Defaults to the calling session's current worktree; use worktree_list to find another idle worktree."),
+    reason: z.string().optional().describe("Optional short explanation of why the worktree is finished."),
+});
+export const WorktreeArchiveTool = Tool.define("worktree_archive", {
+    description: "Archive a finished Synergy-managed git worktree. Use when isolated work is complete, including from the running owner turn, or to reclaim another idle worktree. Optional target accepts a name, ID, branch or path; omitted target selects the caller's current worktree. The caller returns to its original checkout without stopping or archiving the conversation. Other sessions retain their Workspace identity and restore the checkout when execution resumes. Dirty or ignored files, local-only or unverifiable commits, locks and active users keep the checkout; there is no force option. Reports archived/noop/denied, restored checkout and whether cleanup actually happened with its reason. Keeps the branch; retained checkouts can be re-entered with worktree_enter. Released clean checkouts retain a pinned Git recovery receipt; worktree_enter and session execution restore them on demand. Use worktree_leave when you only need to return to the original checkout and keep the worktree.",
+    parameters,
+    async execute(params, ctx) {
+        ctx.abort.throwIfAborted();
+        const session = await Session.get(ctx.sessionID);
+        const target = params.target ?? (session.workspace?.type === "git_worktree" ? session.workspace.path : undefined);
+        if (!target) {
+            return {
+                title: "worktree_archive",
+                metadata: {
+                    action: "noop",
+                    message: "No current worktree to archive. Use worktree_list and supply a managed target.",
+                },
+                output: "No current worktree to archive. Use worktree_list and supply a managed target.",
+            };
+        }
+        const tree = await Worktree.resolve(target);
+        if (!tree.managed || tree.isMain || tree.stale) {
+            throw new Worktree.CreateFailedError({
+                message: "Only an available Synergy-managed worktree can be archived. Use worktree_list to select one.",
+            });
+        }
+        try {
+            await ctx.ask({
+                permission: "worktree_archive",
+                patterns: [tree.path],
+                metadata: { target: tree.id, branch: tree.branch, reason: params.reason },
+            });
+        }
+        catch (error) {
+            if (!(error instanceof PermissionNext.RejectedError || error instanceof PermissionNext.DeniedError))
+                throw error;
+            const message = "Worktree archive denied. No workspace binding or files were changed.";
+            return { title: "worktree_archive", metadata: { action: "denied", message }, output: message };
+        }
+        ctx.abort.throwIfAborted();
+        const result = await Worktree.archive({ sessionID: ctx.sessionID, target: tree.id, signal: ctx.abort });
+        const lines = [`Archived worktree "${tree.name}". Conversation remains available and this turn can continue.`];
+        if (result.restored)
+            lines.push(`Restored: ${result.restored.path}`);
+        if (result.cleanup.performed)
+            lines.push(`Checkout released; branch "${tree.branch}" and recovery commit retained. Referencing sessions and worktree_enter restore it on demand.`);
+        else if (result.cleanup.state === "unknown")
+            lines.push(`Checkout removal could not be confirmed.${result.cleanup.error ? ` ${result.cleanup.error}` : ""} Use worktree_list to inspect the target; do not assume it can be re-entered.`);
+        else
+            lines.push(`Checkout kept at ${tree.path}: ${result.cleanup.reason ?? "removal_failed"}.${result.cleanup.error ? ` ${result.cleanup.error}` : ""} Re-enter it with worktree_enter or retry archive after resolving the blocker.`);
+        if (result.cleanup.performed && result.cleanup.error)
+            lines.push(`Checkout release was verified after an error: ${result.cleanup.error}`);
+        const message = lines.join("\n");
+        return {
+            title: "worktree_archive",
+            output: message,
+            metadata: {
+                action: "archived",
+                worktree: { id: tree.id, name: tree.name, path: tree.path, branch: tree.branch },
+                restored: result.restored,
+                cleanup: result.cleanup,
+                message,
+            },
+        };
+    },
+});

package/dist/project/tools/worktree-enter.js

@@ -0,0 +1,175 @@
+import z from "zod";
+import { Tool } from "@ericsanchezok/synergy-harness/tool/tool";
+import { Worktree } from "@ericsanchezok/synergy-local-runtime/workspace/worktree";
+import { ScopeContext } from "@ericsanchezok/synergy-harness/scope/context";
+import { PermissionNext } from "@ericsanchezok/synergy-harness/permission/next";
+import { EnforcementError } from "@ericsanchezok/synergy-harness/enforcement/errors";
+const parameters = z.object({
+    target: z.string().min(1).optional().describe("Target worktree name, ID, branch, or path to enter"),
+    baseRef: z
+        .enum(["current", "fresh"])
+        .optional()
+        .default("current")
+        .describe("Base reference for new worktree: current HEAD or fresh from origin"),
+    baseRevision: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Explicit git revision/ref/commit to create the worktree from. Overrides baseRef when provided."),
+    reason: z.string().optional().describe("Optional short note about why the worktree is being entered"),
+    force: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Force enter even if the current or target worktree has uncommitted changes"),
+});
+function buildWorkspaceMetadata(info) {
+    return {
+        type: "git_worktree",
+        path: info.path,
+        scopeID: info.scopeID,
+        worktreeID: info.id,
+        name: info.name,
+        branch: info.branch,
+        baseRef: info.baseRef,
+        baseRevision: info.baseRevision,
+        resolvedBaseCommit: info.resolvedBaseCommit,
+    };
+}
+function denialMetadata(action, reason, message) {
+    return {
+        title: "worktree_enter",
+        output: message,
+        metadata: { action: action, reason, message },
+    };
+}
+export const WorktreeEnterTool = Tool.define("worktree_enter", {
+    description: "Create or enter a git worktree for the current session. " +
+        "When already in a worktree, calling with a different 'target' switches to that worktree " +
+        "(leaving the current one). Calling with no 'target' switches to a new worktree. " +
+        "When 'target' matches an existing worktree (by name, ID, branch, or path), enter that worktree. " +
+        "When no match is found, create a new worktree using 'target' as the name. " +
+        "Omit 'target' to create a new worktree with an auto-generated unique name.",
+    parameters,
+    async execute(params, ctx) {
+        const currentWorkspace = ScopeContext.current.workspace;
+        if (currentWorkspace?.type === "git_worktree") {
+            const cw = currentWorkspace;
+            const currentName = (cw.name ?? cw.worktreeID ?? cw.path ?? "unknown");
+            const currentPath = cw.path;
+            const currentID = cw.worktreeID;
+            const currentBranch = cw.branch;
+            // Noop: target matches current worktree
+            if (params.target) {
+                const t = params.target;
+                if (t === currentID || t === currentName || t === currentPath || (currentBranch && t === currentBranch)) {
+                    return {
+                        title: "worktree_enter",
+                        output: `Already in worktree "${currentName}" at ${currentPath}.`,
+                        metadata: {
+                            action: "entered",
+                            reason: "already_in_this_worktree",
+                            created: false,
+                            message: `Session is already in worktree "${currentName}".`,
+                            worktree: undefined,
+                            workspace: currentWorkspace,
+                        },
+                    };
+                }
+            }
+            // Switching: refuse if current worktree is dirty and force not set
+            const st = await Worktree.status(ctx.sessionID);
+            if (st.dirty !== false && !params.force) {
+                return denialMetadata("denied", "current_dirty", `Current worktree "${currentName}" has uncommitted changes. Use 'force' to switch without saving.`);
+            }
+            await Worktree.leave(ctx.sessionID);
+        }
+        try {
+            await ctx.ask({
+                permission: "worktree_enter",
+                patterns: [params.target ?? "*"],
+                metadata: {
+                    target: params.target,
+                    baseRef: params.baseRef,
+                    baseRevision: params.baseRevision,
+                    reason: params.reason,
+                },
+            });
+        }
+        catch (error) {
+            if (error instanceof PermissionNext.RejectedError ||
+                error instanceof PermissionNext.CorrectedError ||
+                error instanceof PermissionNext.DeniedError ||
+                error instanceof EnforcementError.PolicyDenied) {
+                return denialMetadata("denied", "user_denied", error instanceof PermissionNext.CorrectedError ? error.message : "User declined worktree for this task.");
+            }
+            throw error;
+        }
+        if (params.target) {
+            try {
+                const worktrees = await Worktree.list();
+                const match = worktrees.find((wt) => wt.id === params.target ||
+                    wt.name === params.target ||
+                    wt.branch === params.target ||
+                    wt.path === params.target);
+                if (match) {
+                    const entered = await Worktree.enter({
+                        sessionID: ctx.sessionID,
+                        target: params.target,
+                        force: params.force,
+                    });
+                    return {
+                        title: "worktree_enter",
+                        output: `Entered existing worktree "${entered.name}" at ${entered.path}.`,
+                        metadata: {
+                            action: "entered",
+                            created: false,
+                            message: `Entered existing worktree "${entered.name}".`,
+                            worktree: entered,
+                            workspace: buildWorkspaceMetadata(entered),
+                        },
+                    };
+                }
+            }
+            catch (error) {
+                if (error instanceof Worktree.NotGitError) {
+                    return denialMetadata("denied", "not_git_scope", "Current scope is not a Git repository; git worktree is unavailable.");
+                }
+                throw error;
+            }
+        }
+        try {
+            const created = await Worktree.create({
+                name: params.target,
+                sessionID: ctx.sessionID,
+                baseRef: params.baseRef,
+                baseRevision: params.baseRevision,
+                bind: true,
+            });
+            const baseLabel = params.baseRevision ?? `${params.baseRef} base`;
+            return {
+                title: "worktree_enter",
+                output: `Created and entered worktree "${created.name}" at ${created.path}.`,
+                metadata: {
+                    action: "entered",
+                    created: true,
+                    message: `Created new worktree "${created.name}" from ${baseLabel}.`,
+                    worktree: created,
+                    workspace: buildWorkspaceMetadata(created),
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof Worktree.NotGitError) {
+                return denialMetadata("denied", "not_git_scope", "Current scope is not a Git repository; git worktree is unavailable.");
+            }
+            if (error instanceof Worktree.NameGenerationFailedError ||
+                error instanceof Worktree.CreateFailedError ||
+                error instanceof Worktree.SetupConfigError ||
+                error instanceof Worktree.StartCommandFailedError) {
+                return denialMetadata("denied", "setup_failed", error instanceof Error ? error.message : "Worktree setup failed.");
+            }
+            throw error;
+        }
+    },
+});

package/dist/project/tools/worktree-leave.js

@@ -0,0 +1,119 @@
+import z from "zod";
+import { Tool } from "@ericsanchezok/synergy-harness/tool/tool";
+import { Worktree } from "@ericsanchezok/synergy-local-runtime/workspace/worktree";
+import { ScopeContext } from "@ericsanchezok/synergy-harness/scope/context";
+import { PermissionNext } from "@ericsanchezok/synergy-harness/permission/next";
+const parameters = z.object({
+    cleanup: z
+        .enum(["keep", "remove_if_clean"])
+        .optional()
+        .default("keep")
+        .describe("Whether to destroy the worktree after leaving. 'keep' (default) leaves it in place. 'remove_if_clean' permanently deletes it when it has no uncommitted changes: the registry entry is removed, the branch is deleted when its content is already on the target branch, and worktree_enter cannot restore it. Use worktree_archive instead when the checkout may be needed again."),
+    reason: z.string().optional().describe("Optional short note about why the session is leaving the worktree"),
+});
+export const WorktreeLeaveTool = Tool.define("worktree_leave", {
+    description: "Leave the current git worktree and return to the main checkout. Unbinds the session from the worktree and " +
+        "restores the workspace to the main tree. The worktree stays on disk by default; the cleanup parameter can " +
+        "permanently delete it instead, and that deletion cannot be undone. Use worktree_archive when isolated work is " +
+        "finished and the checkout should stay restorable.",
+    parameters,
+    async execute(params, ctx) {
+        const workspace = ScopeContext.current.workspace;
+        if (!workspace || workspace.type !== "git_worktree") {
+            return {
+                title: "worktree_leave",
+                output: "Already on the main checkout. No worktree to leave.",
+                metadata: {
+                    action: "noop",
+                    reason: "already_on_main",
+                    message: "Already on the main checkout. No worktree to leave.",
+                },
+            };
+        }
+        const worktreeID = workspace.worktreeID;
+        const worktreePath = workspace.path;
+        const worktreeName = workspace.name;
+        // Tri-state: `undefined` means the dirty probe could not answer, which is
+        // not the same as "clean" and must not be reported as "dirty".
+        let dirtyState;
+        if (params.cleanup === "remove_if_clean") {
+            const st = await Worktree.status(ctx.sessionID);
+            dirtyState = st.dirty;
+        }
+        try {
+            await ctx.ask({
+                permission: "worktree_leave",
+                patterns: [worktreePath],
+                metadata: {
+                    previous: { type: workspace.type, path: worktreePath, name: worktreeName },
+                    cleanup: params.cleanup,
+                },
+            });
+        }
+        catch (error) {
+            if (error instanceof PermissionNext.RejectedError || error instanceof PermissionNext.DeniedError) {
+                return {
+                    title: "worktree_leave",
+                    output: "User declined leaving the worktree.",
+                    metadata: {
+                        action: "denied",
+                        reason: "user_denied",
+                        message: "User declined leaving the worktree.",
+                    },
+                };
+            }
+            throw error;
+        }
+        const previous = { type: workspace.type, path: worktreePath, name: worktreeName };
+        await Worktree.leave(ctx.sessionID);
+        const restored = { type: "main", path: ScopeContext.current.directory };
+        let cleanupResult = {
+            performed: false,
+        };
+        if (params.cleanup === "remove_if_clean" && worktreeID) {
+            if (dirtyState === false) {
+                try {
+                    // The turn issuing this call still holds the worktree's git lock and
+                    // use token, so removal must be told that the caller is its own turn.
+                    await Worktree.remove({ sessionID: ctx.sessionID, target: worktreeID, force: false }, { insideCallerTurn: true });
+                    cleanupResult = { performed: true };
+                }
+                catch (error) {
+                    // Leaving already succeeded, so a failed cleanup must not fail the
+                    // turn: mark the worktree for the janitor and report the reason.
+                    const message = error instanceof Error ? error.message : String(error);
+                    await Worktree.markLifecycle(worktreeID, "gc_candidate").catch(() => undefined);
+                    cleanupResult = { performed: false, error: message, cleanupDeferred: true };
+                }
+            }
+            else if (dirtyState === true) {
+                cleanupResult = { performed: false, skippedReason: "dirty" };
+            }
+            else {
+                cleanupResult = { performed: false, skippedReason: "unknown_dirty" };
+            }
+        }
+        const lines = [
+            `Left worktree "${worktreeName || worktreePath}" and returned to main checkout.`,
+            `Previous: ${worktreePath}`,
+            `Restored: ${restored.path}`,
+        ];
+        if (cleanupResult.performed) {
+            lines.push("Worktree removed (was clean).");
+        }
+        else if (cleanupResult.skippedReason === "dirty") {
+            lines.push("Worktree kept (has uncommitted changes).");
+        }
+        return {
+            title: "worktree_leave",
+            output: lines.join("\n"),
+            metadata: {
+                action: "left",
+                previous,
+                restored,
+                cleanup: cleanupResult,
+                message: lines.join("\n"),
+            },
+        };
+    },
+});

package/dist/project/tools/worktree-list.js

@@ -0,0 +1,52 @@
+import z from "zod";
+import { Tool } from "@ericsanchezok/synergy-harness/tool/tool";
+import { Worktree } from "@ericsanchezok/synergy-local-runtime/workspace/worktree";
+import { ScopeContext } from "@ericsanchezok/synergy-harness/scope/context";
+const parameters = z.object({});
+const description = "List all git worktrees in the current repository. Returns each worktree's path, branch, state, and a cleanup recommendation for non-main managed worktrees. The currently active worktree is marked.";
+export const WorktreeListTool = Tool.define("worktree_list", {
+    description,
+    parameters,
+    async execute(_params, _ctx) {
+        const worktrees = await Worktree.list();
+        const ws = ScopeContext.current.workspace;
+        const activeWt = ws ? (worktrees.find((wt) => wt.path === ws.path) ?? null) : null;
+        const enriched = worktrees.map((wt) => {
+            const recommendation = getCleanupRecommendation(wt, activeWt);
+            return { ...wt, cleanupRecommendation: recommendation };
+        });
+        const activeDisplay = activeWt
+            ? `${activeWt.name ?? activeWt.path}${activeWt.branch ? ` (${activeWt.branch})` : ""}`
+            : "none";
+        const message = `${worktrees.length} worktree${worktrees.length !== 1 ? "s" : ""} found. Active: ${activeDisplay}`;
+        return {
+            title: "worktree_list",
+            output: message,
+            metadata: {
+                action: "listed",
+                active: activeWt
+                    ? { id: activeWt.id, name: activeWt.name, path: activeWt.path, branch: activeWt.branch }
+                    : null,
+                worktrees: enriched,
+                message,
+            },
+        };
+    },
+});
+function getCleanupRecommendation(wt, active) {
+    if (active && wt.path === active.path)
+        return "keep";
+    if (wt.isMain)
+        return "keep";
+    if (!wt.managed)
+        return "external_do_not_manage";
+    if (wt.stale)
+        return "safe_to_remove";
+    // A lock Synergy did not write is never reclaimed, so surface it as a reason
+    // rather than letting the worktree look merely idle.
+    if (wt.locked !== undefined && !wt.locked.startsWith("synergy:v1:"))
+        return "locked_outside_synergy";
+    if (wt.dirty)
+        return "inspect_dirty";
+    return "keep";
+}

package/dist/project/tools.js

@@ -0,0 +1,26 @@
+import { RuntimeContext } from "@ericsanchezok/synergy-harness/lifecycle/context";
+import { ToolRegistry } from "@ericsanchezok/synergy-harness/tool/registry";
+import { SessionControlTool } from "./tools/session-control.js";
+import { WorktreeArchiveTool } from "./tools/worktree-archive.js";
+import { WorktreeEnterTool } from "./tools/worktree-enter.js";
+import { WorktreeLeaveTool } from "./tools/worktree-leave.js";
+import { WorktreeListTool } from "./tools/worktree-list.js";
+/**
+ * Project domain tool registration. Loaded through src/registration.ts.
+ */
+const runtimeState = RuntimeContext.state(() => ({
+    registered: false,
+}));
+export function registerProjectTools() {
+    const instanceState = runtimeState();
+    if (instanceState.registered)
+        return;
+    instanceState.registered = true;
+    ToolRegistry.registerToolProvider("project", () => [
+        SessionControlTool,
+        WorktreeEnterTool,
+        WorktreeLeaveTool,
+        WorktreeArchiveTool,
+        WorktreeListTool,
+    ]);
+}

package/dist/project/vcs-branch-watcher.js

@@ -0,0 +1,76 @@
+import path from "path";
+export var VcsBranchWatcher;
+(function (VcsBranchWatcher) {
+    function create(input) {
+        let branch;
+        let timer;
+        let inFlight;
+        let refreshPending = false;
+        let disposed = false;
+        const idleWaiters = new Set();
+        const settled = () => !timer && !inFlight;
+        const resolveIdle = () => {
+            if (!settled())
+                return;
+            for (const resolve of idleWaiters)
+                resolve();
+            idleWaiters.clear();
+        };
+        const refresh = () => {
+            if (disposed || inFlight)
+                return;
+            inFlight = Promise.resolve()
+                .then(async () => {
+                while (!disposed && refreshPending) {
+                    refreshPending = false;
+                    const previous = branch;
+                    const next = await input.resolve();
+                    branch = next;
+                    if (next !== previous)
+                        await input.onChange(next, previous);
+                }
+            })
+                .finally(() => {
+                inFlight = undefined;
+                if (!disposed && refreshPending)
+                    refresh();
+                resolveIdle();
+            });
+        };
+        return {
+            async start() {
+                branch = await input.resolve();
+                return branch;
+            },
+            current() {
+                return branch;
+            },
+            notify(file) {
+                if (disposed || path.basename(file) !== "HEAD")
+                    return;
+                refreshPending = true;
+                if (timer || inFlight)
+                    return;
+                timer = setTimeout(() => {
+                    timer = undefined;
+                    refresh();
+                }, input.debounceMs);
+            },
+            idle() {
+                if (settled())
+                    return Promise.resolve();
+                return new Promise((resolve) => idleWaiters.add(resolve));
+            },
+            async dispose() {
+                disposed = true;
+                if (timer)
+                    clearTimeout(timer);
+                refreshPending = false;
+                timer = undefined;
+                await inFlight;
+                resolveIdle();
+            },
+        };
+    }
+    VcsBranchWatcher.create = create;
+})(VcsBranchWatcher || (VcsBranchWatcher = {}));